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 };
};

export type AggregateInputGql = {
  aggregations: Array<AggregationInput>;
  filterInput?: InputMaybe<FilterInput>;
};

export type AggregateResultGql = {
  __typename?: "AggregateResultGQL";
  aggregationIdentifiers: Array<AggregationIdentifierGql>;
  targetMetrics: TargetMetricsGql;
};

export type AggregationIdentifierGql = {
  __typename?: "AggregationIdentifierGQL";
  featureName: Scalars["String"]["output"];
  groupName: Scalars["String"]["output"];
};

export type AggregationInput =
  | { bucketSet: BucketSetInputGql; enum?: never }
  | { bucketSet?: never; enum: EnumAggregation };

export type BankFeaturesGql = {
  __typename?: "BankFeaturesGQL";
  bankAngle: Scalars["Float"]["output"];
  distance: Scalars["Float"]["output"];
  wallsHit: Array<WallTypeEnum>;
};

export type BoundingBoxGql = {
  __typename?: "BoundingBoxGQL";
  height: Scalars["Float"]["output"];
  left: Scalars["Float"]["output"];
  top: Scalars["Float"]["output"];
  width: Scalars["Float"]["output"];
};

export type BucketGql = {
  __typename?: "BucketGQL";
  lowerBound: Scalars["Float"]["output"];
  rangeKey: Scalars["String"]["output"];
};

export type BucketInputGql = {
  lowerBound: Scalars["Float"]["input"];
  rangeKey: Scalars["String"]["input"];
};

export type BucketSetGql = {
  __typename?: "BucketSetGQL";
  buckets: Array<BucketGql>;
  feature: Scalars["String"]["output"];
  keyName: Scalars["String"]["output"];
};

export type BucketSetInputGql = {
  buckets: Array<BucketInputGql>;
  feature: Scalars["String"]["input"];
};

export type CreateBucketSetInput = {
  buckets: Array<BucketInputGql>;
  feature: Scalars["String"]["input"];
  keyName: Scalars["String"]["input"];
};

export type CreateUploadStreamReturn = {
  __typename?: "CreateUploadStreamReturn";
  videoId: Scalars["Int"]["output"];
};

export type CueObjectFeaturesGql = {
  __typename?: "CueObjectFeaturesGQL";
  cueBallSpeed?: Maybe<Scalars["Float"]["output"]>;
  cueObjectAngle?: Maybe<Scalars["Float"]["output"]>;
  cueObjectDistance?: Maybe<Scalars["Float"]["output"]>;
  shotDirection?: Maybe<ShotDirectionEnum>;
};

export type DeployedConfigGql = {
  __typename?: "DeployedConfigGQL";
  allowNewUsers: Scalars["Boolean"]["output"];
  devMode: Scalars["Boolean"]["output"];
  environment: Scalars["String"]["output"];
  firebase: Scalars["Boolean"]["output"];
};

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

export type EnumAggregation = {
  feature: Scalars["String"]["input"];
};

export type FilterInput =
  | {
      andFilters: Array<FilterInput>;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed: RangeFilter;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle: RangeFilter;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance: RangeFilter;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty: RangeFilter;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType: Array<PocketEnum>;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make: Array<Scalars["Boolean"]["input"]>;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters: Array<FilterInput>;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection: Array<ShotDirectionEnum>;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags: Array<VideoTagInput>;
      targetPocketDistance?: never;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance: RangeFilter;
      userId?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId: Array<Scalars["Int"]["input"]>;
      videoId?: never;
    }
  | {
      andFilters?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      difficulty?: never;
      intendedPocketType?: never;
      make?: never;
      orFilters?: never;
      shotDirection?: never;
      tags?: never;
      targetPocketDistance?: never;
      userId?: never;
      videoId: Array<Scalars["Int"]["input"]>;
    };

export type GetUploadLinkReturn = {
  __typename?: "GetUploadLinkReturn";
  headers: Array<Maybe<Header>>;
  uploadUrl: Scalars["String"]["output"];
};

export type HlsPlaylistGql = {
  __typename?: "HLSPlaylistGQL";
  m3u8Text: Scalars["String"]["output"];
  segmentDurations: Array<Scalars["Float"]["output"]>;
  videoId: Scalars["Int"]["output"];
};

export type Header = {
  __typename?: "Header";
  key: Scalars["String"]["output"];
  value: Scalars["String"]["output"];
};

export type HomographyInfoGql = {
  __typename?: "HomographyInfoGQL";
  crop: BoundingBoxGql;
  destPoints: PocketPointsGql;
  frameIndex: Scalars["Int"]["output"];
  pockets: Array<BoundingBoxGql>;
  sourcePoints: PocketPointsGql;
};

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

export type MakePercentageIntervalGql = {
  __typename?: "MakePercentageIntervalGQL";
  elapsedTime: Scalars["Float"]["output"];
  makePercentage: Scalars["Float"]["output"];
};

export type Mutation = {
  __typename?: "Mutation";
  createBucketSet: BucketSetGql;
  createUploadStream: CreateUploadStreamReturn;
  deleteVideo: Scalars["Boolean"]["output"];
  editProfileImageUri: UserGql;
  editUploadStream: Scalars["Boolean"]["output"];
  getProfileImageUploadLink: GetUploadLinkReturn;
  getUploadLink: GetUploadLinkReturn;
  setLoggerLevel: Scalars["Boolean"]["output"];
};

export type MutationCreateBucketSetArgs = {
  params: CreateBucketSetInput;
};

export type MutationCreateUploadStreamArgs = {
  videoMetadata: VideoMetadataInput;
};

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

export type MutationEditProfileImageUriArgs = {
  profileImageUri: Scalars["String"]["input"];
};

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

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

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

export type MutationSetLoggerLevelArgs = {
  level: Scalars["String"]["input"];
  path: Scalars["String"]["input"];
};

export type PageInfoGql = {
  __typename?: "PageInfoGQL";
  endCursor?: Maybe<Scalars["String"]["output"]>;
  hasNextPage: Scalars["Boolean"]["output"];
};

export enum PocketEnum {
  Corner = "CORNER",
  Side = "SIDE",
}

export type PocketPointsGql = {
  __typename?: "PocketPointsGQL";
  bottomLeft: IntPoint2D;
  bottomRight: IntPoint2D;
  bottomSide: IntPoint2D;
  topLeft: IntPoint2D;
  topRight: IntPoint2D;
  topSide: IntPoint2D;
};

export type PocketingIntentionFeaturesGql = {
  __typename?: "PocketingIntentionFeaturesGQL";
  difficulty?: Maybe<Scalars["Float"]["output"]>;
  intendedPocketType?: Maybe<PocketEnum>;
  make?: Maybe<Scalars["Boolean"]["output"]>;
  targetPocketDistance?: Maybe<Scalars["Float"]["output"]>;
};

export type Query = {
  __typename?: "Query";
  getAggregatedShotMetrics: Array<AggregateResultGql>;
  getBucketSet?: Maybe<BucketSetGql>;
  getDeployedConfig: DeployedConfigGql;
  getLoggedInUser?: Maybe<UserGql>;
  getPlayTime: UserPlayTimeGql;
  getShots: Array<ShotGql>;
  getUser?: Maybe<UserGql>;
  getUserVideos: VideoHistoryGql;
  getVideo: VideoGql;
  getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
  getVideos: Array<VideoGql>;
};

export type QueryGetAggregatedShotMetricsArgs = {
  aggregateInput: AggregateInputGql;
};

export type QueryGetBucketSetArgs = {
  keyName: Scalars["String"]["input"];
};

export type QueryGetPlayTimeArgs = {
  userId: Scalars["Int"]["input"];
};

export type QueryGetShotsArgs = {
  filterInput: FilterInput;
};

export type QueryGetUserArgs = {
  userId: Scalars["Int"]["input"];
};

export type QueryGetUserVideosArgs = {
  after?: InputMaybe<Scalars["String"]["input"]>;
  filters?: InputMaybe<VideoFilterInput>;
  limit?: Scalars["Int"]["input"];
  userId?: InputMaybe<Scalars["Int"]["input"]>;
};

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

export type QueryGetVideoMakePercentageIntervalsArgs = {
  intervalDuration?: Scalars["Int"]["input"];
  videoId: Scalars["ID"]["input"];
};

export type QueryGetVideosArgs = {
  videoIds: Array<Scalars["Int"]["input"]>;
};

export type RangeFilter = {
  greaterThanEqualTo?: InputMaybe<Scalars["Float"]["input"]>;
  lessThan?: InputMaybe<Scalars["Float"]["input"]>;
};

export type SerializedShotPathsGql = {
  __typename?: "SerializedShotPathsGQL";
  b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
};

export enum ShotDirectionEnum {
  Left = "LEFT",
  Right = "RIGHT",
  Straight = "STRAIGHT",
}

export type ShotGql = {
  __typename?: "ShotGQL";
  bankFeatures?: Maybe<BankFeaturesGql>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
  endFrame: Scalars["Int"]["output"];
  id: Scalars["Int"]["output"];
  pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
  serializedShotPaths?: Maybe<SerializedShotPathsGql>;
  startFrame: Scalars["Int"]["output"];
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  user?: Maybe<UserGql>;
  videoId: Scalars["Int"]["output"];
};

export type StreamErrorGql = {
  __typename?: "StreamErrorGQL";
  message: Scalars["String"]["output"];
};

export type TargetMetricsGql = {
  __typename?: "TargetMetricsGQL";
  averageDifficulty?: Maybe<Scalars["Float"]["output"]>;
  count: Scalars["Int"]["output"];
  makePercentage?: Maybe<Scalars["Float"]["output"]>;
};

export type UploadSegmentGql = {
  __typename?: "UploadSegmentGQL";
  durationsInSeconds?: Maybe<Scalars["Float"]["output"]>;
  endFrameIndex?: Maybe<Scalars["Int"]["output"]>;
  framesPerSecond?: Maybe<Scalars["Float"]["output"]>;
  linksRequested: Scalars["Int"]["output"];
  segmentIndex: Scalars["Int"]["output"];
  uploaded: Scalars["Boolean"]["output"];
  valid: Scalars["Boolean"]["output"];
};

export type UploadStreamGql = {
  __typename?: "UploadStreamGQL";
  createdAt: Scalars["DateTime"]["output"];
  errors: Array<StreamErrorGql>;
  id: Scalars["ID"]["output"];
  isCompleted: Scalars["Boolean"]["output"];
  lastIntendedSegmentBound?: Maybe<Scalars["Int"]["output"]>;
  linksRequested: Scalars["Int"]["output"];
  lowestUnuploadedSegmentIndex: Scalars["Int"]["output"];
  segmentProcessingCursor: Scalars["Int"]["output"];
  segments: Array<UploadSegmentGql>;
  updatedAt: Scalars["DateTime"]["output"];
  uploadCompletionCursor: Scalars["Int"]["output"];
  uploadsCompleted: Scalars["Int"]["output"];
};

export type UploadStreamMetadataInput = {
  appVersion?: InputMaybe<Scalars["String"]["input"]>;
  browserName?: InputMaybe<Scalars["String"]["input"]>;
  browserVersion?: InputMaybe<Scalars["String"]["input"]>;
  deviceType?: InputMaybe<DeviceTypeEnum>;
  ipAddress?: InputMaybe<Scalars["String"]["input"]>;
  locale?: InputMaybe<Scalars["String"]["input"]>;
  networkType?: InputMaybe<Scalars["String"]["input"]>;
  osVersion?: InputMaybe<Scalars["String"]["input"]>;
  timezone?: InputMaybe<Scalars["String"]["input"]>;
};

export type UserGql = {
  __typename?: "UserGQL";
  activeVideoId?: Maybe<Scalars["Int"]["output"]>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  firebaseUid: Scalars["String"]["output"];
  id: Scalars["Int"]["output"];
  profileImageUri?: Maybe<Scalars["String"]["output"]>;
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  username: Scalars["String"]["output"];
};

export type UserPlayTimeGql = {
  __typename?: "UserPlayTimeGQL";
  totalSeconds: Scalars["Float"]["output"];
};

export type VideoFilterInput = {
  isStreamCompleted?: InputMaybe<Scalars["Boolean"]["input"]>;
  requireCursorCompletion?: Scalars["Boolean"]["input"];
};

export type VideoGql = {
  __typename?: "VideoGQL";
  averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  currentProcessing?: Maybe<VideoProcessingGql>;
  elapsedTime?: Maybe<Scalars["Float"]["output"]>;
  endTime?: Maybe<Scalars["DateTime"]["output"]>;
  framesPerSecond: Scalars["Float"]["output"];
  homographyHistory: Array<HomographyInfoGql>;
  id: Scalars["Int"]["output"];
  makePercentage: Scalars["Float"]["output"];
  medianRun?: Maybe<Scalars["Float"]["output"]>;
  name?: Maybe<Scalars["String"]["output"]>;
  owner?: Maybe<UserGql>;
  playlist?: Maybe<HlsPlaylistGql>;
  screenshotUri?: Maybe<Scalars["String"]["output"]>;
  shots: Array<ShotGql>;
  startTime?: Maybe<Scalars["DateTime"]["output"]>;
  stream?: Maybe<UploadStreamGql>;
  tags: Array<VideoTag>;
  totalShots: Scalars["Int"]["output"];
  totalShotsMade: Scalars["Int"]["output"];
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
};

export type VideoHistoryGql = {
  __typename?: "VideoHistoryGQL";
  pageInfo: PageInfoGql;
  videos: Array<VideoGql>;
};

export type VideoMetadataInput = {
  endStream?: Scalars["Boolean"]["input"];
  endTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
  startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  tableSize?: InputMaybe<Scalars["String"]["input"]>;
  uploadStreamMetadataInput?: InputMaybe<UploadStreamMetadataInput>;
  videoName?: InputMaybe<Scalars["String"]["input"]>;
};

export type VideoProcessingErrorGql = {
  __typename?: "VideoProcessingErrorGQL";
  endSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
  message: Scalars["String"]["output"];
  startSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
};

export type VideoProcessingGql = {
  __typename?: "VideoProcessingGQL";
  errors: Array<VideoProcessingErrorGql>;
};

export type VideoTag = {
  __typename?: "VideoTag";
  name: Scalars["String"]["output"];
  tagClasses: Array<VideoTagClass>;
};

export type VideoTagClass = {
  __typename?: "VideoTagClass";
  name: Scalars["String"]["output"];
};

export type VideoTagClassInput = {
  name: Scalars["String"]["input"];
};

export type VideoTagInput = {
  name: Scalars["String"]["input"];
  tagClasses?: Array<VideoTagClassInput>;
};

export enum WallTypeEnum {
  Long = "LONG",
  Short = "SHORT",
}

export type GetAggregatedShotMetricsQueryVariables = Exact<{
  aggregateInput: AggregateInputGql;
}>;

export type GetAggregatedShotMetricsQuery = {
  __typename?: "Query";
  getAggregatedShotMetrics: Array<{
    __typename?: "AggregateResultGQL";
    aggregationIdentifiers: Array<{
      __typename?: "AggregationIdentifierGQL";
      featureName: string;
      groupName: string;
    }>;
    targetMetrics: {
      __typename?: "TargetMetricsGQL";
      count: number;
      makePercentage?: number | null;
    };
  }>;
};

export type GetDeployedConfigQueryVariables = Exact<{ [key: string]: never }>;

export type GetDeployedConfigQuery = {
  __typename?: "Query";
  getDeployedConfig: {
    __typename?: "DeployedConfigGQL";
    allowNewUsers: boolean;
    devMode: boolean;
    environment: string;
    firebase: boolean;
  };
};

export type GetFeedQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
  after?: InputMaybe<Scalars["String"]["input"]>;
  filters?: InputMaybe<VideoFilterInput>;
}>;

export type GetFeedQuery = {
  __typename?: "Query";
  getUserVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      screenshotUri?: string | null;
      totalShotsMade: number;
      totalShots: number;
      makePercentage: number;
      createdAt?: any | null;
      updatedAt?: any | null;
      startTime?: any | null;
      endTime?: any | null;
      elapsedTime?: number | null;
      owner?: { __typename?: "UserGQL"; username: string } | null;
      stream?: { __typename?: "UploadStreamGQL"; isCompleted: boolean } | null;
      tags: Array<{
        __typename?: "VideoTag";
        name: string;
        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
      }>;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

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

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

export type GetShotsQueryVariables = Exact<{
  filterInput: FilterInput;
  includeCreatedAt?: Scalars["Boolean"]["input"];
  includeUpdatedAt?: Scalars["Boolean"]["input"];
  includeCueObjectFeatures?: Scalars["Boolean"]["input"];
  includePocketingIntentionFeatures?: Scalars["Boolean"]["input"];
  includeCueObjectDistance?: Scalars["Boolean"]["input"];
  includeCueObjectAngle?: Scalars["Boolean"]["input"];
  includeCueBallSpeed?: Scalars["Boolean"]["input"];
  includeShotDirection?: Scalars["Boolean"]["input"];
  includeTargetPocketDistance?: Scalars["Boolean"]["input"];
  includeMake?: Scalars["Boolean"]["input"];
  includeIntendedPocketType?: Scalars["Boolean"]["input"];
}>;

export type GetShotsQuery = {
  __typename?: "Query";
  getShots: Array<{
    __typename?: "ShotGQL";
    id: number;
    videoId: number;
    startFrame: number;
    endFrame: number;
    createdAt?: any | null;
    updatedAt?: any | null;
    user?: { __typename?: "UserGQL"; id: number } | null;
    cueObjectFeatures?: {
      __typename?: "CueObjectFeaturesGQL";
      cueObjectDistance?: number | null;
      cueObjectAngle?: number | null;
      cueBallSpeed?: number | null;
      shotDirection?: ShotDirectionEnum | null;
    } | null;
    pocketingIntentionFeatures?: {
      __typename?: "PocketingIntentionFeaturesGQL";
      targetPocketDistance?: number | null;
      make?: boolean | null;
      intendedPocketType?: PocketEnum | null;
    } | null;
  }>;
};

export type GetProfileImageUploadLinkMutationVariables = Exact<{
  fileExt?: InputMaybe<Scalars["String"]["input"]>;
}>;

export type GetProfileImageUploadLinkMutation = {
  __typename?: "Mutation";
  getProfileImageUploadLink: {
    __typename?: "GetUploadLinkReturn";
    uploadUrl: string;
    headers: Array<{
      __typename?: "Header";
      key: string;
      value: string;
    } | null>;
  };
};

export type EditProfileImageUriMutationVariables = Exact<{
  profileImageUri: Scalars["String"]["input"];
}>;

export type EditProfileImageUriMutation = {
  __typename?: "Mutation";
  editProfileImageUri: {
    __typename?: "UserGQL";
    id: number;
    firebaseUid: string;
    username: string;
    profileImageUri?: string | null;
    createdAt?: any | null;
    updatedAt?: any | null;
  };
};

export type GetLoggedInUserQueryVariables = Exact<{ [key: string]: never }>;

export type GetLoggedInUserQuery = {
  __typename?: "Query";
  getLoggedInUser?: {
    __typename?: "UserGQL";
    id: number;
    firebaseUid: string;
    username: string;
    profileImageUri?: string | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
  } | null;
};

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

export type GetUserPlayTimeQuery = {
  __typename?: "Query";
  getPlayTime: { __typename?: "UserPlayTimeGQL"; totalSeconds: number };
};

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

export type GetStreamMonitoringDetailsQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    totalShots: number;
    makePercentage: number;
    elapsedTime?: number | null;
    homographyHistory: Array<{
      __typename?: "HomographyInfoGQL";
      crop: {
        __typename?: "BoundingBoxGQL";
        left: number;
        top: number;
        width: number;
        height: number;
      };
      pockets: Array<{
        __typename?: "BoundingBoxGQL";
        left: number;
        top: number;
        width: number;
        height: number;
      }>;
      sourcePoints: {
        __typename?: "PocketPointsGQL";
        topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
        topSide: { __typename?: "IntPoint2D"; x: number; y: number };
        topRight: { __typename?: "IntPoint2D"; x: number; y: number };
        bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
        bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
        bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
      };
    }>;
    stream?: {
      __typename?: "UploadStreamGQL";
      linksRequested: number;
      uploadsCompleted: number;
      segmentProcessingCursor: number;
      isCompleted: boolean;
      uploadCompletionCursor: number;
      lastIntendedSegmentBound?: number | null;
    } | null;
    currentProcessing?: {
      __typename?: "VideoProcessingGQL";
      errors: Array<{
        __typename?: "VideoProcessingErrorGQL";
        message: string;
        startSegmentIndex?: number | null;
        endSegmentIndex?: number | null;
      }>;
    } | null;
  };
};

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

export type GetVideoUpdatePageDetailsQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    totalShots: number;
    makePercentage: number;
    elapsedTime?: number | null;
    tags: Array<{
      __typename?: "VideoTag";
      name: string;
      tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
    }>;
  };
};

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

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

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

export type GetVideoDetailsQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    screenshotUri?: string | null;
    averageTimeBetweenShots?: number | null;
    elapsedTime?: number | null;
    endTime?: any | null;
    makePercentage: number;
    medianRun?: number | null;
    startTime?: any | null;
    totalShots: number;
    totalShotsMade: number;
    createdAt?: any | null;
    updatedAt?: any | null;
    owner?: {
      __typename?: "UserGQL";
      id: number;
      firebaseUid: string;
      username: string;
      profileImageUri?: string | null;
    } | null;
    tags: Array<{
      __typename?: "VideoTag";
      name: string;
      tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
    }>;
  };
};

export type GetVideosQueryVariables = Exact<{
  videoIds: Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"];
}>;

export type GetVideosQuery = {
  __typename?: "Query";
  getVideos: Array<{
    __typename?: "VideoGQL";
    id: number;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      segmentDurations: Array<number>;
    } | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        uploaded: boolean;
        valid: boolean;
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
    } | null;
  }>;
};

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

export type GetVideoQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      segmentDurations: Array<number>;
    } | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
    } | null;
  };
};

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

export type GetAverageTimePerShotForVideoQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    averageTimeBetweenShots?: number | null;
  };
};

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

export type GetElapsedTimeForVideoQuery = {
  __typename?: "Query";
  getVideo: { __typename?: "VideoGQL"; elapsedTime?: number | null };
};

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

export type GetMedianRunForVideoQuery = {
  __typename?: "Query";
  getVideo: { __typename?: "VideoGQL"; medianRun?: number | 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 EditUploadStreamMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  videoMetadataInput: VideoMetadataInput;
}>;

export type EditUploadStreamMutation = {
  __typename?: "Mutation";
  editUploadStream: boolean;
};

export type GetUploadStreamsQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
  after?: InputMaybe<Scalars["String"]["input"]>;
  filters?: InputMaybe<VideoFilterInput>;
}>;

export type GetUploadStreamsQuery = {
  __typename?: "Query";
  getUserVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{ __typename?: "VideoGQL"; id: number }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export type GetUploadStreamsWithDetailsQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
  after?: InputMaybe<Scalars["String"]["input"]>;
  filters?: InputMaybe<VideoFilterInput>;
}>;

export type GetUploadStreamsWithDetailsQuery = {
  __typename?: "Query";
  getUserVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      startTime?: any | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        isCompleted: boolean;
        lastIntendedSegmentBound?: number | null;
        uploadCompletionCursor: number;
      } | null;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export const GetAggregatedShotMetricsDocument = gql`
  query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
    getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
      aggregationIdentifiers {
        featureName
        groupName
      }
      targetMetrics {
        count
        makePercentage
      }
    }
  }
`;

/**
 * __useGetAggregatedShotMetricsQuery__
 *
 * To run a query within a React component, call `useGetAggregatedShotMetricsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAggregatedShotMetricsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetAggregatedShotMetricsQuery({
 *   variables: {
 *      aggregateInput: // value for 'aggregateInput'
 *   },
 * });
 */
export function useGetAggregatedShotMetricsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >(GetAggregatedShotMetricsDocument, options);
}
export function useGetAggregatedShotMetricsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >(GetAggregatedShotMetricsDocument, options);
}
export function useGetAggregatedShotMetricsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetAggregatedShotMetricsQuery,
    GetAggregatedShotMetricsQueryVariables
  >(GetAggregatedShotMetricsDocument, options);
}
export type GetAggregatedShotMetricsQueryHookResult = ReturnType<
  typeof useGetAggregatedShotMetricsQuery
>;
export type GetAggregatedShotMetricsLazyQueryHookResult = ReturnType<
  typeof useGetAggregatedShotMetricsLazyQuery
>;
export type GetAggregatedShotMetricsSuspenseQueryHookResult = ReturnType<
  typeof useGetAggregatedShotMetricsSuspenseQuery
>;
export type GetAggregatedShotMetricsQueryResult = Apollo.QueryResult<
  GetAggregatedShotMetricsQuery,
  GetAggregatedShotMetricsQueryVariables
>;
export const GetDeployedConfigDocument = gql`
  query getDeployedConfig {
    getDeployedConfig {
      allowNewUsers
      devMode
      environment
      firebase
    }
  }
`;

/**
 * __useGetDeployedConfigQuery__
 *
 * To run a query within a React component, call `useGetDeployedConfigQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetDeployedConfigQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetDeployedConfigQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetDeployedConfigQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >(GetDeployedConfigDocument, options);
}
export function useGetDeployedConfigLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >(GetDeployedConfigDocument, options);
}
export function useGetDeployedConfigSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetDeployedConfigQuery,
    GetDeployedConfigQueryVariables
  >(GetDeployedConfigDocument, options);
}
export type GetDeployedConfigQueryHookResult = ReturnType<
  typeof useGetDeployedConfigQuery
>;
export type GetDeployedConfigLazyQueryHookResult = ReturnType<
  typeof useGetDeployedConfigLazyQuery
>;
export type GetDeployedConfigSuspenseQueryHookResult = ReturnType<
  typeof useGetDeployedConfigSuspenseQuery
>;
export type GetDeployedConfigQueryResult = Apollo.QueryResult<
  GetDeployedConfigQuery,
  GetDeployedConfigQueryVariables
>;
export const GetFeedDocument = gql`
  query GetFeed(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
  ) {
    getUserVideos(limit: $limit, after: $after, filters: $filters) {
      videos {
        id
        owner {
          username
        }
        name
        screenshotUri
        totalShotsMade
        totalShots
        makePercentage
        createdAt
        updatedAt
        startTime
        endTime
        elapsedTime
        screenshotUri
        stream {
          isCompleted
        }
        tags {
          tagClasses {
            name
          }
          name
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
`;

/**
 * __useGetFeedQuery__
 *
 * To run a query within a React component, call `useGetFeedQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetFeedQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetFeedQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *      filters: // value for 'filters'
 *   },
 * });
 */
export function useGetFeedQuery(
  baseOptions?: Apollo.QueryHookOptions<GetFeedQuery, GetFeedQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetFeedQuery, GetFeedQueryVariables>(
    GetFeedDocument,
    options,
  );
}
export function useGetFeedLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetFeedQuery,
    GetFeedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetFeedQuery, GetFeedQueryVariables>(
    GetFeedDocument,
    options,
  );
}
export function useGetFeedSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetFeedQuery,
    GetFeedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetFeedQuery, GetFeedQueryVariables>(
    GetFeedDocument,
    options,
  );
}
export type GetFeedQueryHookResult = ReturnType<typeof useGetFeedQuery>;
export type GetFeedLazyQueryHookResult = ReturnType<typeof useGetFeedLazyQuery>;
export type GetFeedSuspenseQueryHookResult = ReturnType<
  typeof useGetFeedSuspenseQuery
>;
export type GetFeedQueryResult = Apollo.QueryResult<
  GetFeedQuery,
  GetFeedQueryVariables
>;
export const GetVideoMakePercentageIntervalsDocument = gql`
  query GetVideoMakePercentageIntervals(
    $videoId: ID!
    $intervalDuration: Int!
  ) {
    getVideoMakePercentageIntervals(
      videoId: $videoId
      intervalDuration: $intervalDuration
    ) {
      makePercentage
      elapsedTime
    }
  }
`;

/**
 * __useGetVideoMakePercentageIntervalsQuery__
 *
 * To run a query within a React component, call `useGetVideoMakePercentageIntervalsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoMakePercentageIntervalsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetVideoMakePercentageIntervalsQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      intervalDuration: // value for 'intervalDuration'
 *   },
 * });
 */
export function useGetVideoMakePercentageIntervalsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >(GetVideoMakePercentageIntervalsDocument, options);
}
export function useGetVideoMakePercentageIntervalsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >(GetVideoMakePercentageIntervalsDocument, options);
}
export function useGetVideoMakePercentageIntervalsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoMakePercentageIntervalsQuery,
    GetVideoMakePercentageIntervalsQueryVariables
  >(GetVideoMakePercentageIntervalsDocument, options);
}
export type GetVideoMakePercentageIntervalsQueryHookResult = ReturnType<
  typeof useGetVideoMakePercentageIntervalsQuery
>;
export type GetVideoMakePercentageIntervalsLazyQueryHookResult = ReturnType<
  typeof useGetVideoMakePercentageIntervalsLazyQuery
>;
export type GetVideoMakePercentageIntervalsSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoMakePercentageIntervalsSuspenseQuery
>;
export type GetVideoMakePercentageIntervalsQueryResult = Apollo.QueryResult<
  GetVideoMakePercentageIntervalsQuery,
  GetVideoMakePercentageIntervalsQueryVariables
>;
export const GetShotsDocument = gql`
  query GetShots(
    $filterInput: FilterInput!
    $includeCreatedAt: Boolean! = false
    $includeUpdatedAt: Boolean! = false
    $includeCueObjectFeatures: Boolean! = false
    $includePocketingIntentionFeatures: Boolean! = false
    $includeCueObjectDistance: Boolean! = false
    $includeCueObjectAngle: Boolean! = false
    $includeCueBallSpeed: Boolean! = false
    $includeShotDirection: Boolean! = false
    $includeTargetPocketDistance: Boolean! = false
    $includeMake: Boolean! = false
    $includeIntendedPocketType: Boolean! = false
  ) {
    getShots(filterInput: $filterInput) {
      id
      videoId
      startFrame
      endFrame
      user {
        id
      }
      createdAt @include(if: $includeCreatedAt)
      updatedAt @include(if: $includeUpdatedAt)
      cueObjectFeatures @include(if: $includeCueObjectFeatures) {
        cueObjectDistance @include(if: $includeCueObjectDistance)
        cueObjectAngle @include(if: $includeCueObjectAngle)
        cueBallSpeed @include(if: $includeCueBallSpeed)
        shotDirection @include(if: $includeShotDirection)
      }
      pocketingIntentionFeatures
        @include(if: $includePocketingIntentionFeatures) {
        targetPocketDistance @include(if: $includeTargetPocketDistance)
        make @include(if: $includeMake)
        intendedPocketType @include(if: $includeIntendedPocketType)
      }
    }
  }
`;

/**
 * __useGetShotsQuery__
 *
 * To run a query within a React component, call `useGetShotsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetShotsQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      includeCreatedAt: // value for 'includeCreatedAt'
 *      includeUpdatedAt: // value for 'includeUpdatedAt'
 *      includeCueObjectFeatures: // value for 'includeCueObjectFeatures'
 *      includePocketingIntentionFeatures: // value for 'includePocketingIntentionFeatures'
 *      includeCueObjectDistance: // value for 'includeCueObjectDistance'
 *      includeCueObjectAngle: // value for 'includeCueObjectAngle'
 *      includeCueBallSpeed: // value for 'includeCueBallSpeed'
 *      includeShotDirection: // value for 'includeShotDirection'
 *      includeTargetPocketDistance: // value for 'includeTargetPocketDistance'
 *      includeMake: // value for 'includeMake'
 *      includeIntendedPocketType: // value for 'includeIntendedPocketType'
 *   },
 * });
 */
export function useGetShotsQuery(
  baseOptions: Apollo.QueryHookOptions<GetShotsQuery, GetShotsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetShotsQuery, GetShotsQueryVariables>(
    GetShotsDocument,
    options,
  );
}
export function useGetShotsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsQuery,
    GetShotsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetShotsQuery, GetShotsQueryVariables>(
    GetShotsDocument,
    options,
  );
}
export function useGetShotsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsQuery,
    GetShotsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetShotsQuery, GetShotsQueryVariables>(
    GetShotsDocument,
    options,
  );
}
export type GetShotsQueryHookResult = ReturnType<typeof useGetShotsQuery>;
export type GetShotsLazyQueryHookResult = ReturnType<
  typeof useGetShotsLazyQuery
>;
export type GetShotsSuspenseQueryHookResult = ReturnType<
  typeof useGetShotsSuspenseQuery
>;
export type GetShotsQueryResult = Apollo.QueryResult<
  GetShotsQuery,
  GetShotsQueryVariables
>;
export const GetProfileImageUploadLinkDocument = gql`
  mutation getProfileImageUploadLink($fileExt: String = ".png") {
    getProfileImageUploadLink(fileExt: $fileExt) {
      uploadUrl
      headers {
        key
        value
      }
    }
  }
`;
export type GetProfileImageUploadLinkMutationFn = Apollo.MutationFunction<
  GetProfileImageUploadLinkMutation,
  GetProfileImageUploadLinkMutationVariables
>;

/**
 * __useGetProfileImageUploadLinkMutation__
 *
 * To run a mutation, you first call `useGetProfileImageUploadLinkMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGetProfileImageUploadLinkMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [getProfileImageUploadLinkMutation, { data, loading, error }] = useGetProfileImageUploadLinkMutation({
 *   variables: {
 *      fileExt: // value for 'fileExt'
 *   },
 * });
 */
export function useGetProfileImageUploadLinkMutation(
  baseOptions?: Apollo.MutationHookOptions<
    GetProfileImageUploadLinkMutation,
    GetProfileImageUploadLinkMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    GetProfileImageUploadLinkMutation,
    GetProfileImageUploadLinkMutationVariables
  >(GetProfileImageUploadLinkDocument, options);
}
export type GetProfileImageUploadLinkMutationHookResult = ReturnType<
  typeof useGetProfileImageUploadLinkMutation
>;
export type GetProfileImageUploadLinkMutationResult =
  Apollo.MutationResult<GetProfileImageUploadLinkMutation>;
export type GetProfileImageUploadLinkMutationOptions =
  Apollo.BaseMutationOptions<
    GetProfileImageUploadLinkMutation,
    GetProfileImageUploadLinkMutationVariables
  >;
export const EditProfileImageUriDocument = gql`
  mutation editProfileImageUri($profileImageUri: String!) {
    editProfileImageUri(profileImageUri: $profileImageUri) {
      id
      firebaseUid
      username
      profileImageUri
      createdAt
      updatedAt
    }
  }
`;
export type EditProfileImageUriMutationFn = Apollo.MutationFunction<
  EditProfileImageUriMutation,
  EditProfileImageUriMutationVariables
>;

/**
 * __useEditProfileImageUriMutation__
 *
 * To run a mutation, you first call `useEditProfileImageUriMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditProfileImageUriMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [editProfileImageUriMutation, { data, loading, error }] = useEditProfileImageUriMutation({
 *   variables: {
 *      profileImageUri: // value for 'profileImageUri'
 *   },
 * });
 */
export function useEditProfileImageUriMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EditProfileImageUriMutation,
    EditProfileImageUriMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    EditProfileImageUriMutation,
    EditProfileImageUriMutationVariables
  >(EditProfileImageUriDocument, options);
}
export type EditProfileImageUriMutationHookResult = ReturnType<
  typeof useEditProfileImageUriMutation
>;
export type EditProfileImageUriMutationResult =
  Apollo.MutationResult<EditProfileImageUriMutation>;
export type EditProfileImageUriMutationOptions = Apollo.BaseMutationOptions<
  EditProfileImageUriMutation,
  EditProfileImageUriMutationVariables
>;
export const GetLoggedInUserDocument = gql`
  query getLoggedInUser {
    getLoggedInUser {
      id
      firebaseUid
      username
      profileImageUri
      activeVideoId
      createdAt
      updatedAt
    }
  }
`;

/**
 * __useGetLoggedInUserQuery__
 *
 * To run a query within a React component, call `useGetLoggedInUserQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetLoggedInUserQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetLoggedInUserQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetLoggedInUserQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetLoggedInUserQuery,
    GetLoggedInUserQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>(
    GetLoggedInUserDocument,
    options,
  );
}
export function useGetLoggedInUserLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetLoggedInUserQuery,
    GetLoggedInUserQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetLoggedInUserQuery,
    GetLoggedInUserQueryVariables
  >(GetLoggedInUserDocument, options);
}
export function useGetLoggedInUserSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetLoggedInUserQuery,
    GetLoggedInUserQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetLoggedInUserQuery,
    GetLoggedInUserQueryVariables
  >(GetLoggedInUserDocument, options);
}
export type GetLoggedInUserQueryHookResult = ReturnType<
  typeof useGetLoggedInUserQuery
>;
export type GetLoggedInUserLazyQueryHookResult = ReturnType<
  typeof useGetLoggedInUserLazyQuery
>;
export type GetLoggedInUserSuspenseQueryHookResult = ReturnType<
  typeof useGetLoggedInUserSuspenseQuery
>;
export type GetLoggedInUserQueryResult = Apollo.QueryResult<
  GetLoggedInUserQuery,
  GetLoggedInUserQueryVariables
>;
export const GetUserPlayTimeDocument = gql`
  query GetUserPlayTime($userId: Int!) {
    getPlayTime(userId: $userId) {
      totalSeconds
    }
  }
`;

/**
 * __useGetUserPlayTimeQuery__
 *
 * To run a query within a React component, call `useGetUserPlayTimeQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserPlayTimeQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetUserPlayTimeQuery({
 *   variables: {
 *      userId: // value for 'userId'
 *   },
 * });
 */
export function useGetUserPlayTimeQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetUserPlayTimeQuery,
    GetUserPlayTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>(
    GetUserPlayTimeDocument,
    options,
  );
}
export function useGetUserPlayTimeLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUserPlayTimeQuery,
    GetUserPlayTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUserPlayTimeQuery,
    GetUserPlayTimeQueryVariables
  >(GetUserPlayTimeDocument, options);
}
export function useGetUserPlayTimeSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUserPlayTimeQuery,
    GetUserPlayTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUserPlayTimeQuery,
    GetUserPlayTimeQueryVariables
  >(GetUserPlayTimeDocument, options);
}
export type GetUserPlayTimeQueryHookResult = ReturnType<
  typeof useGetUserPlayTimeQuery
>;
export type GetUserPlayTimeLazyQueryHookResult = ReturnType<
  typeof useGetUserPlayTimeLazyQuery
>;
export type GetUserPlayTimeSuspenseQueryHookResult = ReturnType<
  typeof useGetUserPlayTimeSuspenseQuery
>;
export type GetUserPlayTimeQueryResult = Apollo.QueryResult<
  GetUserPlayTimeQuery,
  GetUserPlayTimeQueryVariables
>;
export const GetStreamMonitoringDetailsDocument = gql`
  query GetStreamMonitoringDetails($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      totalShots
      makePercentage
      elapsedTime
      homographyHistory {
        crop {
          left
          top
          width
          height
        }
        pockets {
          left
          top
          width
          height
        }
        sourcePoints {
          topLeft {
            x
            y
          }
          topSide {
            x
            y
          }
          topRight {
            x
            y
          }
          bottomLeft {
            x
            y
          }
          bottomSide {
            x
            y
          }
          bottomRight {
            x
            y
          }
        }
      }
      stream {
        linksRequested
        uploadsCompleted
        segmentProcessingCursor
        isCompleted
        uploadCompletionCursor
        lastIntendedSegmentBound
      }
      currentProcessing {
        errors {
          message
          startSegmentIndex
          endSegmentIndex
        }
      }
    }
  }
`;

/**
 * __useGetStreamMonitoringDetailsQuery__
 *
 * To run a query within a React component, call `useGetStreamMonitoringDetailsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetStreamMonitoringDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetStreamMonitoringDetailsQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetStreamMonitoringDetailsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >(GetStreamMonitoringDetailsDocument, options);
}
export function useGetStreamMonitoringDetailsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >(GetStreamMonitoringDetailsDocument, options);
}
export function useGetStreamMonitoringDetailsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetStreamMonitoringDetailsQuery,
    GetStreamMonitoringDetailsQueryVariables
  >(GetStreamMonitoringDetailsDocument, options);
}
export type GetStreamMonitoringDetailsQueryHookResult = ReturnType<
  typeof useGetStreamMonitoringDetailsQuery
>;
export type GetStreamMonitoringDetailsLazyQueryHookResult = ReturnType<
  typeof useGetStreamMonitoringDetailsLazyQuery
>;
export type GetStreamMonitoringDetailsSuspenseQueryHookResult = ReturnType<
  typeof useGetStreamMonitoringDetailsSuspenseQuery
>;
export type GetStreamMonitoringDetailsQueryResult = Apollo.QueryResult<
  GetStreamMonitoringDetailsQuery,
  GetStreamMonitoringDetailsQueryVariables
>;
export const GetVideoUpdatePageDetailsDocument = gql`
  query GetVideoUpdatePageDetails($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      name
      totalShots
      makePercentage
      elapsedTime
      tags {
        tagClasses {
          name
        }
        name
      }
    }
  }
`;

/**
 * __useGetVideoUpdatePageDetailsQuery__
 *
 * To run a query within a React component, call `useGetVideoUpdatePageDetailsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoUpdatePageDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetVideoUpdatePageDetailsQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoUpdatePageDetailsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >(GetVideoUpdatePageDetailsDocument, options);
}
export function useGetVideoUpdatePageDetailsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >(GetVideoUpdatePageDetailsDocument, options);
}
export function useGetVideoUpdatePageDetailsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoUpdatePageDetailsQuery,
    GetVideoUpdatePageDetailsQueryVariables
  >(GetVideoUpdatePageDetailsDocument, options);
}
export type GetVideoUpdatePageDetailsQueryHookResult = ReturnType<
  typeof useGetVideoUpdatePageDetailsQuery
>;
export type GetVideoUpdatePageDetailsLazyQueryHookResult = ReturnType<
  typeof useGetVideoUpdatePageDetailsLazyQuery
>;
export type GetVideoUpdatePageDetailsSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoUpdatePageDetailsSuspenseQuery
>;
export type GetVideoUpdatePageDetailsQueryResult = Apollo.QueryResult<
  GetVideoUpdatePageDetailsQuery,
  GetVideoUpdatePageDetailsQueryVariables
>;
export const DeleteVideoDocument = gql`
  mutation DeleteVideo($videoId: Int!) {
    deleteVideo(videoId: $videoId)
  }
`;
export type DeleteVideoMutationFn = Apollo.MutationFunction<
  DeleteVideoMutation,
  DeleteVideoMutationVariables
>;

/**
 * __useDeleteVideoMutation__
 *
 * To run a mutation, you first call `useDeleteVideoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteVideoMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [deleteVideoMutation, { data, loading, error }] = useDeleteVideoMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useDeleteVideoMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DeleteVideoMutation,
    DeleteVideoMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<DeleteVideoMutation, DeleteVideoMutationVariables>(
    DeleteVideoDocument,
    options,
  );
}
export type DeleteVideoMutationHookResult = ReturnType<
  typeof useDeleteVideoMutation
>;
export type DeleteVideoMutationResult =
  Apollo.MutationResult<DeleteVideoMutation>;
export type DeleteVideoMutationOptions = Apollo.BaseMutationOptions<
  DeleteVideoMutation,
  DeleteVideoMutationVariables
>;
export const GetVideoDetailsDocument = gql`
  query GetVideoDetails($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      name
      screenshotUri
      averageTimeBetweenShots
      elapsedTime
      endTime
      makePercentage
      medianRun
      startTime
      totalShots
      totalShotsMade
      createdAt
      updatedAt
      owner {
        id
        firebaseUid
        username
        profileImageUri
      }
      tags {
        tagClasses {
          name
        }
        name
      }
    }
  }
`;

/**
 * __useGetVideoDetailsQuery__
 *
 * To run a query within a React component, call `useGetVideoDetailsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetVideoDetailsQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoDetailsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoDetailsQuery,
    GetVideoDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>(
    GetVideoDetailsDocument,
    options,
  );
}
export function useGetVideoDetailsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoDetailsQuery,
    GetVideoDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoDetailsQuery,
    GetVideoDetailsQueryVariables
  >(GetVideoDetailsDocument, options);
}
export function useGetVideoDetailsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoDetailsQuery,
    GetVideoDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoDetailsQuery,
    GetVideoDetailsQueryVariables
  >(GetVideoDetailsDocument, options);
}
export type GetVideoDetailsQueryHookResult = ReturnType<
  typeof useGetVideoDetailsQuery
>;
export type GetVideoDetailsLazyQueryHookResult = ReturnType<
  typeof useGetVideoDetailsLazyQuery
>;
export type GetVideoDetailsSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoDetailsSuspenseQuery
>;
export type GetVideoDetailsQueryResult = Apollo.QueryResult<
  GetVideoDetailsQuery,
  GetVideoDetailsQueryVariables
>;
export const GetVideosDocument = gql`
  query GetVideos($videoIds: [Int!]!) {
    getVideos(videoIds: $videoIds) {
      id
      playlist {
        segmentDurations
      }
      stream {
        id
        segments {
          uploaded
          valid
          segmentIndex
          endFrameIndex
          framesPerSecond
        }
      }
    }
  }
`;

/**
 * __useGetVideosQuery__
 *
 * To run a query within a React component, call `useGetVideosQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideosQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetVideosQuery({
 *   variables: {
 *      videoIds: // value for 'videoIds'
 *   },
 * });
 */
export function useGetVideosQuery(
  baseOptions: Apollo.QueryHookOptions<GetVideosQuery, GetVideosQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetVideosQuery, GetVideosQueryVariables>(
    GetVideosDocument,
    options,
  );
}
export function useGetVideosLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideosQuery,
    GetVideosQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetVideosQuery, GetVideosQueryVariables>(
    GetVideosDocument,
    options,
  );
}
export function useGetVideosSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideosQuery,
    GetVideosQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetVideosQuery, GetVideosQueryVariables>(
    GetVideosDocument,
    options,
  );
}
export type GetVideosQueryHookResult = ReturnType<typeof useGetVideosQuery>;
export type GetVideosLazyQueryHookResult = ReturnType<
  typeof useGetVideosLazyQuery
>;
export type GetVideosSuspenseQueryHookResult = ReturnType<
  typeof useGetVideosSuspenseQuery
>;
export type GetVideosQueryResult = Apollo.QueryResult<
  GetVideosQuery,
  GetVideosQueryVariables
>;
export const GetVideoDocument = gql`
  query GetVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      playlist {
        segmentDurations
      }
      stream {
        segments {
          segmentIndex
          endFrameIndex
          framesPerSecond
        }
      }
    }
  }
`;

/**
 * __useGetVideoQuery__
 *
 * To run a query within a React component, call `useGetVideoQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetVideoQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoQuery(
  baseOptions: Apollo.QueryHookOptions<GetVideoQuery, GetVideoQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetVideoQuery, GetVideoQueryVariables>(
    GetVideoDocument,
    options,
  );
}
export function useGetVideoLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoQuery,
    GetVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetVideoQuery, GetVideoQueryVariables>(
    GetVideoDocument,
    options,
  );
}
export function useGetVideoSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoQuery,
    GetVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetVideoQuery, GetVideoQueryVariables>(
    GetVideoDocument,
    options,
  );
}
export type GetVideoQueryHookResult = ReturnType<typeof useGetVideoQuery>;
export type GetVideoLazyQueryHookResult = ReturnType<
  typeof useGetVideoLazyQuery
>;
export type GetVideoSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoSuspenseQuery
>;
export type GetVideoQueryResult = Apollo.QueryResult<
  GetVideoQuery,
  GetVideoQueryVariables
>;
export const GetAverageTimePerShotForVideoDocument = gql`
  query GetAverageTimePerShotForVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      averageTimeBetweenShots
    }
  }
`;

/**
 * __useGetAverageTimePerShotForVideoQuery__
 *
 * To run a query within a React component, call `useGetAverageTimePerShotForVideoQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAverageTimePerShotForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetAverageTimePerShotForVideoQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetAverageTimePerShotForVideoQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >(GetAverageTimePerShotForVideoDocument, options);
}
export function useGetAverageTimePerShotForVideoLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >(GetAverageTimePerShotForVideoDocument, options);
}
export function useGetAverageTimePerShotForVideoSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetAverageTimePerShotForVideoQuery,
    GetAverageTimePerShotForVideoQueryVariables
  >(GetAverageTimePerShotForVideoDocument, options);
}
export type GetAverageTimePerShotForVideoQueryHookResult = ReturnType<
  typeof useGetAverageTimePerShotForVideoQuery
>;
export type GetAverageTimePerShotForVideoLazyQueryHookResult = ReturnType<
  typeof useGetAverageTimePerShotForVideoLazyQuery
>;
export type GetAverageTimePerShotForVideoSuspenseQueryHookResult = ReturnType<
  typeof useGetAverageTimePerShotForVideoSuspenseQuery
>;
export type GetAverageTimePerShotForVideoQueryResult = Apollo.QueryResult<
  GetAverageTimePerShotForVideoQuery,
  GetAverageTimePerShotForVideoQueryVariables
>;
export const GetElapsedTimeForVideoDocument = gql`
  query GetElapsedTimeForVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      elapsedTime
    }
  }
`;

/**
 * __useGetElapsedTimeForVideoQuery__
 *
 * To run a query within a React component, call `useGetElapsedTimeForVideoQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetElapsedTimeForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetElapsedTimeForVideoQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetElapsedTimeForVideoQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >(GetElapsedTimeForVideoDocument, options);
}
export function useGetElapsedTimeForVideoLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >(GetElapsedTimeForVideoDocument, options);
}
export function useGetElapsedTimeForVideoSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetElapsedTimeForVideoQuery,
    GetElapsedTimeForVideoQueryVariables
  >(GetElapsedTimeForVideoDocument, options);
}
export type GetElapsedTimeForVideoQueryHookResult = ReturnType<
  typeof useGetElapsedTimeForVideoQuery
>;
export type GetElapsedTimeForVideoLazyQueryHookResult = ReturnType<
  typeof useGetElapsedTimeForVideoLazyQuery
>;
export type GetElapsedTimeForVideoSuspenseQueryHookResult = ReturnType<
  typeof useGetElapsedTimeForVideoSuspenseQuery
>;
export type GetElapsedTimeForVideoQueryResult = Apollo.QueryResult<
  GetElapsedTimeForVideoQuery,
  GetElapsedTimeForVideoQueryVariables
>;
export const GetMedianRunForVideoDocument = gql`
  query GetMedianRunForVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      medianRun
    }
  }
`;

/**
 * __useGetMedianRunForVideoQuery__
 *
 * To run a query within a React component, call `useGetMedianRunForVideoQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMedianRunForVideoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetMedianRunForVideoQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetMedianRunForVideoQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >(GetMedianRunForVideoDocument, options);
}
export function useGetMedianRunForVideoLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >(GetMedianRunForVideoDocument, options);
}
export function useGetMedianRunForVideoSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMedianRunForVideoQuery,
    GetMedianRunForVideoQueryVariables
  >(GetMedianRunForVideoDocument, options);
}
export type GetMedianRunForVideoQueryHookResult = ReturnType<
  typeof useGetMedianRunForVideoQuery
>;
export type GetMedianRunForVideoLazyQueryHookResult = ReturnType<
  typeof useGetMedianRunForVideoLazyQuery
>;
export type GetMedianRunForVideoSuspenseQueryHookResult = ReturnType<
  typeof useGetMedianRunForVideoSuspenseQuery
>;
export type GetMedianRunForVideoQueryResult = Apollo.QueryResult<
  GetMedianRunForVideoQuery,
  GetMedianRunForVideoQueryVariables
>;
export const 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 EditUploadStreamDocument = gql`
  mutation EditUploadStream(
    $videoId: Int!
    $videoMetadataInput: VideoMetadataInput!
  ) {
    editUploadStream(videoId: $videoId, videoMetadata: $videoMetadataInput)
  }
`;
export type EditUploadStreamMutationFn = Apollo.MutationFunction<
  EditUploadStreamMutation,
  EditUploadStreamMutationVariables
>;

/**
 * __useEditUploadStreamMutation__
 *
 * To run a mutation, you first call `useEditUploadStreamMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditUploadStreamMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [editUploadStreamMutation, { data, loading, error }] = useEditUploadStreamMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      videoMetadataInput: // value for 'videoMetadataInput'
 *   },
 * });
 */
export function useEditUploadStreamMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EditUploadStreamMutation,
    EditUploadStreamMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    EditUploadStreamMutation,
    EditUploadStreamMutationVariables
  >(EditUploadStreamDocument, options);
}
export type EditUploadStreamMutationHookResult = ReturnType<
  typeof useEditUploadStreamMutation
>;
export type EditUploadStreamMutationResult =
  Apollo.MutationResult<EditUploadStreamMutation>;
export type EditUploadStreamMutationOptions = Apollo.BaseMutationOptions<
  EditUploadStreamMutation,
  EditUploadStreamMutationVariables
>;
export const GetUploadStreamsDocument = gql`
  query GetUploadStreams(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
  ) {
    getUserVideos(limit: $limit, after: $after, filters: $filters) {
      videos {
        id
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
`;

/**
 * __useGetUploadStreamsQuery__
 *
 * To run a query within a React component, call `useGetUploadStreamsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUploadStreamsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetUploadStreamsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *      filters: // value for 'filters'
 *   },
 * });
 */
export function useGetUploadStreamsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUploadStreamsQuery,
    GetUploadStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(
    GetUploadStreamsDocument,
    options,
  );
}
export function useGetUploadStreamsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUploadStreamsQuery,
    GetUploadStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUploadStreamsQuery,
    GetUploadStreamsQueryVariables
  >(GetUploadStreamsDocument, options);
}
export function useGetUploadStreamsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUploadStreamsQuery,
    GetUploadStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUploadStreamsQuery,
    GetUploadStreamsQueryVariables
  >(GetUploadStreamsDocument, options);
}
export type GetUploadStreamsQueryHookResult = ReturnType<
  typeof useGetUploadStreamsQuery
>;
export type GetUploadStreamsLazyQueryHookResult = ReturnType<
  typeof useGetUploadStreamsLazyQuery
>;
export type GetUploadStreamsSuspenseQueryHookResult = ReturnType<
  typeof useGetUploadStreamsSuspenseQuery
>;
export type GetUploadStreamsQueryResult = Apollo.QueryResult<
  GetUploadStreamsQuery,
  GetUploadStreamsQueryVariables
>;
export const GetUploadStreamsWithDetailsDocument = gql`
  query GetUploadStreamsWithDetails(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
  ) {
    getUserVideos(limit: $limit, after: $after, filters: $filters) {
      videos {
        id
        name
        startTime
        stream {
          isCompleted
          lastIntendedSegmentBound
          uploadCompletionCursor
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
`;

/**
 * __useGetUploadStreamsWithDetailsQuery__
 *
 * To run a query within a React component, call `useGetUploadStreamsWithDetailsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUploadStreamsWithDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useGetUploadStreamsWithDetailsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *      filters: // value for 'filters'
 *   },
 * });
 */
export function useGetUploadStreamsWithDetailsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >(GetUploadStreamsWithDetailsDocument, options);
}
export function useGetUploadStreamsWithDetailsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >(GetUploadStreamsWithDetailsDocument, options);
}
export function useGetUploadStreamsWithDetailsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUploadStreamsWithDetailsQuery,
    GetUploadStreamsWithDetailsQueryVariables
  >(GetUploadStreamsWithDetailsDocument, options);
}
export type GetUploadStreamsWithDetailsQueryHookResult = ReturnType<
  typeof useGetUploadStreamsWithDetailsQuery
>;
export type GetUploadStreamsWithDetailsLazyQueryHookResult = ReturnType<
  typeof useGetUploadStreamsWithDetailsLazyQuery
>;
export type GetUploadStreamsWithDetailsSuspenseQueryHookResult = ReturnType<
  typeof useGetUploadStreamsWithDetailsSuspenseQuery
>;
export type GetUploadStreamsWithDetailsQueryResult = Apollo.QueryResult<
  GetUploadStreamsWithDetailsQuery,
  GetUploadStreamsWithDetailsQueryVariables
>;