import { gql } from '@apollo/client';
import * as Apollo 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: Scalars['DateTime']['output'];
  elapsedTime?: Maybe<Scalars['Float']['output']>;
  endTime: 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: Scalars['DateTime']['output'];
  stream?: Maybe<UploadStreamGql>;
  totalShots: Scalars['Int']['output'];
  totalShotsMade: Scalars['Int']['output'];
  updatedAt: 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, updatedAt: any, startTime: any, endTime: any, 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>;