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 AggregateInputGql = {
  bucketSets: Array<BucketSetInputGql>;
  filterInput?: InputMaybe<FilterInput>;
};

export type AggregateResultGql = {
  __typename?: "AggregateResultGQL";
  featureBuckets: Array<BucketGql>;
  targetMetrics: 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 BoundingBoxGql = {
  __typename?: "BoundingBoxGQL";
  height: Scalars["Int"]["output"];
  left: Scalars["Int"]["output"];
  top: Scalars["Int"]["output"];
  width: Scalars["Int"]["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 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 type DeployedConfigGql = {
  __typename?: "DeployedConfigGQL";
  allowNewUsers: Scalars["Boolean"]["output"];
};

export enum DeviceTypeEnum {
  Android = "ANDROID",
  Browser = "BROWSER",
  Ios = "IOS",
}

export type FilterInput = {
  andFilters?: InputMaybe<AndFilter>;
  cueBallSpeed?: InputMaybe<CueBallSpeedInput>;
  cueObjectAngle?: InputMaybe<CueObjectAngleInput>;
  cueObjectDistance?: InputMaybe<CueObjectDistanceInput>;
  intendedPocketType?: InputMaybe<IntendedPocketTypeInput>;
  make?: InputMaybe<MakeInputGql>;
  orFilters?: InputMaybe<OrFilter>;
  shotDirection?: InputMaybe<ShotDirectionInput>;
  targetPocketDistance?: InputMaybe<TargetPocketDistanceInput>;
  userId?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  videoId?: InputMaybe<Array<Scalars["Int"]["input"]>>;
};

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 HomographyInfoGql = {
  __typename?: "HomographyInfoGQL";
  crop: BoundingBoxGql;
  destPoints: PocketPointsGql;
  pockets: Array<BoundingBoxGql>;
  sourcePoints: PocketPointsGql;
};

export type IntPoint2D = {
  __typename?: "IntPoint2D";
  x: Scalars["Int"]["output"];
  y: Scalars["Int"]["output"];
};

export type IntendedPocketTypeInput = {
  value: ValueFilterString;
};

export type MakeInputGql = {
  value: ValueFilterBool;
};

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;
  getProfileImageUploadLink: GetUploadLinkReturn;
  getUploadLink: GetUploadLinkReturn;
  terminateUploadStream: 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 MutationGetProfileImageUploadLinkArgs = {
  fileExt?: InputMaybe<Scalars["String"]["input"]>;
};

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 PocketPointsGql = {
  __typename?: "PocketPointsGQL";
  bottomLeft: IntPoint2D;
  bottomRight: IntPoint2D;
  bottomSide: IntPoint2D;
  topLeft: IntPoint2D;
  topRight: IntPoint2D;
  topSide: IntPoint2D;
};

export type PocketingIntentionFeaturesGql = {
  __typename?: "PocketingIntentionFeaturesGQL";
  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>;
  getShots: Array<ShotGql>;
  getUser?: Maybe<UserGql>;
  getVideo: VideoGql;
  getVideoFeedForUser: VideoFeedGql;
  getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
};

export type QueryGetAggregatedShotMetricsArgs = {
  aggregateInput: AggregateInputGql;
};

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 QueryGetVideoMakePercentageIntervalsArgs = {
  intervalDuration?: Scalars["Int"]["input"];
  videoId: Scalars["ID"]["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: ValueFilterString;
};

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 StreamErrorGql = {
  __typename?: "StreamErrorGQL";
  message: Scalars["String"]["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"];
  errors: Array<StreamErrorGql>;
  homographyHistory: Array<HomographyInfoGql>;
  id: Scalars["ID"]["output"];
  isCompleted: Scalars["Boolean"]["output"];
  linksRequested: Scalars["Int"]["output"];
  segmentProcessingCursor: 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"];
  profileImageUri?: Maybe<Scalars["String"]["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 ValueFilterBool = {
  equals?: InputMaybe<Scalars["String"]["input"]>;
};

export type ValueFilterString = {
  equals?: InputMaybe<Scalars["String"]["input"]>;
};

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 GetAggregatedShotMetricsQueryVariables = Exact<{
  aggregateInput: AggregateInputGql;
}>;

export type GetAggregatedShotMetricsQuery = {
  __typename?: "Query";
  getAggregatedShotMetrics: Array<{
    __typename?: "AggregateResultGQL";
    featureBuckets: Array<{
      __typename?: "BucketGQL";
      rangeKey: string;
      lowerBound: number;
    }>;
    targetMetrics: {
      __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 GetVideoMakePercentageIntervalsQueryVariables = Exact<{
  videoId: Scalars["ID"]["input"];
}>;

export type GetVideoMakePercentageIntervalsQuery = {
  __typename?: "Query";
  getVideoMakePercentageIntervals: Array<{
    __typename?: "MakePercentageIntervalGQL";
    makePercentage: number;
    elapsedTime: number;
  }>;
};

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 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 GetStreamMonitoringDetailsQueryVariables = Exact<{
  videoId: Scalars["Int"]["input"];
}>;

export type GetStreamMonitoringDetailsQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    totalShots: number;
    makePercentage: number;
    elapsedTime?: number | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      linksRequested: number;
      uploadsCompleted: number;
      segmentProcessingCursor: number;
      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 };
        };
      }>;
    } | null;
  };
};

export type DeleteVideoMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
}>;

export type DeleteVideoMutation = {
  __typename?: "Mutation";
  deleteVideo: boolean;
};

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 GetAggregatedShotMetricsDocument = gql`
  query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
    getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
      featureBuckets {
        rangeKey
        lowerBound
      }
      targetMetrics {
        count
        makePercentage
        floatFeature {
          featureName
          average
          median
        }
      }
    }
  }
`;

/**
 * __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 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 GetVideoMakePercentageIntervalsDocument = gql`
  query GetVideoMakePercentageIntervals($videoId: ID!) {
    getVideoMakePercentageIntervals(videoId: $videoId) {
      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'
 *   },
 * });
 */
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
    $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 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 GetStreamMonitoringDetailsDocument = gql`
  query GetStreamMonitoringDetails($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      totalShots
      makePercentage
      elapsedTime
      stream {
        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
            }
          }
        }
        linksRequested
        uploadsCompleted
        segmentProcessingCursor
      }
    }
  }
`;

/**
 * __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 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 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
>;