railbird-gql/src/index.tsx

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";
  headers: Array<Maybe<Header>>;
  uploadUrl: Scalars["String"]["output"];
};

export type Header = {
  __typename?: "Header";
  key: Scalars["String"]["output"];
  value: 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 = {
  videoMetadata: VideoMetadataInput;
};

export type MutationGetUploadLinkArgs = {
  segmentIndex: Scalars["Int"]["input"];
  videoId: Scalars["Int"]["input"];
};

export type MutationTerminateUploadStreamArgs = {
  videoId: Scalars["Int"]["input"];
  videoMetadata: VideoMetadataInput;
};

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"]>;
  limit?: 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 UploadStreamGql = {
  __typename?: "UploadStreamGQL";
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  isCompleted: Scalars["Boolean"]["output"];
  linksRequested: Scalars["Int"]["output"];
  updatedAt: Scalars["DateTime"]["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";
  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"]>;
  owner?: Maybe<UserGql>;
  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 type VideoMetadataInput = {
  endTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  tableSize?: InputMaybe<Scalars["String"]["input"]>;
  uploadStreamMetadataInput?: InputMaybe<UploadStreamMetadataInput>;
  videoName?: InputMaybe<Scalars["String"]["input"]>;
};

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<{
  limit?: 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;
      owner?: { __typename?: "UserGQL"; username: string } | 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<{
  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 TerminateUploadStreamMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  videoMetadataInput: VideoMetadataInput;
}>;

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($limit: Int! = 5, $after: String = null) {
    getVideoFeedForUser(limit: $limit, after: $after) {
      videos {
        id
        owner {
          username
        }
        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: {
 *      limit: // value for 'limit'
 *      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($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 TerminateUploadStreamDocument = gql`
  mutation TerminateUploadStream(
    $videoId: Int!
    $videoMetadataInput: VideoMetadataInput!
  ) {
    terminateUploadStream(videoId: $videoId, videoMetadata: $videoMetadataInput)
  }
`;
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'
 *      videoMetadataInput: // value for 'videoMetadataInput'
 *   },
 * });
 */
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
>;