4252 lines
123 KiB
TypeScript
4252 lines
123 KiB
TypeScript
import * as Apollo from "@apollo/client";
|
|
import { gql } from "@apollo/client";
|
|
export type Maybe<T> = T | null;
|
|
export type InputMaybe<T> = Maybe<T>;
|
|
export type Exact<T extends { [key: string]: unknown }> = {
|
|
[K in keyof T]: T[K];
|
|
};
|
|
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
[SubKey in K]?: Maybe<T[SubKey]>;
|
|
};
|
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
[SubKey in K]: Maybe<T[SubKey]>;
|
|
};
|
|
export type MakeEmpty<
|
|
T extends { [key: string]: unknown },
|
|
K extends keyof T,
|
|
> = { [_ in K]?: never };
|
|
export type Incremental<T> =
|
|
| T
|
|
| {
|
|
[P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
|
|
};
|
|
const defaultOptions = {} as const;
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: { input: string; output: string };
|
|
String: { input: string; output: string };
|
|
Boolean: { input: boolean; output: boolean };
|
|
Int: { input: number; output: number };
|
|
Float: { input: number; output: number };
|
|
/** Date with time (isoformat) */
|
|
DateTime: { input: any; output: any };
|
|
};
|
|
|
|
export type AggregateInputGql = {
|
|
aggregations: Array<AggregationInput>;
|
|
filterInput?: InputMaybe<FilterInput>;
|
|
};
|
|
|
|
export type AggregateResultGql = {
|
|
__typename?: "AggregateResultGQL";
|
|
aggregationIdentifiers: Array<AggregationIdentifierGql>;
|
|
targetMetrics: TargetMetricsGql;
|
|
};
|
|
|
|
export type AggregationIdentifierGql = {
|
|
__typename?: "AggregationIdentifierGQL";
|
|
featureName: Scalars["String"]["output"];
|
|
groupName: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type AggregationInput =
|
|
| { bucketSet: BucketSetInputGql; enum?: never }
|
|
| { bucketSet?: never; enum: EnumAggregation };
|
|
|
|
export type BankFeaturesGql = {
|
|
__typename?: "BankFeaturesGQL";
|
|
bankAngle: Scalars["Float"]["output"];
|
|
distance: Scalars["Float"]["output"];
|
|
wallsHit: Array<WallTypeEnum>;
|
|
};
|
|
|
|
export type BoundingBoxGql = {
|
|
__typename?: "BoundingBoxGQL";
|
|
height: Scalars["Float"]["output"];
|
|
left: Scalars["Float"]["output"];
|
|
top: Scalars["Float"]["output"];
|
|
width: Scalars["Float"]["output"];
|
|
};
|
|
|
|
export type BucketGql = {
|
|
__typename?: "BucketGQL";
|
|
lowerBound: Scalars["Float"]["output"];
|
|
rangeKey: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type BucketInputGql = {
|
|
lowerBound: Scalars["Float"]["input"];
|
|
rangeKey: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type BucketSetGql = {
|
|
__typename?: "BucketSetGQL";
|
|
buckets: Array<BucketGql>;
|
|
feature: Scalars["String"]["output"];
|
|
keyName: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type BucketSetInputGql = {
|
|
buckets: Array<BucketInputGql>;
|
|
feature: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type CreateBucketSetInput = {
|
|
buckets: Array<BucketInputGql>;
|
|
feature: Scalars["String"]["input"];
|
|
keyName: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type CreateUploadStreamReturn = {
|
|
__typename?: "CreateUploadStreamReturn";
|
|
videoId: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type CueObjectFeaturesGql = {
|
|
__typename?: "CueObjectFeaturesGQL";
|
|
cueBallSpeed?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectAngle?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
shotDirection?: Maybe<ShotDirectionEnum>;
|
|
};
|
|
|
|
export type DeployedConfigGql = {
|
|
__typename?: "DeployedConfigGQL";
|
|
allowNewUsers: Scalars["Boolean"]["output"];
|
|
devMode: Scalars["Boolean"]["output"];
|
|
environment: Scalars["String"]["output"];
|
|
firebase: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export enum DeviceTypeEnum {
|
|
Android = "ANDROID",
|
|
Browser = "BROWSER",
|
|
Ios = "IOS",
|
|
}
|
|
|
|
export type EnumAggregation = {
|
|
feature: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type FilterInput =
|
|
| {
|
|
andFilters: Array<FilterInput>;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations: Array<ShotAnnotationInput>;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle: RangeFilter;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance: RangeFilter;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject: RangeFilter;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed: RangeFilter;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle: RangeFilter;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance: RangeFilter;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject: RangeFilter;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty: RangeFilter;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore: RangeFilter;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType: Array<PocketEnum>;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect: Array<Scalars["Boolean"]["input"]>;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft: Array<Scalars["Boolean"]["input"]>;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss: Array<Scalars["Boolean"]["input"]>;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight: Array<Scalars["Boolean"]["input"]>;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss: Array<Scalars["Boolean"]["input"]>;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight: Array<Scalars["Boolean"]["input"]>;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle: RangeFilter;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance: RangeFilter;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make: Array<Scalars["Boolean"]["input"]>;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter: FilterInput;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters: Array<FilterInput>;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection: Array<ShotDirectionEnum>;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType: Array<Scalars["String"]["input"]>;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags: Array<VideoTagInput>;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance: RangeFilter;
|
|
userId?: never;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId: Array<Scalars["Int"]["input"]>;
|
|
videoId?: never;
|
|
}
|
|
| {
|
|
andFilters?: never;
|
|
annotations?: never;
|
|
bankAngle?: never;
|
|
bankDistance?: never;
|
|
cueAngleAfterObject?: never;
|
|
cueBallSpeed?: never;
|
|
cueObjectAngle?: never;
|
|
cueObjectDistance?: never;
|
|
cueSpeedAfterObject?: never;
|
|
difficulty?: never;
|
|
falsePositiveScore?: never;
|
|
intendedPocketType?: never;
|
|
isDirect?: never;
|
|
isLeft?: never;
|
|
isLeftMiss?: never;
|
|
isRight?: never;
|
|
isRightMiss?: never;
|
|
isStraight?: never;
|
|
kickAngle?: never;
|
|
kickDistance?: never;
|
|
make?: never;
|
|
notFilter?: never;
|
|
orFilters?: never;
|
|
shotDirection?: never;
|
|
spinType?: never;
|
|
tags?: never;
|
|
targetPocketDistance?: never;
|
|
userId?: never;
|
|
videoId: Array<Scalars["Int"]["input"]>;
|
|
};
|
|
|
|
export type GetUploadLinkReturn = {
|
|
__typename?: "GetUploadLinkReturn";
|
|
headers: Array<Maybe<Header>>;
|
|
uploadUrl: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type HlsPlaylistGql = {
|
|
__typename?: "HLSPlaylistGQL";
|
|
m3u8Text: Scalars["String"]["output"];
|
|
segmentDurations: Array<Scalars["Float"]["output"]>;
|
|
videoId: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type Header = {
|
|
__typename?: "Header";
|
|
key: Scalars["String"]["output"];
|
|
value: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type HomographyInfoGql = {
|
|
__typename?: "HomographyInfoGQL";
|
|
crop: BoundingBoxGql;
|
|
destPoints: PocketPointsGql;
|
|
frameIndex: Scalars["Int"]["output"];
|
|
pockets: Array<BoundingBoxGql>;
|
|
sourcePoints: PocketPointsGql;
|
|
};
|
|
|
|
export enum InitPlaylistUploadStatusEnum {
|
|
NotApplicable = "NOT_APPLICABLE",
|
|
NotUploaded = "NOT_UPLOADED",
|
|
Uploaded = "UPLOADED",
|
|
}
|
|
|
|
export type IntPoint2D = {
|
|
__typename?: "IntPoint2D";
|
|
x: Scalars["Int"]["output"];
|
|
y: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type MakePercentageIntervalGql = {
|
|
__typename?: "MakePercentageIntervalGQL";
|
|
elapsedTime: Scalars["Float"]["output"];
|
|
makePercentage: Scalars["Float"]["output"];
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: "Mutation";
|
|
createBucketSet: BucketSetGql;
|
|
createUploadStream: CreateUploadStreamReturn;
|
|
deleteVideo: Scalars["Boolean"]["output"];
|
|
editProfileImageUri: UserGql;
|
|
editUploadStream: Scalars["Boolean"]["output"];
|
|
getHlsInitUploadLink: GetUploadLinkReturn;
|
|
getProfileImageUploadLink: GetUploadLinkReturn;
|
|
getUploadLink: GetUploadLinkReturn;
|
|
setLoggerLevel: Scalars["Boolean"]["output"];
|
|
setSegmentDuration: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export type MutationCreateBucketSetArgs = {
|
|
params: CreateBucketSetInput;
|
|
};
|
|
|
|
export type MutationCreateUploadStreamArgs = {
|
|
videoMetadata: VideoMetadataInput;
|
|
};
|
|
|
|
export type MutationDeleteVideoArgs = {
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type MutationEditProfileImageUriArgs = {
|
|
profileImageUri: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type MutationEditUploadStreamArgs = {
|
|
videoId: Scalars["Int"]["input"];
|
|
videoMetadata: VideoMetadataInput;
|
|
};
|
|
|
|
export type MutationGetHlsInitUploadLinkArgs = {
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type MutationGetProfileImageUploadLinkArgs = {
|
|
fileExt?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type MutationGetUploadLinkArgs = {
|
|
segmentIndex: Scalars["Int"]["input"];
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type MutationSetLoggerLevelArgs = {
|
|
level: Scalars["String"]["input"];
|
|
path: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type MutationSetSegmentDurationArgs = {
|
|
duration: Scalars["Float"]["input"];
|
|
segmentIndex: Scalars["Int"]["input"];
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type PageInfoGql = {
|
|
__typename?: "PageInfoGQL";
|
|
endCursor?: Maybe<Scalars["String"]["output"]>;
|
|
hasNextPage: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export enum PocketEnum {
|
|
Corner = "CORNER",
|
|
Side = "SIDE",
|
|
}
|
|
|
|
export type PocketPointsGql = {
|
|
__typename?: "PocketPointsGQL";
|
|
bottomLeft: IntPoint2D;
|
|
bottomRight: IntPoint2D;
|
|
bottomSide: IntPoint2D;
|
|
topLeft: IntPoint2D;
|
|
topRight: IntPoint2D;
|
|
topSide: IntPoint2D;
|
|
};
|
|
|
|
export type PocketingIntentionFeaturesGql = {
|
|
__typename?: "PocketingIntentionFeaturesGQL";
|
|
difficulty?: Maybe<Scalars["Float"]["output"]>;
|
|
intendedPocketType?: Maybe<PocketEnum>;
|
|
make?: Maybe<Scalars["Boolean"]["output"]>;
|
|
targetPocketDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: "Query";
|
|
getAggregatedShotMetrics: Array<AggregateResultGql>;
|
|
getBucketSet?: Maybe<BucketSetGql>;
|
|
getDeployedConfig: DeployedConfigGql;
|
|
getLoggedInUser?: Maybe<UserGql>;
|
|
getPlayTime: UserPlayTimeGql;
|
|
getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
|
|
getShots: Array<ShotGql>;
|
|
getUser?: Maybe<UserGql>;
|
|
getUserTags: Array<TagGql>;
|
|
getUserVideos: VideoHistoryGql;
|
|
getUsernames: Array<Scalars["String"]["output"]>;
|
|
getVideo: VideoGql;
|
|
getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
|
|
getVideos: Array<VideoGql>;
|
|
};
|
|
|
|
export type QueryGetAggregatedShotMetricsArgs = {
|
|
aggregateInput: AggregateInputGql;
|
|
};
|
|
|
|
export type QueryGetBucketSetArgs = {
|
|
keyName: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type QueryGetPlayTimeArgs = {
|
|
userId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type QueryGetShotsArgs = {
|
|
filterInput: FilterInput;
|
|
};
|
|
|
|
export type QueryGetUserArgs = {
|
|
userId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type QueryGetUserVideosArgs = {
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
filters?: InputMaybe<VideoFilterInput>;
|
|
limit?: Scalars["Int"]["input"];
|
|
userId?: InputMaybe<Scalars["Int"]["input"]>;
|
|
};
|
|
|
|
export type QueryGetUsernamesArgs = {
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
limit?: InputMaybe<Scalars["Int"]["input"]>;
|
|
matchString?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type QueryGetVideoArgs = {
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type QueryGetVideoMakePercentageIntervalsArgs = {
|
|
intervalDuration?: Scalars["Int"]["input"];
|
|
videoId: Scalars["ID"]["input"];
|
|
};
|
|
|
|
export type QueryGetVideosArgs = {
|
|
videoIds: Array<Scalars["Int"]["input"]>;
|
|
};
|
|
|
|
export type RangeFilter = {
|
|
greaterThanEqualTo?: InputMaybe<Scalars["Float"]["input"]>;
|
|
includeOnNone?: Scalars["Boolean"]["input"];
|
|
lessThan?: InputMaybe<Scalars["Float"]["input"]>;
|
|
};
|
|
|
|
export type SerializedShotPathsGql = {
|
|
__typename?: "SerializedShotPathsGQL";
|
|
b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
|
|
};
|
|
|
|
export type ShotAnnotationGql = {
|
|
__typename?: "ShotAnnotationGQL";
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
creator: UserGql;
|
|
notes: Scalars["String"]["output"];
|
|
shotId: Scalars["Int"]["output"];
|
|
type: ShotAnnotationTypeGql;
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
};
|
|
|
|
export type ShotAnnotationInput = {
|
|
name: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type ShotAnnotationTypeGql = {
|
|
__typename?: "ShotAnnotationTypeGQL";
|
|
id: Scalars["Int"]["output"];
|
|
name: Scalars["String"]["output"];
|
|
};
|
|
|
|
export enum ShotDirectionEnum {
|
|
Left = "LEFT",
|
|
Right = "RIGHT",
|
|
Straight = "STRAIGHT",
|
|
}
|
|
|
|
export type ShotGql = {
|
|
__typename?: "ShotGQL";
|
|
annotations: Array<ShotAnnotationGql>;
|
|
bankFeatures?: Maybe<BankFeaturesGql>;
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
|
|
endFrame: Scalars["Int"]["output"];
|
|
falsePositiveScore?: Maybe<Scalars["Float"]["output"]>;
|
|
id: Scalars["Int"]["output"];
|
|
pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
|
|
serializedShotPaths?: Maybe<SerializedShotPathsGql>;
|
|
startFrame: Scalars["Int"]["output"];
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
user?: Maybe<UserGql>;
|
|
videoId: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type StreamErrorGql = {
|
|
__typename?: "StreamErrorGQL";
|
|
message: Scalars["String"]["output"];
|
|
};
|
|
|
|
export enum StreamSegmentTypeEnum {
|
|
FragmentedMp4 = "FRAGMENTED_MP4",
|
|
RbChunkedMp4 = "RB_CHUNKED_MP4",
|
|
}
|
|
|
|
export type TagGql = {
|
|
__typename?: "TagGQL";
|
|
group?: Maybe<Scalars["String"]["output"]>;
|
|
id: Scalars["Int"]["output"];
|
|
name: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type TargetMetricsGql = {
|
|
__typename?: "TargetMetricsGQL";
|
|
averageDifficulty?: Maybe<Scalars["Float"]["output"]>;
|
|
count: Scalars["Int"]["output"];
|
|
makePercentage?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type UploadSegmentGql = {
|
|
__typename?: "UploadSegmentGQL";
|
|
durationInSeconds?: Maybe<Scalars["Float"]["output"]>;
|
|
endFrameIndex?: Maybe<Scalars["Int"]["output"]>;
|
|
framesPerSecond?: Maybe<Scalars["Float"]["output"]>;
|
|
linksRequested: Scalars["Int"]["output"];
|
|
segmentIndex: Scalars["Int"]["output"];
|
|
uploaded: Scalars["Boolean"]["output"];
|
|
valid: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export type UploadStreamGql = {
|
|
__typename?: "UploadStreamGQL";
|
|
createdAt: Scalars["DateTime"]["output"];
|
|
errors: Array<StreamErrorGql>;
|
|
id: Scalars["ID"]["output"];
|
|
initPlaylistUploadStatus?: Maybe<InitPlaylistUploadStatusEnum>;
|
|
isCompleted: Scalars["Boolean"]["output"];
|
|
lastIntendedSegmentBound?: Maybe<Scalars["Int"]["output"]>;
|
|
linksRequested: Scalars["Int"]["output"];
|
|
lowestUnuploadedSegmentIndex: Scalars["Int"]["output"];
|
|
resolution: VideoResolutionGql;
|
|
segmentProcessingCursor: Scalars["Int"]["output"];
|
|
segments: Array<UploadSegmentGql>;
|
|
streamSegmentType: StreamSegmentTypeEnum;
|
|
updatedAt: Scalars["DateTime"]["output"];
|
|
uploadCompletionCursor: Scalars["Int"]["output"];
|
|
uploadsCompleted: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type UploadStreamMetadataInput = {
|
|
appVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
browserName?: InputMaybe<Scalars["String"]["input"]>;
|
|
browserVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
deviceType?: InputMaybe<DeviceTypeEnum>;
|
|
ipAddress?: InputMaybe<Scalars["String"]["input"]>;
|
|
locale?: InputMaybe<Scalars["String"]["input"]>;
|
|
networkType?: InputMaybe<Scalars["String"]["input"]>;
|
|
osVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
timezone?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type UserGql = {
|
|
__typename?: "UserGQL";
|
|
activeVideoId?: Maybe<Scalars["Int"]["output"]>;
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
firebaseUid: Scalars["String"]["output"];
|
|
id: Scalars["Int"]["output"];
|
|
isAdmin: Scalars["Boolean"]["output"];
|
|
profileImageUri?: Maybe<Scalars["String"]["output"]>;
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
username: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type UserPlayTimeGql = {
|
|
__typename?: "UserPlayTimeGQL";
|
|
totalSeconds: Scalars["Float"]["output"];
|
|
};
|
|
|
|
export type VideoFilterInput = {
|
|
isStreamCompleted?: InputMaybe<Scalars["Boolean"]["input"]>;
|
|
requireCursorCompletion?: Scalars["Boolean"]["input"];
|
|
};
|
|
|
|
export type VideoGql = {
|
|
__typename?: "VideoGQL";
|
|
averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
currentProcessing?: Maybe<VideoProcessingGql>;
|
|
elapsedTime?: Maybe<Scalars["Float"]["output"]>;
|
|
endTime?: Maybe<Scalars["DateTime"]["output"]>;
|
|
framesPerSecond: Scalars["Float"]["output"];
|
|
homographyHistory: Array<HomographyInfoGql>;
|
|
id: Scalars["Int"]["output"];
|
|
makePercentage: Scalars["Float"]["output"];
|
|
medianRun?: Maybe<Scalars["Float"]["output"]>;
|
|
name?: Maybe<Scalars["String"]["output"]>;
|
|
owner?: Maybe<UserGql>;
|
|
playlist?: Maybe<HlsPlaylistGql>;
|
|
screenshotUri?: Maybe<Scalars["String"]["output"]>;
|
|
shots: Array<ShotGql>;
|
|
startTime?: Maybe<Scalars["DateTime"]["output"]>;
|
|
stream?: Maybe<UploadStreamGql>;
|
|
tags: Array<VideoTag>;
|
|
totalShots: Scalars["Int"]["output"];
|
|
totalShotsMade: Scalars["Int"]["output"];
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
};
|
|
|
|
export type VideoHistoryGql = {
|
|
__typename?: "VideoHistoryGQL";
|
|
pageInfo: PageInfoGql;
|
|
videos: Array<VideoGql>;
|
|
};
|
|
|
|
export type VideoMetadataInput = {
|
|
endStream?: Scalars["Boolean"]["input"];
|
|
endTime?: InputMaybe<Scalars["DateTime"]["input"]>;
|
|
framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
|
|
gameType?: InputMaybe<Scalars["String"]["input"]>;
|
|
lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
|
|
resolution?: InputMaybe<VideoResolution>;
|
|
startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
|
|
streamSegmentType?: InputMaybe<StreamSegmentTypeEnum>;
|
|
tableSize?: InputMaybe<Scalars["String"]["input"]>;
|
|
uploadStreamMetadataInput?: InputMaybe<UploadStreamMetadataInput>;
|
|
videoName?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type VideoProcessingErrorGql = {
|
|
__typename?: "VideoProcessingErrorGQL";
|
|
endSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
|
|
message: Scalars["String"]["output"];
|
|
startSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
|
|
};
|
|
|
|
export type VideoProcessingGql = {
|
|
__typename?: "VideoProcessingGQL";
|
|
errors: Array<VideoProcessingErrorGql>;
|
|
};
|
|
|
|
export type VideoResolution = {
|
|
height: Scalars["Int"]["input"];
|
|
width: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type VideoResolutionGql = {
|
|
__typename?: "VideoResolutionGQL";
|
|
height?: Maybe<Scalars["Int"]["output"]>;
|
|
width?: Maybe<Scalars["Int"]["output"]>;
|
|
};
|
|
|
|
export type VideoTag = {
|
|
__typename?: "VideoTag";
|
|
name: Scalars["String"]["output"];
|
|
tagClasses: Array<VideoTagClass>;
|
|
};
|
|
|
|
export type VideoTagClass = {
|
|
__typename?: "VideoTagClass";
|
|
name: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type VideoTagClassInput = {
|
|
name: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type VideoTagInput = {
|
|
name: Scalars["String"]["input"];
|
|
tagClasses?: Array<VideoTagClassInput>;
|
|
};
|
|
|
|
export enum WallTypeEnum {
|
|
Long = "LONG",
|
|
Short = "SHORT",
|
|
}
|
|
|
|
export type GetAggregatedShotMetricsQueryVariables = Exact<{
|
|
aggregateInput: AggregateInputGql;
|
|
}>;
|
|
|
|
export type GetAggregatedShotMetricsQuery = {
|
|
__typename?: "Query";
|
|
getAggregatedShotMetrics: Array<{
|
|
__typename?: "AggregateResultGQL";
|
|
aggregationIdentifiers: Array<{
|
|
__typename?: "AggregationIdentifierGQL";
|
|
featureName: string;
|
|
groupName: string;
|
|
}>;
|
|
targetMetrics: {
|
|
__typename?: "TargetMetricsGQL";
|
|
count: number;
|
|
makePercentage?: number | null;
|
|
};
|
|
}>;
|
|
};
|
|
|
|
export type GetDeployedConfigQueryVariables = Exact<{ [key: string]: never }>;
|
|
|
|
export type GetDeployedConfigQuery = {
|
|
__typename?: "Query";
|
|
getDeployedConfig: {
|
|
__typename?: "DeployedConfigGQL";
|
|
allowNewUsers: boolean;
|
|
devMode: boolean;
|
|
environment: string;
|
|
firebase: boolean;
|
|
};
|
|
};
|
|
|
|
export type GetFeedQueryVariables = Exact<{
|
|
limit?: Scalars["Int"]["input"];
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
filters?: InputMaybe<VideoFilterInput>;
|
|
}>;
|
|
|
|
export type GetFeedQuery = {
|
|
__typename?: "Query";
|
|
getUserVideos: {
|
|
__typename?: "VideoHistoryGQL";
|
|
videos: Array<{
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
name?: string | null;
|
|
screenshotUri?: string | null;
|
|
totalShotsMade: number;
|
|
totalShots: number;
|
|
makePercentage: number;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
startTime?: any | null;
|
|
endTime?: any | null;
|
|
elapsedTime?: number | null;
|
|
owner?: { __typename?: "UserGQL"; username: string } | null;
|
|
stream?: { __typename?: "UploadStreamGQL"; isCompleted: boolean } | null;
|
|
tags: Array<{
|
|
__typename?: "VideoTag";
|
|
name: string;
|
|
tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
|
|
}>;
|
|
}>;
|
|
pageInfo: {
|
|
__typename?: "PageInfoGQL";
|
|
hasNextPage: boolean;
|
|
endCursor?: string | null;
|
|
};
|
|
};
|
|
};
|
|
|
|
export type GetVideoMakePercentageIntervalsQueryVariables = Exact<{
|
|
videoId: Scalars["ID"]["input"];
|
|
intervalDuration: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideoMakePercentageIntervalsQuery = {
|
|
__typename?: "Query";
|
|
getVideoMakePercentageIntervals: Array<{
|
|
__typename?: "MakePercentageIntervalGQL";
|
|
makePercentage: number;
|
|
elapsedTime: number;
|
|
}>;
|
|
};
|
|
|
|
export type GetShotsQueryVariables = Exact<{
|
|
filterInput: FilterInput;
|
|
includeCreatedAt?: Scalars["Boolean"]["input"];
|
|
includeUpdatedAt?: Scalars["Boolean"]["input"];
|
|
includeCueObjectFeatures?: Scalars["Boolean"]["input"];
|
|
includePocketingIntentionFeatures?: Scalars["Boolean"]["input"];
|
|
includeCueObjectDistance?: Scalars["Boolean"]["input"];
|
|
includeCueObjectAngle?: Scalars["Boolean"]["input"];
|
|
includeCueBallSpeed?: Scalars["Boolean"]["input"];
|
|
includeShotDirection?: Scalars["Boolean"]["input"];
|
|
includeTargetPocketDistance?: Scalars["Boolean"]["input"];
|
|
includeMake?: Scalars["Boolean"]["input"];
|
|
includeIntendedPocketType?: Scalars["Boolean"]["input"];
|
|
}>;
|
|
|
|
export type GetShotsQuery = {
|
|
__typename?: "Query";
|
|
getShots: Array<{
|
|
__typename?: "ShotGQL";
|
|
id: number;
|
|
videoId: number;
|
|
startFrame: number;
|
|
endFrame: number;
|
|
falsePositiveScore?: number | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
user?: { __typename?: "UserGQL"; id: number } | null;
|
|
cueObjectFeatures?: {
|
|
__typename?: "CueObjectFeaturesGQL";
|
|
cueObjectDistance?: number | null;
|
|
cueObjectAngle?: number | null;
|
|
cueBallSpeed?: number | null;
|
|
shotDirection?: ShotDirectionEnum | null;
|
|
} | null;
|
|
pocketingIntentionFeatures?: {
|
|
__typename?: "PocketingIntentionFeaturesGQL";
|
|
targetPocketDistance?: number | null;
|
|
make?: boolean | null;
|
|
intendedPocketType?: PocketEnum | null;
|
|
} | null;
|
|
}>;
|
|
};
|
|
|
|
export type GetShotAnnotationTypesQueryVariables = Exact<{
|
|
[key: string]: never;
|
|
}>;
|
|
|
|
export type GetShotAnnotationTypesQuery = {
|
|
__typename?: "Query";
|
|
getShotAnnotationTypes: Array<{
|
|
__typename?: "ShotAnnotationTypeGQL";
|
|
id: number;
|
|
name: string;
|
|
}>;
|
|
};
|
|
|
|
export type GetProfileImageUploadLinkMutationVariables = Exact<{
|
|
fileExt?: InputMaybe<Scalars["String"]["input"]>;
|
|
}>;
|
|
|
|
export type GetProfileImageUploadLinkMutation = {
|
|
__typename?: "Mutation";
|
|
getProfileImageUploadLink: {
|
|
__typename?: "GetUploadLinkReturn";
|
|
uploadUrl: string;
|
|
headers: Array<{
|
|
__typename?: "Header";
|
|
key: string;
|
|
value: string;
|
|
} | null>;
|
|
};
|
|
};
|
|
|
|
export type EditProfileImageUriMutationVariables = Exact<{
|
|
profileImageUri: Scalars["String"]["input"];
|
|
}>;
|
|
|
|
export type EditProfileImageUriMutation = {
|
|
__typename?: "Mutation";
|
|
editProfileImageUri: {
|
|
__typename?: "UserGQL";
|
|
id: number;
|
|
firebaseUid: string;
|
|
username: string;
|
|
profileImageUri?: string | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
};
|
|
};
|
|
|
|
export type GetLoggedInUserQueryVariables = Exact<{ [key: string]: never }>;
|
|
|
|
export type GetLoggedInUserQuery = {
|
|
__typename?: "Query";
|
|
getLoggedInUser?: {
|
|
__typename?: "UserGQL";
|
|
id: number;
|
|
firebaseUid: string;
|
|
username: string;
|
|
isAdmin: boolean;
|
|
profileImageUri?: string | null;
|
|
activeVideoId?: number | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
} | null;
|
|
};
|
|
|
|
export type GetUserPlayTimeQueryVariables = Exact<{
|
|
userId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetUserPlayTimeQuery = {
|
|
__typename?: "Query";
|
|
getPlayTime: { __typename?: "UserPlayTimeGQL"; totalSeconds: number };
|
|
};
|
|
|
|
export type GetUsernamesQueryVariables = Exact<{
|
|
matchString: Scalars["String"]["input"];
|
|
limit?: InputMaybe<Scalars["Int"]["input"]>;
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
}>;
|
|
|
|
export type GetUsernamesQuery = {
|
|
__typename?: "Query";
|
|
getUsernames: Array<string>;
|
|
};
|
|
|
|
export type GetStreamMonitoringDetailsQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetStreamMonitoringDetailsQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
totalShots: number;
|
|
makePercentage: number;
|
|
elapsedTime?: number | null;
|
|
homographyHistory: Array<{
|
|
__typename?: "HomographyInfoGQL";
|
|
crop: {
|
|
__typename?: "BoundingBoxGQL";
|
|
left: number;
|
|
top: number;
|
|
width: number;
|
|
height: number;
|
|
};
|
|
pockets: Array<{
|
|
__typename?: "BoundingBoxGQL";
|
|
left: number;
|
|
top: number;
|
|
width: number;
|
|
height: number;
|
|
}>;
|
|
sourcePoints: {
|
|
__typename?: "PocketPointsGQL";
|
|
topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
topSide: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
topRight: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
};
|
|
}>;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
linksRequested: number;
|
|
uploadsCompleted: number;
|
|
segmentProcessingCursor: number;
|
|
isCompleted: boolean;
|
|
uploadCompletionCursor: number;
|
|
lastIntendedSegmentBound?: number | null;
|
|
initPlaylistUploadStatus?: InitPlaylistUploadStatusEnum | null;
|
|
} | null;
|
|
currentProcessing?: {
|
|
__typename?: "VideoProcessingGQL";
|
|
errors: Array<{
|
|
__typename?: "VideoProcessingErrorGQL";
|
|
message: string;
|
|
startSegmentIndex?: number | null;
|
|
endSegmentIndex?: number | null;
|
|
}>;
|
|
} | null;
|
|
};
|
|
};
|
|
|
|
export type GetVideoUpdatePageDetailsQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideoUpdatePageDetailsQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
name?: string | null;
|
|
totalShots: number;
|
|
makePercentage: number;
|
|
elapsedTime?: number | null;
|
|
tags: Array<{
|
|
__typename?: "VideoTag";
|
|
name: string;
|
|
tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
|
|
}>;
|
|
};
|
|
};
|
|
|
|
export type DeleteVideoMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type DeleteVideoMutation = {
|
|
__typename?: "Mutation";
|
|
deleteVideo: boolean;
|
|
};
|
|
|
|
export type GetVideoDetailsQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideoDetailsQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
name?: string | null;
|
|
screenshotUri?: string | null;
|
|
averageTimeBetweenShots?: number | null;
|
|
elapsedTime?: number | null;
|
|
endTime?: any | null;
|
|
makePercentage: number;
|
|
medianRun?: number | null;
|
|
startTime?: any | null;
|
|
totalShots: number;
|
|
totalShotsMade: number;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
owner?: {
|
|
__typename?: "UserGQL";
|
|
id: number;
|
|
firebaseUid: string;
|
|
username: string;
|
|
profileImageUri?: string | null;
|
|
} | null;
|
|
tags: Array<{
|
|
__typename?: "VideoTag";
|
|
name: string;
|
|
tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
|
|
}>;
|
|
};
|
|
};
|
|
|
|
export type GetVideosQueryVariables = Exact<{
|
|
videoIds: Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideosQuery = {
|
|
__typename?: "Query";
|
|
getVideos: Array<{
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
playlist?: {
|
|
__typename?: "HLSPlaylistGQL";
|
|
segmentDurations: Array<number>;
|
|
} | null;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
id: string;
|
|
segments: Array<{
|
|
__typename?: "UploadSegmentGQL";
|
|
uploaded: boolean;
|
|
valid: boolean;
|
|
segmentIndex: number;
|
|
endFrameIndex?: number | null;
|
|
framesPerSecond?: number | null;
|
|
}>;
|
|
} | null;
|
|
}>;
|
|
};
|
|
|
|
export type GetVideoQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideoQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
playlist?: {
|
|
__typename?: "HLSPlaylistGQL";
|
|
segmentDurations: Array<number>;
|
|
} | null;
|
|
homographyHistory: Array<{
|
|
__typename?: "HomographyInfoGQL";
|
|
crop: {
|
|
__typename?: "BoundingBoxGQL";
|
|
left: number;
|
|
top: number;
|
|
width: number;
|
|
height: number;
|
|
};
|
|
pockets: Array<{
|
|
__typename?: "BoundingBoxGQL";
|
|
left: number;
|
|
top: number;
|
|
width: number;
|
|
height: number;
|
|
}>;
|
|
sourcePoints: {
|
|
__typename?: "PocketPointsGQL";
|
|
topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
topSide: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
topRight: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
|
|
};
|
|
}>;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
streamSegmentType: StreamSegmentTypeEnum;
|
|
segments: Array<{
|
|
__typename?: "UploadSegmentGQL";
|
|
segmentIndex: number;
|
|
endFrameIndex?: number | null;
|
|
framesPerSecond?: number | null;
|
|
}>;
|
|
resolution: {
|
|
__typename?: "VideoResolutionGQL";
|
|
width?: number | null;
|
|
height?: number | null;
|
|
};
|
|
} | null;
|
|
};
|
|
};
|
|
|
|
export type GetAverageTimePerShotForVideoQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetAverageTimePerShotForVideoQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
averageTimeBetweenShots?: number | null;
|
|
};
|
|
};
|
|
|
|
export type GetElapsedTimeForVideoQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetElapsedTimeForVideoQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
elapsedTime?: number | null;
|
|
};
|
|
};
|
|
|
|
export type GetMedianRunForVideoQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetMedianRunForVideoQuery = {
|
|
__typename?: "Query";
|
|
getVideo: { __typename?: "VideoGQL"; id: number; medianRun?: number | null };
|
|
};
|
|
|
|
export type GetVideoForClipTimesQueryVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetVideoForClipTimesQuery = {
|
|
__typename?: "Query";
|
|
getVideo: {
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
playlist?: {
|
|
__typename?: "HLSPlaylistGQL";
|
|
segmentDurations: Array<number>;
|
|
} | null;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
id: string;
|
|
streamSegmentType: StreamSegmentTypeEnum;
|
|
segments: Array<{
|
|
__typename?: "UploadSegmentGQL";
|
|
uploaded: boolean;
|
|
valid: boolean;
|
|
segmentIndex: number;
|
|
endFrameIndex?: number | null;
|
|
framesPerSecond?: number | null;
|
|
}>;
|
|
} | null;
|
|
};
|
|
};
|
|
|
|
export type CreateUploadStreamMutationVariables = Exact<{
|
|
videoMetadataInput: VideoMetadataInput;
|
|
}>;
|
|
|
|
export type CreateUploadStreamMutation = {
|
|
__typename?: "Mutation";
|
|
createUploadStream: {
|
|
__typename?: "CreateUploadStreamReturn";
|
|
videoId: number;
|
|
};
|
|
};
|
|
|
|
export type GetUploadLinkMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
segmentIndex: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetUploadLinkMutation = {
|
|
__typename?: "Mutation";
|
|
getUploadLink: {
|
|
__typename?: "GetUploadLinkReturn";
|
|
uploadUrl: string;
|
|
headers: Array<{
|
|
__typename?: "Header";
|
|
key: string;
|
|
value: string;
|
|
} | null>;
|
|
};
|
|
};
|
|
|
|
export type GetHlsInitUploadLinkMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
}>;
|
|
|
|
export type GetHlsInitUploadLinkMutation = {
|
|
__typename?: "Mutation";
|
|
getHlsInitUploadLink: {
|
|
__typename?: "GetUploadLinkReturn";
|
|
uploadUrl: string;
|
|
headers: Array<{
|
|
__typename?: "Header";
|
|
key: string;
|
|
value: string;
|
|
} | null>;
|
|
};
|
|
};
|
|
|
|
export type SetSegmentDurationMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
segmentIndex: Scalars["Int"]["input"];
|
|
duration: Scalars["Float"]["input"];
|
|
}>;
|
|
|
|
export type SetSegmentDurationMutation = {
|
|
__typename?: "Mutation";
|
|
setSegmentDuration: boolean;
|
|
};
|
|
|
|
export type EditUploadStreamMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
videoMetadataInput: VideoMetadataInput;
|
|
}>;
|
|
|
|
export type EditUploadStreamMutation = {
|
|
__typename?: "Mutation";
|
|
editUploadStream: boolean;
|
|
};
|
|
|
|
export type GetUploadStreamsQueryVariables = Exact<{
|
|
limit?: Scalars["Int"]["input"];
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
filters?: InputMaybe<VideoFilterInput>;
|
|
}>;
|
|
|
|
export type GetUploadStreamsQuery = {
|
|
__typename?: "Query";
|
|
getUserVideos: {
|
|
__typename?: "VideoHistoryGQL";
|
|
videos: Array<{ __typename?: "VideoGQL"; id: number }>;
|
|
pageInfo: {
|
|
__typename?: "PageInfoGQL";
|
|
hasNextPage: boolean;
|
|
endCursor?: string | null;
|
|
};
|
|
};
|
|
};
|
|
|
|
export type GetUploadStreamsWithDetailsQueryVariables = Exact<{
|
|
limit?: Scalars["Int"]["input"];
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
filters?: InputMaybe<VideoFilterInput>;
|
|
}>;
|
|
|
|
export type GetUploadStreamsWithDetailsQuery = {
|
|
__typename?: "Query";
|
|
getUserVideos: {
|
|
__typename?: "VideoHistoryGQL";
|
|
videos: Array<{
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
name?: string | null;
|
|
startTime?: any | null;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
isCompleted: boolean;
|
|
lastIntendedSegmentBound?: number | null;
|
|
uploadCompletionCursor: number;
|
|
} | null;
|
|
}>;
|
|
pageInfo: {
|
|
__typename?: "PageInfoGQL";
|
|
hasNextPage: boolean;
|
|
endCursor?: string | null;
|
|
};
|
|
};
|
|
};
|
|
|
|
export const GetAggregatedShotMetricsDocument = gql`
|
|
query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
|
|
getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
|
|
aggregationIdentifiers {
|
|
featureName
|
|
groupName
|
|
}
|
|
targetMetrics {
|
|
count
|
|
makePercentage
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetAggregatedShotMetricsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetAggregatedShotMetricsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetAggregatedShotMetricsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetAggregatedShotMetricsQuery({
|
|
* variables: {
|
|
* aggregateInput: // value for 'aggregateInput'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetAggregatedShotMetricsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>(GetAggregatedShotMetricsDocument, options);
|
|
}
|
|
export function useGetAggregatedShotMetricsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>(GetAggregatedShotMetricsDocument, options);
|
|
}
|
|
export function useGetAggregatedShotMetricsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>(GetAggregatedShotMetricsDocument, options);
|
|
}
|
|
export type GetAggregatedShotMetricsQueryHookResult = ReturnType<
|
|
typeof useGetAggregatedShotMetricsQuery
|
|
>;
|
|
export type GetAggregatedShotMetricsLazyQueryHookResult = ReturnType<
|
|
typeof useGetAggregatedShotMetricsLazyQuery
|
|
>;
|
|
export type GetAggregatedShotMetricsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetAggregatedShotMetricsSuspenseQuery
|
|
>;
|
|
export type GetAggregatedShotMetricsQueryResult = Apollo.QueryResult<
|
|
GetAggregatedShotMetricsQuery,
|
|
GetAggregatedShotMetricsQueryVariables
|
|
>;
|
|
export const GetDeployedConfigDocument = gql`
|
|
query getDeployedConfig {
|
|
getDeployedConfig {
|
|
allowNewUsers
|
|
devMode
|
|
environment
|
|
firebase
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetDeployedConfigQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetDeployedConfigQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetDeployedConfigQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetDeployedConfigQuery({
|
|
* variables: {
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetDeployedConfigQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>(GetDeployedConfigDocument, options);
|
|
}
|
|
export function useGetDeployedConfigLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>(GetDeployedConfigDocument, options);
|
|
}
|
|
export function useGetDeployedConfigSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>(GetDeployedConfigDocument, options);
|
|
}
|
|
export type GetDeployedConfigQueryHookResult = ReturnType<
|
|
typeof useGetDeployedConfigQuery
|
|
>;
|
|
export type GetDeployedConfigLazyQueryHookResult = ReturnType<
|
|
typeof useGetDeployedConfigLazyQuery
|
|
>;
|
|
export type GetDeployedConfigSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetDeployedConfigSuspenseQuery
|
|
>;
|
|
export type GetDeployedConfigQueryResult = Apollo.QueryResult<
|
|
GetDeployedConfigQuery,
|
|
GetDeployedConfigQueryVariables
|
|
>;
|
|
export const GetFeedDocument = gql`
|
|
query GetFeed(
|
|
$limit: Int! = 5
|
|
$after: String = null
|
|
$filters: VideoFilterInput = null
|
|
) {
|
|
getUserVideos(limit: $limit, after: $after, filters: $filters) {
|
|
videos {
|
|
id
|
|
owner {
|
|
username
|
|
}
|
|
name
|
|
screenshotUri
|
|
totalShotsMade
|
|
totalShots
|
|
makePercentage
|
|
createdAt
|
|
updatedAt
|
|
startTime
|
|
endTime
|
|
elapsedTime
|
|
screenshotUri
|
|
stream {
|
|
isCompleted
|
|
}
|
|
tags {
|
|
tagClasses {
|
|
name
|
|
}
|
|
name
|
|
}
|
|
}
|
|
pageInfo {
|
|
hasNextPage
|
|
endCursor
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetFeedQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetFeedQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetFeedQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetFeedQuery({
|
|
* variables: {
|
|
* limit: // value for 'limit'
|
|
* after: // value for 'after'
|
|
* filters: // value for 'filters'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetFeedQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<GetFeedQuery, GetFeedQueryVariables>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetFeedQuery, GetFeedQueryVariables>(
|
|
GetFeedDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetFeedLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetFeedQuery,
|
|
GetFeedQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<GetFeedQuery, GetFeedQueryVariables>(
|
|
GetFeedDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetFeedSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetFeedQuery,
|
|
GetFeedQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<GetFeedQuery, GetFeedQueryVariables>(
|
|
GetFeedDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type GetFeedQueryHookResult = ReturnType<typeof useGetFeedQuery>;
|
|
export type GetFeedLazyQueryHookResult = ReturnType<typeof useGetFeedLazyQuery>;
|
|
export type GetFeedSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetFeedSuspenseQuery
|
|
>;
|
|
export type GetFeedQueryResult = Apollo.QueryResult<
|
|
GetFeedQuery,
|
|
GetFeedQueryVariables
|
|
>;
|
|
export const GetVideoMakePercentageIntervalsDocument = gql`
|
|
query GetVideoMakePercentageIntervals(
|
|
$videoId: ID!
|
|
$intervalDuration: Int!
|
|
) {
|
|
getVideoMakePercentageIntervals(
|
|
videoId: $videoId
|
|
intervalDuration: $intervalDuration
|
|
) {
|
|
makePercentage
|
|
elapsedTime
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideoMakePercentageIntervalsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideoMakePercentageIntervalsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideoMakePercentageIntervalsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideoMakePercentageIntervalsQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* intervalDuration: // value for 'intervalDuration'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideoMakePercentageIntervalsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>(GetVideoMakePercentageIntervalsDocument, options);
|
|
}
|
|
export function useGetVideoMakePercentageIntervalsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>(GetVideoMakePercentageIntervalsDocument, options);
|
|
}
|
|
export function useGetVideoMakePercentageIntervalsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>(GetVideoMakePercentageIntervalsDocument, options);
|
|
}
|
|
export type GetVideoMakePercentageIntervalsQueryHookResult = ReturnType<
|
|
typeof useGetVideoMakePercentageIntervalsQuery
|
|
>;
|
|
export type GetVideoMakePercentageIntervalsLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideoMakePercentageIntervalsLazyQuery
|
|
>;
|
|
export type GetVideoMakePercentageIntervalsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideoMakePercentageIntervalsSuspenseQuery
|
|
>;
|
|
export type GetVideoMakePercentageIntervalsQueryResult = Apollo.QueryResult<
|
|
GetVideoMakePercentageIntervalsQuery,
|
|
GetVideoMakePercentageIntervalsQueryVariables
|
|
>;
|
|
export const GetShotsDocument = gql`
|
|
query GetShots(
|
|
$filterInput: FilterInput!
|
|
$includeCreatedAt: Boolean! = false
|
|
$includeUpdatedAt: Boolean! = false
|
|
$includeCueObjectFeatures: Boolean! = false
|
|
$includePocketingIntentionFeatures: Boolean! = false
|
|
$includeCueObjectDistance: Boolean! = false
|
|
$includeCueObjectAngle: Boolean! = false
|
|
$includeCueBallSpeed: Boolean! = false
|
|
$includeShotDirection: Boolean! = false
|
|
$includeTargetPocketDistance: Boolean! = false
|
|
$includeMake: Boolean! = false
|
|
$includeIntendedPocketType: Boolean! = false
|
|
) {
|
|
getShots(filterInput: $filterInput) {
|
|
id
|
|
videoId
|
|
startFrame
|
|
endFrame
|
|
user {
|
|
id
|
|
}
|
|
falsePositiveScore
|
|
createdAt @include(if: $includeCreatedAt)
|
|
updatedAt @include(if: $includeUpdatedAt)
|
|
cueObjectFeatures @include(if: $includeCueObjectFeatures) {
|
|
cueObjectDistance @include(if: $includeCueObjectDistance)
|
|
cueObjectAngle @include(if: $includeCueObjectAngle)
|
|
cueBallSpeed @include(if: $includeCueBallSpeed)
|
|
shotDirection @include(if: $includeShotDirection)
|
|
}
|
|
pocketingIntentionFeatures
|
|
@include(if: $includePocketingIntentionFeatures) {
|
|
targetPocketDistance @include(if: $includeTargetPocketDistance)
|
|
make @include(if: $includeMake)
|
|
intendedPocketType @include(if: $includeIntendedPocketType)
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetShotsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetShotsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetShotsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetShotsQuery({
|
|
* variables: {
|
|
* filterInput: // value for 'filterInput'
|
|
* includeCreatedAt: // value for 'includeCreatedAt'
|
|
* includeUpdatedAt: // value for 'includeUpdatedAt'
|
|
* includeCueObjectFeatures: // value for 'includeCueObjectFeatures'
|
|
* includePocketingIntentionFeatures: // value for 'includePocketingIntentionFeatures'
|
|
* includeCueObjectDistance: // value for 'includeCueObjectDistance'
|
|
* includeCueObjectAngle: // value for 'includeCueObjectAngle'
|
|
* includeCueBallSpeed: // value for 'includeCueBallSpeed'
|
|
* includeShotDirection: // value for 'includeShotDirection'
|
|
* includeTargetPocketDistance: // value for 'includeTargetPocketDistance'
|
|
* includeMake: // value for 'includeMake'
|
|
* includeIntendedPocketType: // value for 'includeIntendedPocketType'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetShotsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<GetShotsQuery, GetShotsQueryVariables>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetShotsQuery, GetShotsQueryVariables>(
|
|
GetShotsDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetShotsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetShotsQuery,
|
|
GetShotsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<GetShotsQuery, GetShotsQueryVariables>(
|
|
GetShotsDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetShotsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetShotsQuery,
|
|
GetShotsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<GetShotsQuery, GetShotsQueryVariables>(
|
|
GetShotsDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type GetShotsQueryHookResult = ReturnType<typeof useGetShotsQuery>;
|
|
export type GetShotsLazyQueryHookResult = ReturnType<
|
|
typeof useGetShotsLazyQuery
|
|
>;
|
|
export type GetShotsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetShotsSuspenseQuery
|
|
>;
|
|
export type GetShotsQueryResult = Apollo.QueryResult<
|
|
GetShotsQuery,
|
|
GetShotsQueryVariables
|
|
>;
|
|
export const GetShotAnnotationTypesDocument = gql`
|
|
query GetShotAnnotationTypes {
|
|
getShotAnnotationTypes {
|
|
id
|
|
name
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetShotAnnotationTypesQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetShotAnnotationTypesQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetShotAnnotationTypesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetShotAnnotationTypesQuery({
|
|
* variables: {
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetShotAnnotationTypesQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>(GetShotAnnotationTypesDocument, options);
|
|
}
|
|
export function useGetShotAnnotationTypesLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>(GetShotAnnotationTypesDocument, options);
|
|
}
|
|
export function useGetShotAnnotationTypesSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>(GetShotAnnotationTypesDocument, options);
|
|
}
|
|
export type GetShotAnnotationTypesQueryHookResult = ReturnType<
|
|
typeof useGetShotAnnotationTypesQuery
|
|
>;
|
|
export type GetShotAnnotationTypesLazyQueryHookResult = ReturnType<
|
|
typeof useGetShotAnnotationTypesLazyQuery
|
|
>;
|
|
export type GetShotAnnotationTypesSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetShotAnnotationTypesSuspenseQuery
|
|
>;
|
|
export type GetShotAnnotationTypesQueryResult = Apollo.QueryResult<
|
|
GetShotAnnotationTypesQuery,
|
|
GetShotAnnotationTypesQueryVariables
|
|
>;
|
|
export const GetProfileImageUploadLinkDocument = gql`
|
|
mutation getProfileImageUploadLink($fileExt: String = ".png") {
|
|
getProfileImageUploadLink(fileExt: $fileExt) {
|
|
uploadUrl
|
|
headers {
|
|
key
|
|
value
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
export type GetProfileImageUploadLinkMutationFn = Apollo.MutationFunction<
|
|
GetProfileImageUploadLinkMutation,
|
|
GetProfileImageUploadLinkMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useGetProfileImageUploadLinkMutation__
|
|
*
|
|
* To run a mutation, you first call `useGetProfileImageUploadLinkMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useGetProfileImageUploadLinkMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [getProfileImageUploadLinkMutation, { data, loading, error }] = useGetProfileImageUploadLinkMutation({
|
|
* variables: {
|
|
* fileExt: // value for 'fileExt'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetProfileImageUploadLinkMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
GetProfileImageUploadLinkMutation,
|
|
GetProfileImageUploadLinkMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
GetProfileImageUploadLinkMutation,
|
|
GetProfileImageUploadLinkMutationVariables
|
|
>(GetProfileImageUploadLinkDocument, options);
|
|
}
|
|
export type GetProfileImageUploadLinkMutationHookResult = ReturnType<
|
|
typeof useGetProfileImageUploadLinkMutation
|
|
>;
|
|
export type GetProfileImageUploadLinkMutationResult =
|
|
Apollo.MutationResult<GetProfileImageUploadLinkMutation>;
|
|
export type GetProfileImageUploadLinkMutationOptions =
|
|
Apollo.BaseMutationOptions<
|
|
GetProfileImageUploadLinkMutation,
|
|
GetProfileImageUploadLinkMutationVariables
|
|
>;
|
|
export const EditProfileImageUriDocument = gql`
|
|
mutation editProfileImageUri($profileImageUri: String!) {
|
|
editProfileImageUri(profileImageUri: $profileImageUri) {
|
|
id
|
|
firebaseUid
|
|
username
|
|
profileImageUri
|
|
createdAt
|
|
updatedAt
|
|
}
|
|
}
|
|
`;
|
|
export type EditProfileImageUriMutationFn = Apollo.MutationFunction<
|
|
EditProfileImageUriMutation,
|
|
EditProfileImageUriMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useEditProfileImageUriMutation__
|
|
*
|
|
* To run a mutation, you first call `useEditProfileImageUriMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useEditProfileImageUriMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [editProfileImageUriMutation, { data, loading, error }] = useEditProfileImageUriMutation({
|
|
* variables: {
|
|
* profileImageUri: // value for 'profileImageUri'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useEditProfileImageUriMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
EditProfileImageUriMutation,
|
|
EditProfileImageUriMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
EditProfileImageUriMutation,
|
|
EditProfileImageUriMutationVariables
|
|
>(EditProfileImageUriDocument, options);
|
|
}
|
|
export type EditProfileImageUriMutationHookResult = ReturnType<
|
|
typeof useEditProfileImageUriMutation
|
|
>;
|
|
export type EditProfileImageUriMutationResult =
|
|
Apollo.MutationResult<EditProfileImageUriMutation>;
|
|
export type EditProfileImageUriMutationOptions = Apollo.BaseMutationOptions<
|
|
EditProfileImageUriMutation,
|
|
EditProfileImageUriMutationVariables
|
|
>;
|
|
export const GetLoggedInUserDocument = gql`
|
|
query getLoggedInUser {
|
|
getLoggedInUser {
|
|
id
|
|
firebaseUid
|
|
username
|
|
isAdmin
|
|
profileImageUri
|
|
activeVideoId
|
|
createdAt
|
|
updatedAt
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetLoggedInUserQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetLoggedInUserQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetLoggedInUserQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetLoggedInUserQuery({
|
|
* variables: {
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetLoggedInUserQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>(
|
|
GetLoggedInUserDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetLoggedInUserLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>(GetLoggedInUserDocument, options);
|
|
}
|
|
export function useGetLoggedInUserSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>(GetLoggedInUserDocument, options);
|
|
}
|
|
export type GetLoggedInUserQueryHookResult = ReturnType<
|
|
typeof useGetLoggedInUserQuery
|
|
>;
|
|
export type GetLoggedInUserLazyQueryHookResult = ReturnType<
|
|
typeof useGetLoggedInUserLazyQuery
|
|
>;
|
|
export type GetLoggedInUserSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetLoggedInUserSuspenseQuery
|
|
>;
|
|
export type GetLoggedInUserQueryResult = Apollo.QueryResult<
|
|
GetLoggedInUserQuery,
|
|
GetLoggedInUserQueryVariables
|
|
>;
|
|
export const GetUserPlayTimeDocument = gql`
|
|
query GetUserPlayTime($userId: Int!) {
|
|
getPlayTime(userId: $userId) {
|
|
totalSeconds
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetUserPlayTimeQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetUserPlayTimeQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUserPlayTimeQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetUserPlayTimeQuery({
|
|
* variables: {
|
|
* userId: // value for 'userId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUserPlayTimeQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>(
|
|
GetUserPlayTimeDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetUserPlayTimeLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>(GetUserPlayTimeDocument, options);
|
|
}
|
|
export function useGetUserPlayTimeSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>(GetUserPlayTimeDocument, options);
|
|
}
|
|
export type GetUserPlayTimeQueryHookResult = ReturnType<
|
|
typeof useGetUserPlayTimeQuery
|
|
>;
|
|
export type GetUserPlayTimeLazyQueryHookResult = ReturnType<
|
|
typeof useGetUserPlayTimeLazyQuery
|
|
>;
|
|
export type GetUserPlayTimeSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetUserPlayTimeSuspenseQuery
|
|
>;
|
|
export type GetUserPlayTimeQueryResult = Apollo.QueryResult<
|
|
GetUserPlayTimeQuery,
|
|
GetUserPlayTimeQueryVariables
|
|
>;
|
|
export const GetUsernamesDocument = gql`
|
|
query getUsernames(
|
|
$matchString: String!
|
|
$limit: Int = null
|
|
$after: String = null
|
|
) {
|
|
getUsernames(matchString: $matchString, limit: $limit, after: $after)
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetUsernamesQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetUsernamesQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUsernamesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetUsernamesQuery({
|
|
* variables: {
|
|
* matchString: // value for 'matchString'
|
|
* limit: // value for 'limit'
|
|
* after: // value for 'after'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUsernamesQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetUsernamesQuery,
|
|
GetUsernamesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
|
|
GetUsernamesDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetUsernamesLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetUsernamesQuery,
|
|
GetUsernamesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
|
|
GetUsernamesDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetUsernamesSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetUsernamesQuery,
|
|
GetUsernamesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
|
|
GetUsernamesDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type GetUsernamesQueryHookResult = ReturnType<
|
|
typeof useGetUsernamesQuery
|
|
>;
|
|
export type GetUsernamesLazyQueryHookResult = ReturnType<
|
|
typeof useGetUsernamesLazyQuery
|
|
>;
|
|
export type GetUsernamesSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetUsernamesSuspenseQuery
|
|
>;
|
|
export type GetUsernamesQueryResult = Apollo.QueryResult<
|
|
GetUsernamesQuery,
|
|
GetUsernamesQueryVariables
|
|
>;
|
|
export const GetStreamMonitoringDetailsDocument = gql`
|
|
query GetStreamMonitoringDetails($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
totalShots
|
|
makePercentage
|
|
elapsedTime
|
|
homographyHistory {
|
|
crop {
|
|
left
|
|
top
|
|
width
|
|
height
|
|
}
|
|
pockets {
|
|
left
|
|
top
|
|
width
|
|
height
|
|
}
|
|
sourcePoints {
|
|
topLeft {
|
|
x
|
|
y
|
|
}
|
|
topSide {
|
|
x
|
|
y
|
|
}
|
|
topRight {
|
|
x
|
|
y
|
|
}
|
|
bottomLeft {
|
|
x
|
|
y
|
|
}
|
|
bottomSide {
|
|
x
|
|
y
|
|
}
|
|
bottomRight {
|
|
x
|
|
y
|
|
}
|
|
}
|
|
}
|
|
stream {
|
|
linksRequested
|
|
uploadsCompleted
|
|
segmentProcessingCursor
|
|
isCompleted
|
|
uploadCompletionCursor
|
|
lastIntendedSegmentBound
|
|
initPlaylistUploadStatus
|
|
}
|
|
currentProcessing {
|
|
errors {
|
|
message
|
|
startSegmentIndex
|
|
endSegmentIndex
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetStreamMonitoringDetailsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetStreamMonitoringDetailsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetStreamMonitoringDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetStreamMonitoringDetailsQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetStreamMonitoringDetailsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>(GetStreamMonitoringDetailsDocument, options);
|
|
}
|
|
export function useGetStreamMonitoringDetailsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>(GetStreamMonitoringDetailsDocument, options);
|
|
}
|
|
export function useGetStreamMonitoringDetailsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>(GetStreamMonitoringDetailsDocument, options);
|
|
}
|
|
export type GetStreamMonitoringDetailsQueryHookResult = ReturnType<
|
|
typeof useGetStreamMonitoringDetailsQuery
|
|
>;
|
|
export type GetStreamMonitoringDetailsLazyQueryHookResult = ReturnType<
|
|
typeof useGetStreamMonitoringDetailsLazyQuery
|
|
>;
|
|
export type GetStreamMonitoringDetailsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetStreamMonitoringDetailsSuspenseQuery
|
|
>;
|
|
export type GetStreamMonitoringDetailsQueryResult = Apollo.QueryResult<
|
|
GetStreamMonitoringDetailsQuery,
|
|
GetStreamMonitoringDetailsQueryVariables
|
|
>;
|
|
export const GetVideoUpdatePageDetailsDocument = gql`
|
|
query GetVideoUpdatePageDetails($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
name
|
|
totalShots
|
|
makePercentage
|
|
elapsedTime
|
|
tags {
|
|
tagClasses {
|
|
name
|
|
}
|
|
name
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideoUpdatePageDetailsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideoUpdatePageDetailsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideoUpdatePageDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideoUpdatePageDetailsQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideoUpdatePageDetailsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>(GetVideoUpdatePageDetailsDocument, options);
|
|
}
|
|
export function useGetVideoUpdatePageDetailsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>(GetVideoUpdatePageDetailsDocument, options);
|
|
}
|
|
export function useGetVideoUpdatePageDetailsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>(GetVideoUpdatePageDetailsDocument, options);
|
|
}
|
|
export type GetVideoUpdatePageDetailsQueryHookResult = ReturnType<
|
|
typeof useGetVideoUpdatePageDetailsQuery
|
|
>;
|
|
export type GetVideoUpdatePageDetailsLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideoUpdatePageDetailsLazyQuery
|
|
>;
|
|
export type GetVideoUpdatePageDetailsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideoUpdatePageDetailsSuspenseQuery
|
|
>;
|
|
export type GetVideoUpdatePageDetailsQueryResult = Apollo.QueryResult<
|
|
GetVideoUpdatePageDetailsQuery,
|
|
GetVideoUpdatePageDetailsQueryVariables
|
|
>;
|
|
export const DeleteVideoDocument = gql`
|
|
mutation DeleteVideo($videoId: Int!) {
|
|
deleteVideo(videoId: $videoId)
|
|
}
|
|
`;
|
|
export type DeleteVideoMutationFn = Apollo.MutationFunction<
|
|
DeleteVideoMutation,
|
|
DeleteVideoMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useDeleteVideoMutation__
|
|
*
|
|
* To run a mutation, you first call `useDeleteVideoMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useDeleteVideoMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [deleteVideoMutation, { data, loading, error }] = useDeleteVideoMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useDeleteVideoMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
DeleteVideoMutation,
|
|
DeleteVideoMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<DeleteVideoMutation, DeleteVideoMutationVariables>(
|
|
DeleteVideoDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type DeleteVideoMutationHookResult = ReturnType<
|
|
typeof useDeleteVideoMutation
|
|
>;
|
|
export type DeleteVideoMutationResult =
|
|
Apollo.MutationResult<DeleteVideoMutation>;
|
|
export type DeleteVideoMutationOptions = Apollo.BaseMutationOptions<
|
|
DeleteVideoMutation,
|
|
DeleteVideoMutationVariables
|
|
>;
|
|
export const GetVideoDetailsDocument = gql`
|
|
query GetVideoDetails($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
name
|
|
screenshotUri
|
|
averageTimeBetweenShots
|
|
elapsedTime
|
|
endTime
|
|
makePercentage
|
|
medianRun
|
|
startTime
|
|
totalShots
|
|
totalShotsMade
|
|
createdAt
|
|
updatedAt
|
|
owner {
|
|
id
|
|
firebaseUid
|
|
username
|
|
profileImageUri
|
|
}
|
|
tags {
|
|
tagClasses {
|
|
name
|
|
}
|
|
name
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideoDetailsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideoDetailsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideoDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideoDetailsQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideoDetailsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>(
|
|
GetVideoDetailsDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetVideoDetailsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>(GetVideoDetailsDocument, options);
|
|
}
|
|
export function useGetVideoDetailsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>(GetVideoDetailsDocument, options);
|
|
}
|
|
export type GetVideoDetailsQueryHookResult = ReturnType<
|
|
typeof useGetVideoDetailsQuery
|
|
>;
|
|
export type GetVideoDetailsLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideoDetailsLazyQuery
|
|
>;
|
|
export type GetVideoDetailsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideoDetailsSuspenseQuery
|
|
>;
|
|
export type GetVideoDetailsQueryResult = Apollo.QueryResult<
|
|
GetVideoDetailsQuery,
|
|
GetVideoDetailsQueryVariables
|
|
>;
|
|
export const GetVideosDocument = gql`
|
|
query GetVideos($videoIds: [Int!]!) {
|
|
getVideos(videoIds: $videoIds) {
|
|
id
|
|
playlist {
|
|
segmentDurations
|
|
}
|
|
stream {
|
|
id
|
|
segments {
|
|
uploaded
|
|
valid
|
|
segmentIndex
|
|
endFrameIndex
|
|
framesPerSecond
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideosQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideosQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideosQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideosQuery({
|
|
* variables: {
|
|
* videoIds: // value for 'videoIds'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideosQuery(
|
|
baseOptions: Apollo.QueryHookOptions<GetVideosQuery, GetVideosQueryVariables>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetVideosQuery, GetVideosQueryVariables>(
|
|
GetVideosDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetVideosLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideosQuery,
|
|
GetVideosQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<GetVideosQuery, GetVideosQueryVariables>(
|
|
GetVideosDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetVideosSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideosQuery,
|
|
GetVideosQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<GetVideosQuery, GetVideosQueryVariables>(
|
|
GetVideosDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type GetVideosQueryHookResult = ReturnType<typeof useGetVideosQuery>;
|
|
export type GetVideosLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideosLazyQuery
|
|
>;
|
|
export type GetVideosSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideosSuspenseQuery
|
|
>;
|
|
export type GetVideosQueryResult = Apollo.QueryResult<
|
|
GetVideosQuery,
|
|
GetVideosQueryVariables
|
|
>;
|
|
export const GetVideoDocument = gql`
|
|
query GetVideo($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
playlist {
|
|
segmentDurations
|
|
}
|
|
homographyHistory {
|
|
crop {
|
|
left
|
|
top
|
|
width
|
|
height
|
|
}
|
|
pockets {
|
|
left
|
|
top
|
|
width
|
|
height
|
|
}
|
|
sourcePoints {
|
|
topLeft {
|
|
x
|
|
y
|
|
}
|
|
topSide {
|
|
x
|
|
y
|
|
}
|
|
topRight {
|
|
x
|
|
y
|
|
}
|
|
bottomLeft {
|
|
x
|
|
y
|
|
}
|
|
bottomSide {
|
|
x
|
|
y
|
|
}
|
|
bottomRight {
|
|
x
|
|
y
|
|
}
|
|
}
|
|
}
|
|
stream {
|
|
streamSegmentType
|
|
segments {
|
|
segmentIndex
|
|
endFrameIndex
|
|
framesPerSecond
|
|
}
|
|
resolution {
|
|
width
|
|
height
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideoQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideoQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideoQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideoQuery(
|
|
baseOptions: Apollo.QueryHookOptions<GetVideoQuery, GetVideoQueryVariables>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetVideoQuery, GetVideoQueryVariables>(
|
|
GetVideoDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetVideoLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideoQuery,
|
|
GetVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<GetVideoQuery, GetVideoQueryVariables>(
|
|
GetVideoDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetVideoSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideoQuery,
|
|
GetVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<GetVideoQuery, GetVideoQueryVariables>(
|
|
GetVideoDocument,
|
|
options,
|
|
);
|
|
}
|
|
export type GetVideoQueryHookResult = ReturnType<typeof useGetVideoQuery>;
|
|
export type GetVideoLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideoLazyQuery
|
|
>;
|
|
export type GetVideoSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideoSuspenseQuery
|
|
>;
|
|
export type GetVideoQueryResult = Apollo.QueryResult<
|
|
GetVideoQuery,
|
|
GetVideoQueryVariables
|
|
>;
|
|
export const GetAverageTimePerShotForVideoDocument = gql`
|
|
query GetAverageTimePerShotForVideo($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
averageTimeBetweenShots
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetAverageTimePerShotForVideoQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetAverageTimePerShotForVideoQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetAverageTimePerShotForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetAverageTimePerShotForVideoQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetAverageTimePerShotForVideoQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>(GetAverageTimePerShotForVideoDocument, options);
|
|
}
|
|
export function useGetAverageTimePerShotForVideoLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>(GetAverageTimePerShotForVideoDocument, options);
|
|
}
|
|
export function useGetAverageTimePerShotForVideoSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>(GetAverageTimePerShotForVideoDocument, options);
|
|
}
|
|
export type GetAverageTimePerShotForVideoQueryHookResult = ReturnType<
|
|
typeof useGetAverageTimePerShotForVideoQuery
|
|
>;
|
|
export type GetAverageTimePerShotForVideoLazyQueryHookResult = ReturnType<
|
|
typeof useGetAverageTimePerShotForVideoLazyQuery
|
|
>;
|
|
export type GetAverageTimePerShotForVideoSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetAverageTimePerShotForVideoSuspenseQuery
|
|
>;
|
|
export type GetAverageTimePerShotForVideoQueryResult = Apollo.QueryResult<
|
|
GetAverageTimePerShotForVideoQuery,
|
|
GetAverageTimePerShotForVideoQueryVariables
|
|
>;
|
|
export const GetElapsedTimeForVideoDocument = gql`
|
|
query GetElapsedTimeForVideo($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
elapsedTime
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetElapsedTimeForVideoQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetElapsedTimeForVideoQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetElapsedTimeForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetElapsedTimeForVideoQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetElapsedTimeForVideoQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>(GetElapsedTimeForVideoDocument, options);
|
|
}
|
|
export function useGetElapsedTimeForVideoLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>(GetElapsedTimeForVideoDocument, options);
|
|
}
|
|
export function useGetElapsedTimeForVideoSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>(GetElapsedTimeForVideoDocument, options);
|
|
}
|
|
export type GetElapsedTimeForVideoQueryHookResult = ReturnType<
|
|
typeof useGetElapsedTimeForVideoQuery
|
|
>;
|
|
export type GetElapsedTimeForVideoLazyQueryHookResult = ReturnType<
|
|
typeof useGetElapsedTimeForVideoLazyQuery
|
|
>;
|
|
export type GetElapsedTimeForVideoSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetElapsedTimeForVideoSuspenseQuery
|
|
>;
|
|
export type GetElapsedTimeForVideoQueryResult = Apollo.QueryResult<
|
|
GetElapsedTimeForVideoQuery,
|
|
GetElapsedTimeForVideoQueryVariables
|
|
>;
|
|
export const GetMedianRunForVideoDocument = gql`
|
|
query GetMedianRunForVideo($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
medianRun
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetMedianRunForVideoQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetMedianRunForVideoQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetMedianRunForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetMedianRunForVideoQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetMedianRunForVideoQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>(GetMedianRunForVideoDocument, options);
|
|
}
|
|
export function useGetMedianRunForVideoLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>(GetMedianRunForVideoDocument, options);
|
|
}
|
|
export function useGetMedianRunForVideoSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>(GetMedianRunForVideoDocument, options);
|
|
}
|
|
export type GetMedianRunForVideoQueryHookResult = ReturnType<
|
|
typeof useGetMedianRunForVideoQuery
|
|
>;
|
|
export type GetMedianRunForVideoLazyQueryHookResult = ReturnType<
|
|
typeof useGetMedianRunForVideoLazyQuery
|
|
>;
|
|
export type GetMedianRunForVideoSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetMedianRunForVideoSuspenseQuery
|
|
>;
|
|
export type GetMedianRunForVideoQueryResult = Apollo.QueryResult<
|
|
GetMedianRunForVideoQuery,
|
|
GetMedianRunForVideoQueryVariables
|
|
>;
|
|
export const GetVideoForClipTimesDocument = gql`
|
|
query GetVideoForClipTimes($videoId: Int!) {
|
|
getVideo(videoId: $videoId) {
|
|
id
|
|
playlist {
|
|
segmentDurations
|
|
}
|
|
stream {
|
|
id
|
|
streamSegmentType
|
|
segments {
|
|
uploaded
|
|
valid
|
|
segmentIndex
|
|
endFrameIndex
|
|
framesPerSecond
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetVideoForClipTimesQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetVideoForClipTimesQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetVideoForClipTimesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetVideoForClipTimesQuery({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetVideoForClipTimesQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>(GetVideoForClipTimesDocument, options);
|
|
}
|
|
export function useGetVideoForClipTimesLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>(GetVideoForClipTimesDocument, options);
|
|
}
|
|
export function useGetVideoForClipTimesSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>(GetVideoForClipTimesDocument, options);
|
|
}
|
|
export type GetVideoForClipTimesQueryHookResult = ReturnType<
|
|
typeof useGetVideoForClipTimesQuery
|
|
>;
|
|
export type GetVideoForClipTimesLazyQueryHookResult = ReturnType<
|
|
typeof useGetVideoForClipTimesLazyQuery
|
|
>;
|
|
export type GetVideoForClipTimesSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetVideoForClipTimesSuspenseQuery
|
|
>;
|
|
export type GetVideoForClipTimesQueryResult = Apollo.QueryResult<
|
|
GetVideoForClipTimesQuery,
|
|
GetVideoForClipTimesQueryVariables
|
|
>;
|
|
export const CreateUploadStreamDocument = gql`
|
|
mutation CreateUploadStream($videoMetadataInput: VideoMetadataInput!) {
|
|
createUploadStream(videoMetadata: $videoMetadataInput) {
|
|
videoId
|
|
}
|
|
}
|
|
`;
|
|
export type CreateUploadStreamMutationFn = Apollo.MutationFunction<
|
|
CreateUploadStreamMutation,
|
|
CreateUploadStreamMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useCreateUploadStreamMutation__
|
|
*
|
|
* To run a mutation, you first call `useCreateUploadStreamMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useCreateUploadStreamMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [createUploadStreamMutation, { data, loading, error }] = useCreateUploadStreamMutation({
|
|
* variables: {
|
|
* videoMetadataInput: // value for 'videoMetadataInput'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useCreateUploadStreamMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
CreateUploadStreamMutation,
|
|
CreateUploadStreamMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
CreateUploadStreamMutation,
|
|
CreateUploadStreamMutationVariables
|
|
>(CreateUploadStreamDocument, options);
|
|
}
|
|
export type CreateUploadStreamMutationHookResult = ReturnType<
|
|
typeof useCreateUploadStreamMutation
|
|
>;
|
|
export type CreateUploadStreamMutationResult =
|
|
Apollo.MutationResult<CreateUploadStreamMutation>;
|
|
export type CreateUploadStreamMutationOptions = Apollo.BaseMutationOptions<
|
|
CreateUploadStreamMutation,
|
|
CreateUploadStreamMutationVariables
|
|
>;
|
|
export const GetUploadLinkDocument = gql`
|
|
mutation GetUploadLink($videoId: Int!, $segmentIndex: Int!) {
|
|
getUploadLink(videoId: $videoId, segmentIndex: $segmentIndex) {
|
|
uploadUrl
|
|
headers {
|
|
key
|
|
value
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
export type GetUploadLinkMutationFn = Apollo.MutationFunction<
|
|
GetUploadLinkMutation,
|
|
GetUploadLinkMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useGetUploadLinkMutation__
|
|
*
|
|
* To run a mutation, you first call `useGetUploadLinkMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUploadLinkMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [getUploadLinkMutation, { data, loading, error }] = useGetUploadLinkMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* segmentIndex: // value for 'segmentIndex'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUploadLinkMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
GetUploadLinkMutation,
|
|
GetUploadLinkMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
GetUploadLinkMutation,
|
|
GetUploadLinkMutationVariables
|
|
>(GetUploadLinkDocument, options);
|
|
}
|
|
export type GetUploadLinkMutationHookResult = ReturnType<
|
|
typeof useGetUploadLinkMutation
|
|
>;
|
|
export type GetUploadLinkMutationResult =
|
|
Apollo.MutationResult<GetUploadLinkMutation>;
|
|
export type GetUploadLinkMutationOptions = Apollo.BaseMutationOptions<
|
|
GetUploadLinkMutation,
|
|
GetUploadLinkMutationVariables
|
|
>;
|
|
export const GetHlsInitUploadLinkDocument = gql`
|
|
mutation GetHlsInitUploadLink($videoId: Int!) {
|
|
getHlsInitUploadLink(videoId: $videoId) {
|
|
uploadUrl
|
|
headers {
|
|
key
|
|
value
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
export type GetHlsInitUploadLinkMutationFn = Apollo.MutationFunction<
|
|
GetHlsInitUploadLinkMutation,
|
|
GetHlsInitUploadLinkMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useGetHlsInitUploadLinkMutation__
|
|
*
|
|
* To run a mutation, you first call `useGetHlsInitUploadLinkMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useGetHlsInitUploadLinkMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [getHlsInitUploadLinkMutation, { data, loading, error }] = useGetHlsInitUploadLinkMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetHlsInitUploadLinkMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
GetHlsInitUploadLinkMutation,
|
|
GetHlsInitUploadLinkMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
GetHlsInitUploadLinkMutation,
|
|
GetHlsInitUploadLinkMutationVariables
|
|
>(GetHlsInitUploadLinkDocument, options);
|
|
}
|
|
export type GetHlsInitUploadLinkMutationHookResult = ReturnType<
|
|
typeof useGetHlsInitUploadLinkMutation
|
|
>;
|
|
export type GetHlsInitUploadLinkMutationResult =
|
|
Apollo.MutationResult<GetHlsInitUploadLinkMutation>;
|
|
export type GetHlsInitUploadLinkMutationOptions = Apollo.BaseMutationOptions<
|
|
GetHlsInitUploadLinkMutation,
|
|
GetHlsInitUploadLinkMutationVariables
|
|
>;
|
|
export const SetSegmentDurationDocument = gql`
|
|
mutation SetSegmentDuration(
|
|
$videoId: Int!
|
|
$segmentIndex: Int!
|
|
$duration: Float!
|
|
) {
|
|
setSegmentDuration(
|
|
videoId: $videoId
|
|
segmentIndex: $segmentIndex
|
|
duration: $duration
|
|
)
|
|
}
|
|
`;
|
|
export type SetSegmentDurationMutationFn = Apollo.MutationFunction<
|
|
SetSegmentDurationMutation,
|
|
SetSegmentDurationMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useSetSegmentDurationMutation__
|
|
*
|
|
* To run a mutation, you first call `useSetSegmentDurationMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useSetSegmentDurationMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [setSegmentDurationMutation, { data, loading, error }] = useSetSegmentDurationMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* segmentIndex: // value for 'segmentIndex'
|
|
* duration: // value for 'duration'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useSetSegmentDurationMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
SetSegmentDurationMutation,
|
|
SetSegmentDurationMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
SetSegmentDurationMutation,
|
|
SetSegmentDurationMutationVariables
|
|
>(SetSegmentDurationDocument, options);
|
|
}
|
|
export type SetSegmentDurationMutationHookResult = ReturnType<
|
|
typeof useSetSegmentDurationMutation
|
|
>;
|
|
export type SetSegmentDurationMutationResult =
|
|
Apollo.MutationResult<SetSegmentDurationMutation>;
|
|
export type SetSegmentDurationMutationOptions = Apollo.BaseMutationOptions<
|
|
SetSegmentDurationMutation,
|
|
SetSegmentDurationMutationVariables
|
|
>;
|
|
export const EditUploadStreamDocument = gql`
|
|
mutation EditUploadStream(
|
|
$videoId: Int!
|
|
$videoMetadataInput: VideoMetadataInput!
|
|
) {
|
|
editUploadStream(videoId: $videoId, videoMetadata: $videoMetadataInput)
|
|
}
|
|
`;
|
|
export type EditUploadStreamMutationFn = Apollo.MutationFunction<
|
|
EditUploadStreamMutation,
|
|
EditUploadStreamMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useEditUploadStreamMutation__
|
|
*
|
|
* To run a mutation, you first call `useEditUploadStreamMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useEditUploadStreamMutation` returns a tuple that includes:
|
|
* - A mutate function that you can call at any time to execute the mutation
|
|
* - An object with fields that represent the current status of the mutation's execution
|
|
*
|
|
* @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
|
|
*
|
|
* @example
|
|
* const [editUploadStreamMutation, { data, loading, error }] = useEditUploadStreamMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* videoMetadataInput: // value for 'videoMetadataInput'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useEditUploadStreamMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
EditUploadStreamMutation,
|
|
EditUploadStreamMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
EditUploadStreamMutation,
|
|
EditUploadStreamMutationVariables
|
|
>(EditUploadStreamDocument, options);
|
|
}
|
|
export type EditUploadStreamMutationHookResult = ReturnType<
|
|
typeof useEditUploadStreamMutation
|
|
>;
|
|
export type EditUploadStreamMutationResult =
|
|
Apollo.MutationResult<EditUploadStreamMutation>;
|
|
export type EditUploadStreamMutationOptions = Apollo.BaseMutationOptions<
|
|
EditUploadStreamMutation,
|
|
EditUploadStreamMutationVariables
|
|
>;
|
|
export const GetUploadStreamsDocument = gql`
|
|
query GetUploadStreams(
|
|
$limit: Int! = 5
|
|
$after: String = null
|
|
$filters: VideoFilterInput = null
|
|
) {
|
|
getUserVideos(limit: $limit, after: $after, filters: $filters) {
|
|
videos {
|
|
id
|
|
}
|
|
pageInfo {
|
|
hasNextPage
|
|
endCursor
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetUploadStreamsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetUploadStreamsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUploadStreamsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetUploadStreamsQuery({
|
|
* variables: {
|
|
* limit: // value for 'limit'
|
|
* after: // value for 'after'
|
|
* filters: // value for 'filters'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUploadStreamsQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(
|
|
GetUploadStreamsDocument,
|
|
options,
|
|
);
|
|
}
|
|
export function useGetUploadStreamsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>(GetUploadStreamsDocument, options);
|
|
}
|
|
export function useGetUploadStreamsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>(GetUploadStreamsDocument, options);
|
|
}
|
|
export type GetUploadStreamsQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsQuery
|
|
>;
|
|
export type GetUploadStreamsLazyQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsLazyQuery
|
|
>;
|
|
export type GetUploadStreamsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsSuspenseQuery
|
|
>;
|
|
export type GetUploadStreamsQueryResult = Apollo.QueryResult<
|
|
GetUploadStreamsQuery,
|
|
GetUploadStreamsQueryVariables
|
|
>;
|
|
export const GetUploadStreamsWithDetailsDocument = gql`
|
|
query GetUploadStreamsWithDetails(
|
|
$limit: Int! = 5
|
|
$after: String = null
|
|
$filters: VideoFilterInput = null
|
|
) {
|
|
getUserVideos(limit: $limit, after: $after, filters: $filters) {
|
|
videos {
|
|
id
|
|
name
|
|
startTime
|
|
stream {
|
|
isCompleted
|
|
lastIntendedSegmentBound
|
|
uploadCompletionCursor
|
|
}
|
|
}
|
|
pageInfo {
|
|
hasNextPage
|
|
endCursor
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetUploadStreamsWithDetailsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetUploadStreamsWithDetailsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetUploadStreamsWithDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
* you can use to render your UI.
|
|
*
|
|
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
*
|
|
* @example
|
|
* const { data, loading, error } = useGetUploadStreamsWithDetailsQuery({
|
|
* variables: {
|
|
* limit: // value for 'limit'
|
|
* after: // value for 'after'
|
|
* filters: // value for 'filters'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetUploadStreamsWithDetailsQuery(
|
|
baseOptions?: Apollo.QueryHookOptions<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>(GetUploadStreamsWithDetailsDocument, options);
|
|
}
|
|
export function useGetUploadStreamsWithDetailsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>(GetUploadStreamsWithDetailsDocument, options);
|
|
}
|
|
export function useGetUploadStreamsWithDetailsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>(GetUploadStreamsWithDetailsDocument, options);
|
|
}
|
|
export type GetUploadStreamsWithDetailsQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsWithDetailsQuery
|
|
>;
|
|
export type GetUploadStreamsWithDetailsLazyQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsWithDetailsLazyQuery
|
|
>;
|
|
export type GetUploadStreamsWithDetailsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetUploadStreamsWithDetailsSuspenseQuery
|
|
>;
|
|
export type GetUploadStreamsWithDetailsQueryResult = Apollo.QueryResult<
|
|
GetUploadStreamsWithDetailsQuery,
|
|
GetUploadStreamsWithDetailsQueryVariables
|
|
>;
|