1005 lines
30 KiB
TypeScript
1005 lines
30 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 };
|
|
/** Decimal (fixed-point) */
|
|
Decimal: { input: any; output: any };
|
|
};
|
|
|
|
export type AggregateResultGql = {
|
|
__typename?: "AggregateResultGQL";
|
|
featureBuckets: Array<BucketGql>;
|
|
targetMetrics: Array<TargetMetricGql>;
|
|
};
|
|
|
|
export type AndFilter = {
|
|
filters: Array<FilterInput>;
|
|
};
|
|
|
|
export type BankFeaturesGql = {
|
|
__typename?: "BankFeaturesGQL";
|
|
bankAngle: Scalars["Float"]["output"];
|
|
distance: Scalars["Float"]["output"];
|
|
wallsHit: Array<WallTypeEnum>;
|
|
};
|
|
|
|
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 CueBallSpeedInput = {
|
|
value: RangeFilter;
|
|
};
|
|
|
|
export type CueObjectAngleInput = {
|
|
value: RangeFilter;
|
|
};
|
|
|
|
export type CueObjectDistanceInput = {
|
|
value: RangeFilter;
|
|
};
|
|
|
|
export type CueObjectFeaturesGql = {
|
|
__typename?: "CueObjectFeaturesGQL";
|
|
cueBallSpeed?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectAngle?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
shotDirection?: Maybe<ShotDirectionEnum>;
|
|
};
|
|
|
|
export enum DeviceTypeEnum {
|
|
Android = "ANDROID",
|
|
Browser = "BROWSER",
|
|
Ios = "IOS",
|
|
}
|
|
|
|
export type EnumFilter = {
|
|
equals?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type FilterInput = {
|
|
andFilters?: InputMaybe<AndFilter>;
|
|
cueBallSpeed?: InputMaybe<CueBallSpeedInput>;
|
|
cueObjectAngle?: InputMaybe<CueObjectAngleInput>;
|
|
cueObjectDistance?: InputMaybe<CueObjectDistanceInput>;
|
|
intendedPocketType?: InputMaybe<IntendedPocketTypeInput>;
|
|
orFilters?: InputMaybe<OrFilter>;
|
|
shotDirection?: InputMaybe<ShotDirectionInput>;
|
|
targetPocketDistance?: InputMaybe<TargetPocketDistanceInput>;
|
|
};
|
|
|
|
export type GetUploadLinkReturn = {
|
|
__typename?: "GetUploadLinkReturn";
|
|
uploadUrl: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type IntendedPocketTypeInput = {
|
|
value: EnumFilter;
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: "Mutation";
|
|
createBucketSet: BucketSetGql;
|
|
createUploadStream: CreateUploadStreamReturn;
|
|
getUploadLink: GetUploadLinkReturn;
|
|
terminateUploadStream: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export type MutationCreateBucketSetArgs = {
|
|
params: CreateBucketSetInput;
|
|
};
|
|
|
|
export type MutationCreateUploadStreamArgs = {
|
|
uploadMetadata?: InputMaybe<UploadMetadataInput>;
|
|
videoName?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type MutationGetUploadLinkArgs = {
|
|
segmentIndex: Scalars["Int"]["input"];
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type MutationTerminateUploadStreamArgs = {
|
|
gameType?: InputMaybe<Scalars["String"]["input"]>;
|
|
tableSize?: InputMaybe<Scalars["String"]["input"]>;
|
|
videoId: Scalars["Int"]["input"];
|
|
videoName?: InputMaybe<Scalars["String"]["input"]>;
|
|
};
|
|
|
|
export type OrFilter = {
|
|
filters: Array<FilterInput>;
|
|
};
|
|
|
|
export type PageInfoGql = {
|
|
__typename?: "PageInfoGQL";
|
|
endCursor?: Maybe<Scalars["String"]["output"]>;
|
|
hasNextPage: Scalars["Boolean"]["output"];
|
|
};
|
|
|
|
export enum PocketEnum {
|
|
Corner = "CORNER",
|
|
Side = "SIDE",
|
|
}
|
|
|
|
export type PocketingIntentionFeaturesGql = {
|
|
__typename?: "PocketingIntentionFeaturesGQL";
|
|
intendedPocketType?: Maybe<PocketEnum>;
|
|
make?: Maybe<Scalars["Boolean"]["output"]>;
|
|
targetPocketDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: "Query";
|
|
getAggregateShots: Array<AggregateResultGql>;
|
|
getBucketSet?: Maybe<BucketSetGql>;
|
|
getLoggedInUser?: Maybe<UserGql>;
|
|
getShots: Array<ShotGql>;
|
|
getUser?: Maybe<UserGql>;
|
|
getVideo: VideoGql;
|
|
getVideoFeedForUser: VideoFeedGql;
|
|
};
|
|
|
|
export type QueryGetAggregateShotsArgs = {
|
|
bucketSets: Array<BucketSetInputGql>;
|
|
};
|
|
|
|
export type QueryGetBucketSetArgs = {
|
|
keyName: Scalars["String"]["input"];
|
|
};
|
|
|
|
export type QueryGetShotsArgs = {
|
|
filterInput?: InputMaybe<FilterInput>;
|
|
};
|
|
|
|
export type QueryGetUserArgs = {
|
|
userId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type QueryGetVideoArgs = {
|
|
videoId: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type QueryGetVideoFeedForUserArgs = {
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
first?: Scalars["Int"]["input"];
|
|
};
|
|
|
|
export type RangeFilter = {
|
|
greaterThanEqualTo?: InputMaybe<Scalars["Float"]["input"]>;
|
|
lessThan?: InputMaybe<Scalars["Float"]["input"]>;
|
|
};
|
|
|
|
export enum ShotDirectionEnum {
|
|
Left = "LEFT",
|
|
Right = "RIGHT",
|
|
Straight = "STRAIGHT",
|
|
}
|
|
|
|
export type ShotDirectionInput = {
|
|
value: EnumFilter;
|
|
};
|
|
|
|
export type ShotFeaturesGql = {
|
|
__typename?: "ShotFeaturesGQL";
|
|
bank?: Maybe<BankFeaturesGql>;
|
|
cueBallSpeed?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectAngle?: Maybe<Scalars["Float"]["output"]>;
|
|
cueObjectDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
intendedPocket?: Maybe<PocketEnum>;
|
|
shotDirection?: Maybe<ShotDirectionEnum>;
|
|
targetPocketDistance?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type ShotGql = {
|
|
__typename?: "ShotGQL";
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
|
|
endFrame?: Maybe<Scalars["Int"]["output"]>;
|
|
features?: Maybe<ShotFeaturesGql>;
|
|
id?: Maybe<Scalars["Int"]["output"]>;
|
|
pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
|
|
startFrame?: Maybe<Scalars["Int"]["output"]>;
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
videoId?: Maybe<Scalars["Int"]["output"]>;
|
|
};
|
|
|
|
export type TargetFloatFeatureGql = {
|
|
__typename?: "TargetFloatFeatureGQL";
|
|
average?: Maybe<Scalars["Float"]["output"]>;
|
|
featureName: Scalars["String"]["output"];
|
|
median?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type TargetMetricGql = {
|
|
__typename?: "TargetMetricGQL";
|
|
count?: Maybe<Scalars["Int"]["output"]>;
|
|
floatFeature?: Maybe<TargetFloatFeatureGql>;
|
|
makePercentage?: Maybe<Scalars["Float"]["output"]>;
|
|
};
|
|
|
|
export type TargetPocketDistanceInput = {
|
|
value: RangeFilter;
|
|
};
|
|
|
|
export type UploadMetadataInput = {
|
|
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 UploadStreamGql = {
|
|
__typename?: "UploadStreamGQL";
|
|
createdAt: Scalars["DateTime"]["output"];
|
|
id: Scalars["ID"]["output"];
|
|
isCompleted: Scalars["Boolean"]["output"];
|
|
linksRequested: Scalars["Int"]["output"];
|
|
updatedAt: Scalars["DateTime"]["output"];
|
|
uploadMetadata: UploadStreamMetadata;
|
|
uploadsCompleted: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type UploadStreamMetadata = {
|
|
__typename?: "UploadStreamMetadata";
|
|
appVersion?: Maybe<Scalars["String"]["output"]>;
|
|
browserName?: Maybe<Scalars["String"]["output"]>;
|
|
browserVersion?: Maybe<Scalars["String"]["output"]>;
|
|
deviceType?: Maybe<DeviceTypeEnum>;
|
|
ipAddress?: Maybe<Scalars["String"]["output"]>;
|
|
locale?: Maybe<Scalars["String"]["output"]>;
|
|
networkType?: Maybe<Scalars["String"]["output"]>;
|
|
osVersion?: Maybe<Scalars["String"]["output"]>;
|
|
timezone?: Maybe<Scalars["String"]["output"]>;
|
|
};
|
|
|
|
export type UserGql = {
|
|
__typename?: "UserGQL";
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
firebaseUid: Scalars["String"]["output"];
|
|
id: Scalars["Int"]["output"];
|
|
statistics: UserStatisticsGql;
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
username: Scalars["String"]["output"];
|
|
};
|
|
|
|
export type UserStatisticsGql = {
|
|
__typename?: "UserStatisticsGQL";
|
|
averageTimeBetweenShots: Scalars["Decimal"]["output"];
|
|
makePercentage: Scalars["Decimal"]["output"];
|
|
medianRun?: Maybe<Scalars["Decimal"]["output"]>;
|
|
timeSpentPlaying: Scalars["Decimal"]["output"];
|
|
totalShots: Scalars["Int"]["output"];
|
|
totalShotsMade: Scalars["Int"]["output"];
|
|
};
|
|
|
|
export type VideoFeedGql = {
|
|
__typename?: "VideoFeedGQL";
|
|
pageInfo: PageInfoGql;
|
|
videos: Array<VideoGql>;
|
|
};
|
|
|
|
export type VideoGql = {
|
|
__typename?: "VideoGQL";
|
|
averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
|
|
createdAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
elapsedTime?: Maybe<Scalars["Float"]["output"]>;
|
|
endTime?: Maybe<Scalars["DateTime"]["output"]>;
|
|
framesPerSecond: Scalars["Int"]["output"];
|
|
id: Scalars["Int"]["output"];
|
|
makePercentage: Scalars["Float"]["output"];
|
|
medianRun?: Maybe<Scalars["Float"]["output"]>;
|
|
name?: Maybe<Scalars["String"]["output"]>;
|
|
shots: Array<ShotGql>;
|
|
startTime?: Maybe<Scalars["DateTime"]["output"]>;
|
|
stream?: Maybe<UploadStreamGql>;
|
|
totalShots: Scalars["Int"]["output"];
|
|
totalShotsMade: Scalars["Int"]["output"];
|
|
updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
|
|
};
|
|
|
|
export enum WallTypeEnum {
|
|
Long = "LONG",
|
|
Short = "SHORT",
|
|
}
|
|
|
|
export type GetAggregateShotsQueryVariables = Exact<{
|
|
bucketSets: Array<BucketSetInputGql> | BucketSetInputGql;
|
|
}>;
|
|
|
|
export type GetAggregateShotsQuery = {
|
|
__typename?: "Query";
|
|
getAggregateShots: Array<{
|
|
__typename?: "AggregateResultGQL";
|
|
featureBuckets: Array<{
|
|
__typename?: "BucketGQL";
|
|
rangeKey: string;
|
|
lowerBound: number;
|
|
}>;
|
|
targetMetrics: Array<{
|
|
__typename?: "TargetMetricGQL";
|
|
count?: number | null;
|
|
makePercentage?: number | null;
|
|
floatFeature?: {
|
|
__typename?: "TargetFloatFeatureGQL";
|
|
featureName: string;
|
|
average?: number | null;
|
|
median?: number | null;
|
|
} | null;
|
|
}>;
|
|
}>;
|
|
};
|
|
|
|
export type GetFeedQueryVariables = Exact<{
|
|
first?: Scalars["Int"]["input"];
|
|
after?: InputMaybe<Scalars["String"]["input"]>;
|
|
}>;
|
|
|
|
export type GetFeedQuery = {
|
|
__typename?: "Query";
|
|
getVideoFeedForUser: {
|
|
__typename?: "VideoFeedGQL";
|
|
videos: Array<{
|
|
__typename?: "VideoGQL";
|
|
id: number;
|
|
name?: string | null;
|
|
totalShotsMade: number;
|
|
totalShots: number;
|
|
makePercentage: number;
|
|
medianRun?: number | null;
|
|
averageTimeBetweenShots?: number | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
startTime?: any | null;
|
|
endTime?: any | null;
|
|
elapsedTime?: number | null;
|
|
shots: Array<{
|
|
__typename?: "ShotGQL";
|
|
id?: number | null;
|
|
videoId?: number | null;
|
|
startFrame?: number | null;
|
|
endFrame?: number | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | null;
|
|
}>;
|
|
stream?: {
|
|
__typename?: "UploadStreamGQL";
|
|
id: string;
|
|
linksRequested: number;
|
|
uploadsCompleted: number;
|
|
isCompleted: boolean;
|
|
createdAt: any;
|
|
updatedAt: any;
|
|
} | null;
|
|
}>;
|
|
pageInfo: {
|
|
__typename?: "PageInfoGQL";
|
|
hasNextPage: boolean;
|
|
endCursor?: string | null;
|
|
};
|
|
};
|
|
};
|
|
|
|
export type GetShotsQueryVariables = Exact<{
|
|
filterInput?: InputMaybe<FilterInput>;
|
|
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 | null;
|
|
videoId?: number | null;
|
|
startFrame?: number | null;
|
|
endFrame?: number | null;
|
|
createdAt?: any | null;
|
|
updatedAt?: any | 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 CreateUploadStreamMutationVariables = Exact<{
|
|
videoName: Scalars["String"]["input"];
|
|
deviceType?: InputMaybe<DeviceTypeEnum>;
|
|
osVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
appVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
browserName?: InputMaybe<Scalars["String"]["input"]>;
|
|
browserVersion?: InputMaybe<Scalars["String"]["input"]>;
|
|
locale?: InputMaybe<Scalars["String"]["input"]>;
|
|
timezone?: InputMaybe<Scalars["String"]["input"]>;
|
|
networkType?: InputMaybe<Scalars["String"]["input"]>;
|
|
ipAddress?: InputMaybe<Scalars["String"]["input"]>;
|
|
}>;
|
|
|
|
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 };
|
|
};
|
|
|
|
export type TerminateUploadStreamMutationVariables = Exact<{
|
|
videoId: Scalars["Int"]["input"];
|
|
videoName?: InputMaybe<Scalars["String"]["input"]>;
|
|
gameType?: InputMaybe<Scalars["String"]["input"]>;
|
|
tableSize?: InputMaybe<Scalars["String"]["input"]>;
|
|
}>;
|
|
|
|
export type TerminateUploadStreamMutation = {
|
|
__typename?: "Mutation";
|
|
terminateUploadStream: boolean;
|
|
};
|
|
|
|
export const GetAggregateShotsDocument = gql`
|
|
query GetAggregateShots($bucketSets: [BucketSetInputGQL!]!) {
|
|
getAggregateShots(bucketSets: $bucketSets) {
|
|
featureBuckets {
|
|
rangeKey
|
|
lowerBound
|
|
}
|
|
targetMetrics {
|
|
count
|
|
makePercentage
|
|
floatFeature {
|
|
featureName
|
|
average
|
|
median
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`;
|
|
|
|
/**
|
|
* __useGetAggregateShotsQuery__
|
|
*
|
|
* To run a query within a React component, call `useGetAggregateShotsQuery` and pass it any options that fit your needs.
|
|
* When your component renders, `useGetAggregateShotsQuery` 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 } = useGetAggregateShotsQuery({
|
|
* variables: {
|
|
* bucketSets: // value for 'bucketSets'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useGetAggregateShotsQuery(
|
|
baseOptions: Apollo.QueryHookOptions<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useQuery<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>(GetAggregateShotsDocument, options);
|
|
}
|
|
export function useGetAggregateShotsLazyQuery(
|
|
baseOptions?: Apollo.LazyQueryHookOptions<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useLazyQuery<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>(GetAggregateShotsDocument, options);
|
|
}
|
|
export function useGetAggregateShotsSuspenseQuery(
|
|
baseOptions?: Apollo.SuspenseQueryHookOptions<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useSuspenseQuery<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>(GetAggregateShotsDocument, options);
|
|
}
|
|
export type GetAggregateShotsQueryHookResult = ReturnType<
|
|
typeof useGetAggregateShotsQuery
|
|
>;
|
|
export type GetAggregateShotsLazyQueryHookResult = ReturnType<
|
|
typeof useGetAggregateShotsLazyQuery
|
|
>;
|
|
export type GetAggregateShotsSuspenseQueryHookResult = ReturnType<
|
|
typeof useGetAggregateShotsSuspenseQuery
|
|
>;
|
|
export type GetAggregateShotsQueryResult = Apollo.QueryResult<
|
|
GetAggregateShotsQuery,
|
|
GetAggregateShotsQueryVariables
|
|
>;
|
|
export const GetFeedDocument = gql`
|
|
query GetFeed($first: Int! = 5, $after: String = null) {
|
|
getVideoFeedForUser(first: $first, after: $after) {
|
|
videos {
|
|
id
|
|
name
|
|
totalShotsMade
|
|
totalShots
|
|
makePercentage
|
|
medianRun
|
|
averageTimeBetweenShots
|
|
createdAt
|
|
updatedAt
|
|
shots {
|
|
id
|
|
videoId
|
|
startFrame
|
|
endFrame
|
|
createdAt
|
|
updatedAt
|
|
}
|
|
startTime
|
|
endTime
|
|
elapsedTime
|
|
stream {
|
|
id
|
|
linksRequested
|
|
uploadsCompleted
|
|
isCompleted
|
|
createdAt
|
|
updatedAt
|
|
}
|
|
}
|
|
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: {
|
|
* first: // value for 'first'
|
|
* after: // value for 'after'
|
|
* },
|
|
* });
|
|
*/
|
|
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 GetShotsDocument = gql`
|
|
query GetShots(
|
|
$filterInput: FilterInput
|
|
$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
|
|
createdAt
|
|
updatedAt
|
|
cueObjectFeatures {
|
|
cueObjectDistance @include(if: $includeCueObjectDistance)
|
|
cueObjectAngle @include(if: $includeCueObjectAngle)
|
|
cueBallSpeed @include(if: $includeCueBallSpeed)
|
|
shotDirection @include(if: $includeShotDirection)
|
|
}
|
|
pocketingIntentionFeatures {
|
|
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'
|
|
* 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 CreateUploadStreamDocument = gql`
|
|
mutation CreateUploadStream(
|
|
$videoName: String!
|
|
$deviceType: DeviceTypeEnum
|
|
$osVersion: String
|
|
$appVersion: String
|
|
$browserName: String
|
|
$browserVersion: String
|
|
$locale: String
|
|
$timezone: String
|
|
$networkType: String
|
|
$ipAddress: String
|
|
) {
|
|
createUploadStream(
|
|
videoName: $videoName
|
|
uploadMetadata: {
|
|
deviceType: $deviceType
|
|
osVersion: $osVersion
|
|
appVersion: $appVersion
|
|
browserName: $browserName
|
|
browserVersion: $browserVersion
|
|
locale: $locale
|
|
timezone: $timezone
|
|
networkType: $networkType
|
|
ipAddress: $ipAddress
|
|
}
|
|
) {
|
|
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: {
|
|
* videoName: // value for 'videoName'
|
|
* deviceType: // value for 'deviceType'
|
|
* osVersion: // value for 'osVersion'
|
|
* appVersion: // value for 'appVersion'
|
|
* browserName: // value for 'browserName'
|
|
* browserVersion: // value for 'browserVersion'
|
|
* locale: // value for 'locale'
|
|
* timezone: // value for 'timezone'
|
|
* networkType: // value for 'networkType'
|
|
* ipAddress: // value for 'ipAddress'
|
|
* },
|
|
* });
|
|
*/
|
|
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
|
|
}
|
|
}
|
|
`;
|
|
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 TerminateUploadStreamDocument = gql`
|
|
mutation TerminateUploadStream(
|
|
$videoId: Int!
|
|
$videoName: String
|
|
$gameType: String
|
|
$tableSize: String
|
|
) {
|
|
terminateUploadStream(
|
|
videoId: $videoId
|
|
videoName: $videoName
|
|
gameType: $gameType
|
|
tableSize: $tableSize
|
|
)
|
|
}
|
|
`;
|
|
export type TerminateUploadStreamMutationFn = Apollo.MutationFunction<
|
|
TerminateUploadStreamMutation,
|
|
TerminateUploadStreamMutationVariables
|
|
>;
|
|
|
|
/**
|
|
* __useTerminateUploadStreamMutation__
|
|
*
|
|
* To run a mutation, you first call `useTerminateUploadStreamMutation` within a React component and pass it any options that fit your needs.
|
|
* When your component renders, `useTerminateUploadStreamMutation` 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 [terminateUploadStreamMutation, { data, loading, error }] = useTerminateUploadStreamMutation({
|
|
* variables: {
|
|
* videoId: // value for 'videoId'
|
|
* videoName: // value for 'videoName'
|
|
* gameType: // value for 'gameType'
|
|
* tableSize: // value for 'tableSize'
|
|
* },
|
|
* });
|
|
*/
|
|
export function useTerminateUploadStreamMutation(
|
|
baseOptions?: Apollo.MutationHookOptions<
|
|
TerminateUploadStreamMutation,
|
|
TerminateUploadStreamMutationVariables
|
|
>,
|
|
) {
|
|
const options = { ...defaultOptions, ...baseOptions };
|
|
return Apollo.useMutation<
|
|
TerminateUploadStreamMutation,
|
|
TerminateUploadStreamMutationVariables
|
|
>(TerminateUploadStreamDocument, options);
|
|
}
|
|
export type TerminateUploadStreamMutationHookResult = ReturnType<
|
|
typeof useTerminateUploadStreamMutation
|
|
>;
|
|
export type TerminateUploadStreamMutationResult =
|
|
Apollo.MutationResult<TerminateUploadStreamMutation>;
|
|
export type TerminateUploadStreamMutationOptions = Apollo.BaseMutationOptions<
|
|
TerminateUploadStreamMutation,
|
|
TerminateUploadStreamMutationVariables
|
|
>;
|