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 (isoformat) */
  Date: { input: any; output: any };
  /** Date with time (isoformat) */
  DateTime: { input: any; output: any };
  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](https://ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf). */
  JSON: { input: any; output: any };
};

export type AddShotAnnotationErrors = {
  __typename?: "AddShotAnnotationErrors";
  error: DoesNotOwnShotErrOtherErrorNeedsNote;
};

export type AddShotAnnotationReturn = {
  __typename?: "AddShotAnnotationReturn";
  value: SuccessfulAddAddShotAnnotationErrors;
};

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; datetimeRange?: never; enum?: never }
  | {
      bucketSet?: never;
      datetimeRange: DatetimeRangeAggregationInput;
      enum?: never;
    }
  | { bucketSet?: never; datetimeRange?: never; enum: EnumAggregation };

export enum AlignedIntervalEnum {
  Day = "DAY",
  Month = "MONTH",
  Week = "WEEK",
  Year = "YEAR",
}

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 CreatedAfter =
  | { createdAt: Scalars["DateTime"]["input"]; videoId?: never }
  | { createdAt?: never; videoId: Scalars["Int"]["input"] };

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

export type DateRangeFilter = {
  greaterThan?: InputMaybe<Scalars["Date"]["input"]>;
  greaterThanEqualTo?: InputMaybe<Scalars["Date"]["input"]>;
  greaterThanInclusive?: Scalars["Boolean"]["input"];
  includeOnNone?: Scalars["Boolean"]["input"];
  lessThan?: InputMaybe<Scalars["Date"]["input"]>;
  lessThanInclusive?: Scalars["Boolean"]["input"];
};

export type DatetimeRangeAggregationInput = {
  endDatetime?: InputMaybe<Scalars["DateTime"]["input"]>;
  feature?: Scalars["String"]["input"];
  interval: TimeInterval;
  startDatetime?: InputMaybe<Scalars["DateTime"]["input"]>;
};

export type DatetimeShotOrdering = {
  descending?: Scalars["Boolean"]["input"];
  startingAt?: InputMaybe<Scalars["DateTime"]["input"]>;
};

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

export type DoesNotOwnShotErr = {
  __typename?: "DoesNotOwnShotErr";
  msg?: Maybe<Scalars["String"]["output"]>;
  shotId: Scalars["Int"]["output"];
};

export type DoesNotOwnShotErrOtherErrorNeedsNote =
  | DoesNotOwnShotErr
  | OtherErrorNeedsNote;

export type EditUserInputGql = {
  fargoRating?: InputMaybe<Scalars["Int"]["input"]>;
  username?: InputMaybe<Scalars["String"]["input"]>;
  videosPrivateByDefault?: InputMaybe<Scalars["Boolean"]["input"]>;
};

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

export type FilterInput =
  | {
      andFilters: Array<FilterInput>;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations: Array<ShotAnnotationInput>;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut: Array<Scalars["Boolean"]["input"]>;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle: FloatRangeFilter;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance: FloatRangeFilter;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt: DateRangeFilter;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject: FloatRangeFilter;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed: FloatRangeFilter;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle: FloatRangeFilter;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance: FloatRangeFilter;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject: FloatRangeFilter;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty: FloatRangeFilter;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore: FloatRangeFilter;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating: FloatRangeFilter;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType: Array<PocketEnum>;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect: Array<Scalars["Boolean"]["input"]>;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft: Array<Scalars["Boolean"]["input"]>;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss: Array<Scalars["Boolean"]["input"]>;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight: Array<Scalars["Boolean"]["input"]>;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss: Array<Scalars["Boolean"]["input"]>;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight: Array<Scalars["Boolean"]["input"]>;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle: FloatRangeFilter;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance: FloatRangeFilter;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make: Array<Scalars["Boolean"]["input"]>;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees: FloatRangeFilter;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees: FloatRangeFilter;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter: FilterInput;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters: Array<FilterInput>;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength: FloatRangeFilter;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection: Array<ShotDirectionEnum>;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType: Array<SpinTypeEnum>;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize: FloatRangeFilter;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags: Array<VideoTagInput>;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle: FloatRangeFilter;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection: Array<ShotDirectionEnum>;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance: FloatRangeFilter;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance: FloatRangeFilter;
      userId?: never;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId: Array<Scalars["Int"]["input"]>;
      username?: never;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username: Array<Scalars["String"]["input"]>;
      videoId?: never;
    }
  | {
      andFilters?: never;
      annotations?: never;
      backcut?: never;
      bankAngle?: never;
      bankDistance?: never;
      createdAt?: never;
      cueAngleAfterObject?: never;
      cueBallSpeed?: never;
      cueObjectAngle?: never;
      cueObjectDistance?: never;
      cueSpeedAfterObject?: never;
      difficulty?: never;
      falsePositiveScore?: never;
      fargoRating?: never;
      intendedPocketType?: never;
      isDirect?: never;
      isLeft?: never;
      isLeftMiss?: never;
      isRight?: never;
      isRightMiss?: never;
      isStraight?: never;
      kickAngle?: never;
      kickDistance?: never;
      make?: never;
      marginOfErrorInDegrees?: never;
      missAngleInDegrees?: never;
      notFilter?: never;
      orFilters?: never;
      runLength?: never;
      shotDirection?: never;
      spinType?: never;
      tableSize?: never;
      tags?: never;
      targetPocketAngle?: never;
      targetPocketAngleDirection?: never;
      targetPocketDistance?: never;
      totalDistance?: never;
      userId?: never;
      username?: never;
      videoId: Array<Scalars["Int"]["input"]>;
    };

export type FloatRangeFilter = {
  greaterThan?: InputMaybe<Scalars["Float"]["input"]>;
  greaterThanEqualTo?: InputMaybe<Scalars["Float"]["input"]>;
  greaterThanInclusive?: Scalars["Boolean"]["input"];
  includeOnNone?: Scalars["Boolean"]["input"];
  lessThan?: InputMaybe<Scalars["Float"]["input"]>;
  lessThanInclusive?: Scalars["Boolean"]["input"];
};

export type FloatShotOrdering = {
  descending?: Scalars["Boolean"]["input"];
  startingAt?: InputMaybe<Scalars["Float"]["input"]>;
};

export type GetProfileUploadLinkErrors = {
  __typename?: "GetProfileUploadLinkErrors";
  error: TooManyProfileImageUploadsErr;
};

export type GetProfileUploadLinkReturn = {
  __typename?: "GetProfileUploadLinkReturn";
  value: UploadLinkGetProfileUploadLinkErrors;
};

export type GetShotsOrdering = {
  orderings: Array<ShotsOrderingComponent>;
};

export type GetShotsPagination = {
  createdAfter: CreatedAfter;
  startFrameAfter: Scalars["Int"]["input"];
};

export type GetShotsResult = {
  __typename?: "GetShotsResult";
  count?: Maybe<Scalars["Int"]["output"]>;
  ids: Array<Scalars["Int"]["output"]>;
  shots: Array<ShotGql>;
};

export type GetUploadLinkErrors = {
  __typename?: "GetUploadLinkErrors";
  error: MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErr;
};

export type GetUploadLinkReturn = {
  __typename?: "GetUploadLinkReturn";
  stream?: Maybe<UploadStreamGql>;
  value: UploadLinkGetUploadLinkErrors;
};

export type HlsPlaylistGql = {
  __typename?: "HLSPlaylistGQL";
  m3u8Text: Scalars["String"]["output"];
  segmentDurations: Array<Scalars["Float"]["output"]>;
  segmentStartTimes: 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"];
  id: Scalars["Int"]["output"];
  pockets: Array<BoundingBoxGql>;
  sourcePoints: PocketPointsGql;
};

export enum InitPlaylistUploadStatusEnum {
  NotApplicable = "NOT_APPLICABLE",
  NotUploaded = "NOT_UPLOADED",
  Uploaded = "UPLOADED",
}

export type InitUploadAlreadyCompletedErr = {
  __typename?: "InitUploadAlreadyCompletedErr";
  segmentType: StreamSegmentTypeEnum;
};

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

export type IntShotOrdering = {
  descending?: Scalars["Boolean"]["input"];
  startingAt?: InputMaybe<Scalars["Int"]["input"]>;
};

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

export type MedalGql = {
  __typename?: "MedalGQL";
  count: Scalars["Int"]["output"];
};

export type MedalScope =
  | { interval: TimeInterval; videoId?: never }
  | { interval?: never; videoId: Scalars["Int"]["input"] };

export type MustHaveSetForUploadLinkErr = {
  __typename?: "MustHaveSetForUploadLinkErr";
  framesPerSecond?: Maybe<Scalars["Boolean"]["output"]>;
  resolution?: Maybe<Scalars["Boolean"]["output"]>;
};

export type MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErr =

    | InitUploadAlreadyCompletedErr
    | MustHaveSetForUploadLinkErr
    | NoInitForChunkedUploadErr
    | ProcessingFailedErr
    | SegmentAlreadyUploadedErr
    | TooManyInitUploadsErr
    | TooManyProfileImageUploadsErr;

export type Mutation = {
  __typename?: "Mutation";
  addAnnotationToShot: AddShotAnnotationReturn;
  createBucketSet: BucketSetGql;
  createUploadStream: CreateUploadStreamReturn;
  deleteVideo: Scalars["Boolean"]["output"];
  editProfileImageUri: UserGql;
  editUploadStream: Scalars["Boolean"]["output"];
  editUser: UserGql;
  findPrerecordTableLayout?: Maybe<HomographyInfoGql>;
  followUser: UserGql;
  getHlsInitUploadLink: GetUploadLinkReturn;
  getProfileImageUploadLink: GetProfileUploadLinkReturn;
  getUploadLink: GetUploadLinkReturn;
  setLoggerLevel: Scalars["Boolean"]["output"];
  setSegmentDuration: Scalars["Boolean"]["output"];
  unfollowUser: UserGql;
  updateShotAnnotations: UpdateShotAnnotationReturn;
};

export type MutationAddAnnotationToShotArgs = {
  annotationName: Scalars["String"]["input"];
  notes?: InputMaybe<Scalars["String"]["input"]>;
  shotId: Scalars["Int"]["input"];
};

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 MutationEditUserArgs = {
  input: EditUserInputGql;
};

export type MutationFindPrerecordTableLayoutArgs = {
  b64Image: Scalars["String"]["input"];
  videoId: Scalars["Int"]["input"];
};

export type MutationFollowUserArgs = {
  followedUserId: Scalars["Int"]["input"];
};

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

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 MutationSetSegmentDurationArgs = {
  duration: Scalars["Float"]["input"];
  segmentIndex: Scalars["Int"]["input"];
  videoId: Scalars["Int"]["input"];
};

export type MutationUnfollowUserArgs = {
  followedUserId: Scalars["Int"]["input"];
};

export type MutationUpdateShotAnnotationsArgs = {
  annotations: Array<UpdateAnnotationInputGql>;
  shotId: Scalars["Int"]["input"];
};

export type NoInitForChunkedUploadErr = {
  __typename?: "NoInitForChunkedUploadErr";
  segmentType: StreamSegmentTypeEnum;
};

export type OtherErrorNeedsNote = {
  __typename?: "OtherErrorNeedsNote";
  msg?: Maybe<Scalars["String"]["output"]>;
};

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

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

export enum PocketIdentifier {
  BottomLeft = "BOTTOM_LEFT",
  BottomRight = "BOTTOM_RIGHT",
  BottomSide = "BOTTOM_SIDE",
  TopLeft = "TOP_LEFT",
  TopRight = "TOP_RIGHT",
  TopSide = "TOP_SIDE",
}

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

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

export type PocketingIntentionInfoGql = {
  __typename?: "PocketingIntentionInfoGQL";
  ballId: Scalars["Int"]["output"];
  pathMetadataIndex: Scalars["Int"]["output"];
  pocketId: PocketIdentifier;
};

export type ProcessingFailedErr = {
  __typename?: "ProcessingFailedErr";
  processing: VideoProcessingGql;
};

export enum ProcessingStatusEnum {
  Created = "CREATED",
  Failed = "FAILED",
  Queued = "QUEUED",
  ReextractingFeatures = "REEXTRACTING_FEATURES",
  Running = "RUNNING",
  Started = "STARTED",
  Succeeded = "SUCCEEDED",
  Suspended = "SUSPENDED",
}

export type Query = {
  __typename?: "Query";
  doesUsernameExist: Scalars["Boolean"]["output"];
  getAggregatedShotMetrics: Array<AggregateResultGql>;
  getBucketSet?: Maybe<BucketSetGql>;
  getDeployedConfig: DeployedConfigGql;
  getFeedVideos: VideoHistoryGql;
  getLoggedInUser?: Maybe<UserGql>;
  getMedals: RequestedMedalsGql;
  getOrderedShots: GetShotsResult;
  getPlayTime: UserPlayTimeGql;
  getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
  getShots: Array<ShotGql>;
  getShotsByIds: Array<ShotGql>;
  getShotsWithMetadata: GetShotsResult;
  getUser?: Maybe<UserGql>;
  getUserRelationshipsMatching: UserRelationshipsResult;
  getUserTags: Array<TagGql>;
  getUserVideos: VideoHistoryGql;
  getUsernames: Array<Scalars["String"]["output"]>;
  getVideo: VideoGql;
  getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
  getVideos: Array<VideoGql>;
  waitFor: Scalars["Float"]["output"];
};

export type QueryDoesUsernameExistArgs = {
  candidateUsername: Scalars["String"]["input"];
};

export type QueryGetAggregatedShotMetricsArgs = {
  aggregateInput: AggregateInputGql;
};

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

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

export type QueryGetMedalsArgs = {
  scope: MedalScope;
  userId?: InputMaybe<Scalars["Int"]["input"]>;
};

export type QueryGetOrderedShotsArgs = {
  countRespectsLimit?: Scalars["Boolean"]["input"];
  filterInput: FilterInput;
  ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  limit?: Scalars["Int"]["input"];
  shotsOrdering?: InputMaybe<GetShotsOrdering>;
};

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

export type QueryGetShotAnnotationTypesArgs = {
  errorTypes?: InputMaybe<Scalars["Boolean"]["input"]>;
};

export type QueryGetShotsArgs = {
  countRespectsLimit?: Scalars["Boolean"]["input"];
  filterInput: FilterInput;
  limit?: Scalars["Int"]["input"];
  shotsPagination?: InputMaybe<GetShotsPagination>;
};

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

export type QueryGetShotsWithMetadataArgs = {
  countRespectsLimit?: Scalars["Boolean"]["input"];
  filterInput: FilterInput;
  ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  limit?: Scalars["Int"]["input"];
  shotsPagination?: InputMaybe<GetShotsPagination>;
};

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

export type QueryGetUserRelationshipsMatchingArgs = {
  after?: InputMaybe<Scalars["String"]["input"]>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  matchString?: InputMaybe<Scalars["String"]["input"]>;
  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 QueryGetUsernamesArgs = {
  after?: InputMaybe<Scalars["String"]["input"]>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  matchString?: InputMaybe<Scalars["String"]["input"]>;
};

export type QueryGetVideoArgs = {
  debuggingJson?: InputMaybe<Scalars["JSON"]["input"]>;
  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 QueryWaitForArgs = {
  duration: Scalars["Float"]["input"];
};

export type RequestedMedalsGql = {
  __typename?: "RequestedMedalsGQL";
  dayStreak2?: Maybe<MedalGql>;
  dayStreak3?: Maybe<MedalGql>;
  dayStreak4?: Maybe<MedalGql>;
  dayStreak5?: Maybe<MedalGql>;
  dayStreak6?: Maybe<MedalGql>;
  dayStreak7?: Maybe<MedalGql>;
  dayStreak14?: Maybe<MedalGql>;
  dayStreak21?: Maybe<MedalGql>;
  dayStreak30?: Maybe<MedalGql>;
  dayStreak60?: Maybe<MedalGql>;
  dayStreak90?: Maybe<MedalGql>;
  distanceOver66?: Maybe<MedalGql>;
  distanceOver78?: Maybe<MedalGql>;
  distanceOver90?: Maybe<MedalGql>;
  runLength3?: Maybe<MedalGql>;
  runLength5?: Maybe<MedalGql>;
  runLength8?: Maybe<MedalGql>;
  runLength10?: Maybe<MedalGql>;
  runLength15?: Maybe<MedalGql>;
  runLength20?: Maybe<MedalGql>;
  runLength25?: Maybe<MedalGql>;
  runLength30?: Maybe<MedalGql>;
  runLength40?: Maybe<MedalGql>;
  runLength50?: Maybe<MedalGql>;
  totalMakes25?: Maybe<MedalGql>;
  totalMakes50?: Maybe<MedalGql>;
  totalMakes75?: Maybe<MedalGql>;
  totalMakes100?: Maybe<MedalGql>;
  totalMakes200?: Maybe<MedalGql>;
  totalMakes300?: Maybe<MedalGql>;
  totalMakes400?: Maybe<MedalGql>;
  totalMakes500?: Maybe<MedalGql>;
  totalMakes750?: Maybe<MedalGql>;
  totalMakes1000?: Maybe<MedalGql>;
};

export type SegmentAlreadyUploadedErr = {
  __typename?: "SegmentAlreadyUploadedErr";
  segmentId: Scalars["Int"]["output"];
};

export type SegmentEndFramesGql = {
  __typename?: "SegmentEndFramesGQL";
  id: Scalars["Int"]["output"];
  segmentEndFrames: Array<Scalars["Int"]["output"]>;
};

export type SegmentStartTimesGql = {
  __typename?: "SegmentStartTimesGQL";
  id: Scalars["Int"]["output"];
  segmentStartTimes: Array<Scalars["Float"]["output"]>;
};

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

export type ShotAnnotationGql = {
  __typename?: "ShotAnnotationGQL";
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  creator: UserGql;
  errorDefault: Scalars["Boolean"]["output"];
  notes: Scalars["String"]["output"];
  shotId: Scalars["Int"]["output"];
  type: ShotAnnotationTypeGql;
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
};

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

export type ShotAnnotationTypeGql = {
  __typename?: "ShotAnnotationTypeGQL";
  id: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
};

export type ShotDirectionCountsGql = {
  __typename?: "ShotDirectionCountsGQL";
  left: Scalars["Int"]["output"];
  right: Scalars["Int"]["output"];
  straight: Scalars["Int"]["output"];
};

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

export type ShotGql = {
  __typename?: "ShotGQL";
  annotations: Array<ShotAnnotationGql>;
  bankFeatures?: Maybe<BankFeaturesGql>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
  endFrame: Scalars["Int"]["output"];
  endTime: Scalars["Float"]["output"];
  falsePositiveScore?: Maybe<Scalars["Float"]["output"]>;
  id: Scalars["Int"]["output"];
  pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
  pocketingIntentionInfo?: Maybe<PocketingIntentionInfoGql>;
  serializedShotPaths?: Maybe<SerializedShotPathsGql>;
  startFrame: Scalars["Int"]["output"];
  startTime: Scalars["Float"]["output"];
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  user?: Maybe<UserGql>;
  video?: Maybe<VideoGql>;
  videoId: Scalars["Int"]["output"];
};

export type ShotsOrderingComponent =
  | {
      marginOfError: FloatShotOrdering;
      runLength?: never;
      startFrame?: never;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      marginOfError?: never;
      runLength: IntShotOrdering;
      startFrame?: never;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      marginOfError?: never;
      runLength?: never;
      startFrame: IntShotOrdering;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      marginOfError?: never;
      runLength?: never;
      startFrame?: never;
      videoCreation: DatetimeShotOrdering;
      videoId?: never;
    }
  | {
      marginOfError?: never;
      runLength?: never;
      startFrame?: never;
      videoCreation?: never;
      videoId: IntShotOrdering;
    };

export type SpinTypeCountsGql = {
  __typename?: "SpinTypeCountsGQL";
  center: Scalars["Int"]["output"];
  draw: Scalars["Int"]["output"];
  follow: Scalars["Int"]["output"];
  unknown: Scalars["Int"]["output"];
};

export enum SpinTypeEnum {
  Center = "CENTER",
  Draw = "DRAW",
  Follow = "FOLLOW",
  Unknown = "UNKNOWN",
}

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

export enum StreamSegmentTypeEnum {
  FragmentedMp4 = "FRAGMENTED_MP4",
  RbChunkedMp4 = "RB_CHUNKED_MP4",
}

export type SuccessfulAdd = {
  __typename?: "SuccessfulAdd";
  value: Scalars["Boolean"]["output"];
};

export type SuccessfulAddAddShotAnnotationErrors =
  | AddShotAnnotationErrors
  | SuccessfulAdd;

export type TagGql = {
  __typename?: "TagGQL";
  group?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
};

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

export type TimeDeltaGql = {
  days?: InputMaybe<Scalars["Int"]["input"]>;
  months?: InputMaybe<Scalars["Int"]["input"]>;
  weeks?: InputMaybe<Scalars["Int"]["input"]>;
  years?: InputMaybe<Scalars["Int"]["input"]>;
};

export type TimeInterval =
  | { aligned: AlignedIntervalEnum; timedelta?: never }
  | { aligned?: never; timedelta: TimeDeltaGql };

export type TooManyInitUploadsErr = {
  __typename?: "TooManyInitUploadsErr";
  linksRequested: Scalars["Int"]["output"];
};

export type TooManyProfileImageUploadsErr = {
  __typename?: "TooManyProfileImageUploadsErr";
  linksRequested: Scalars["Int"]["output"];
};

export type UpdateAnnotationInputGql = {
  name: Scalars["String"]["input"];
  notes?: InputMaybe<Scalars["String"]["input"]>;
};

export type UpdateShotAnnotationReturn = {
  __typename?: "UpdateShotAnnotationReturn";
  error?: Maybe<DoesNotOwnShotErr>;
  shot?: Maybe<ShotGql>;
};

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

export type UploadLinkGetProfileUploadLinkErrors =
  | GetProfileUploadLinkErrors
  | UploadLink;

export type UploadLinkGetUploadLinkErrors = GetUploadLinkErrors | UploadLink;

export type UploadSegmentGql = {
  __typename?: "UploadSegmentGQL";
  durationInSeconds?: 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"];
  initPlaylistUploadStatus?: Maybe<InitPlaylistUploadStatusEnum>;
  isCompleted: Scalars["Boolean"]["output"];
  lastIntendedSegmentBound?: Maybe<Scalars["Int"]["output"]>;
  linksRequested: Scalars["Int"]["output"];
  lowestUnuploadedSegmentIndex: Scalars["Int"]["output"];
  resolution: VideoResolutionGql;
  segmentEndFrames: Array<Scalars["Int"]["output"]>;
  segmentProcessingCursor: Scalars["Int"]["output"];
  segments: Array<UploadSegmentGql>;
  streamSegmentType: StreamSegmentTypeEnum;
  updatedAt: Scalars["DateTime"]["output"];
  uploadCompletionCursor: Scalars["Int"]["output"];
  uploadsCompleted: Scalars["Int"]["output"];
};

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

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

export type UserRelationship = {
  __typename?: "UserRelationship";
  toUser: UserGql;
  toUserFollows: Scalars["Boolean"]["output"];
  toUserIsFollowedBy: Scalars["Boolean"]["output"];
};

export type UserRelationshipsResult = {
  __typename?: "UserRelationshipsResult";
  inquiringUser: UserGql;
  relationships: Array<UserRelationship>;
};

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

export type VideoGql = {
  __typename?: "VideoGQL";
  averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  currentHomography?: Maybe<HomographyInfoGql>;
  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>;
  private: Scalars["Boolean"]["output"];
  screenshotUri?: Maybe<Scalars["String"]["output"]>;
  shots: Array<ShotGql>;
  startTime?: Maybe<Scalars["DateTime"]["output"]>;
  stream?: Maybe<UploadStreamGql>;
  tableSize: Scalars["Float"]["output"];
  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"]>;
  framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
  private?: InputMaybe<Scalars["Boolean"]["input"]>;
  resolution?: InputMaybe<VideoResolution>;
  startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  streamSegmentType?: InputMaybe<StreamSegmentTypeEnum>;
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
  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>;
  id: Scalars["Int"]["output"];
  status: ProcessingStatusEnum;
  statuses: Array<VideoProcessingStatusGql>;
};

export type VideoProcessingStatusGql = {
  __typename?: "VideoProcessingStatusGQL";
  appVersion: Scalars["String"]["output"];
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  sequenceId: Scalars["Int"]["output"];
  status: ProcessingStatusEnum;
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
};

export type VideoResolution = {
  height: Scalars["Int"]["input"];
  width: Scalars["Int"]["input"];
};

export type VideoResolutionGql = {
  __typename?: "VideoResolutionGQL";
  height?: Maybe<Scalars["Int"]["output"]>;
  width?: Maybe<Scalars["Int"]["output"]>;
};

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;
    minimumAllowedAppVersion: string;
  };
};

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;
      tableSize: number;
      owner?: { __typename?: "UserGQL"; username: string } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        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 VideoCardFieldsFragment = {
  __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;
  private: boolean;
  elapsedTime?: number | null;
  tableSize: number;
  owner?: {
    __typename?: "UserGQL";
    id: number;
    username: string;
    profileImageUri?: string | null;
  } | null;
  stream?: {
    __typename?: "UploadStreamGQL";
    id: string;
    isCompleted: boolean;
  } | null;
  tags: Array<{
    __typename?: "VideoTag";
    name: string;
    tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
  }>;
  currentProcessing?: {
    __typename?: "VideoProcessingGQL";
    id: number;
    status: ProcessingStatusEnum;
    errors: Array<{ __typename?: "VideoProcessingErrorGQL"; message: string }>;
    statuses: Array<{
      __typename?: "VideoProcessingStatusGQL";
      status: ProcessingStatusEnum;
    }>;
  } | null;
};

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

export type GetVideoFeedQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __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;
      private: boolean;
      elapsedTime?: number | null;
      tableSize: number;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        isCompleted: boolean;
      } | null;
      tags: Array<{
        __typename?: "VideoTag";
        name: string;
        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
      }>;
      currentProcessing?: {
        __typename?: "VideoProcessingGQL";
        id: number;
        status: ProcessingStatusEnum;
        errors: Array<{
          __typename?: "VideoProcessingErrorGQL";
          message: string;
        }>;
        statuses: Array<{
          __typename?: "VideoProcessingStatusGQL";
          status: ProcessingStatusEnum;
        }>;
      } | null;
    }>;
    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 GetSerializedShotPathsQueryVariables = Exact<{
  filterInput: FilterInput;
}>;

export type GetSerializedShotPathsQuery = {
  __typename?: "Query";
  getShots: Array<{
    __typename?: "ShotGQL";
    id: number;
    videoId: number;
    startFrame: number;
    endFrame: number;
    serializedShotPaths?: {
      __typename?: "SerializedShotPathsGQL";
      b64EncodedBuffer?: string | null;
    } | null;
  }>;
};

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

export type GetShotAnnotationTypesQuery = {
  __typename?: "Query";
  getShotAnnotationTypes: Array<{
    __typename?: "ShotAnnotationTypeGQL";
    id: number;
    name: string;
  }>;
};

export type UpdateShotAnnotationsMutationVariables = Exact<{
  shotId: Scalars["Int"]["input"];
  annotations: Array<UpdateAnnotationInputGql> | UpdateAnnotationInputGql;
}>;

export type UpdateShotAnnotationsMutation = {
  __typename?: "Mutation";
  updateShotAnnotations: {
    __typename?: "UpdateShotAnnotationReturn";
    shot?: {
      __typename?: "ShotGQL";
      id: number;
      annotations: Array<{
        __typename?: "ShotAnnotationGQL";
        shotId: number;
        notes: string;
        type: {
          __typename?: "ShotAnnotationTypeGQL";
          id: number;
          name: string;
        };
      }>;
    } | null;
    error?: {
      __typename?: "DoesNotOwnShotErr";
      shotId: number;
      msg?: string | null;
    } | null;
  };
};

export type GetShotsWithVideoGqlQueryVariables = Exact<{
  filterInput: FilterInput;
  shotsOrdering?: InputMaybe<GetShotsOrdering>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
}>;

export type GetShotsWithVideoGqlQuery = {
  __typename?: "Query";
  getOrderedShots: {
    __typename?: "GetShotsResult";
    shots: Array<{
      __typename?: "ShotGQL";
      id: number;
      videoId: number;
      video?: {
        __typename?: "VideoGQL";
        screenshotUri?: string | null;
        endTime?: any | null;
      } | null;
    }>;
  };
};

export type GetShotsWithJustIdsQueryVariables = Exact<{
  filterInput: FilterInput;
  shotsOrdering?: InputMaybe<GetShotsOrdering>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  countRespectsLimit?: InputMaybe<Scalars["Boolean"]["input"]>;
}>;

export type GetShotsWithJustIdsQuery = {
  __typename?: "Query";
  getOrderedShots: {
    __typename?: "GetShotsResult";
    count?: number | null;
    shots: Array<{ __typename?: "ShotGQL"; id: number; videoId: number }>;
  };
};

export type GetShotsWithMetadataFilterResultQueryVariables = Exact<{
  filterInput: FilterInput;
  shotsOrdering?: InputMaybe<GetShotsOrdering>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
  countRespectsLimit?: InputMaybe<Scalars["Boolean"]["input"]>;
}>;

export type GetShotsWithMetadataFilterResultQuery = {
  __typename?: "Query";
  getOrderedShots: {
    __typename?: "GetShotsResult";
    count?: number | null;
    ids: Array<number>;
    shots: Array<{
      __typename?: "ShotGQL";
      id: number;
      videoId: number;
      startFrame: number;
      endFrame: number;
      startTime: number;
      endTime: number;
      falsePositiveScore?: number | null;
      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;
        spinType?: SpinTypeEnum | null;
      } | null;
      pocketingIntentionFeatures?: {
        __typename?: "PocketingIntentionFeaturesGQL";
        make?: boolean | null;
        targetPocketDistance?: number | null;
        targetPocketAngle?: number | null;
        targetPocketAngleDirection?: ShotDirectionEnum | null;
        marginOfErrorInDegrees?: number | null;
        intendedPocketType?: PocketEnum | null;
      } | null;
      pocketingIntentionInfo?: {
        __typename?: "PocketingIntentionInfoGQL";
        ballId: number;
        pocketId: PocketIdentifier;
        pathMetadataIndex: number;
      } | null;
      serializedShotPaths?: {
        __typename?: "SerializedShotPathsGQL";
        b64EncodedBuffer?: string | null;
      } | null;
      annotations: Array<{
        __typename?: "ShotAnnotationGQL";
        shotId: number;
        notes: string;
        type: {
          __typename?: "ShotAnnotationTypeGQL";
          id: number;
          name: string;
        };
      }>;
    }>;
  };
};

export type GetShotsWithMetadataQueryVariables = Exact<{
  filterInput: FilterInput;
  shotsPagination?: InputMaybe<GetShotsPagination>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
}>;

export type GetShotsWithMetadataQuery = {
  __typename?: "Query";
  getShotsWithMetadata: {
    __typename?: "GetShotsResult";
    count?: number | null;
    ids: Array<number>;
    shots: Array<{
      __typename?: "ShotGQL";
      id: number;
      videoId: number;
      startFrame: number;
      endFrame: number;
      startTime: number;
      endTime: number;
      falsePositiveScore?: number | null;
      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;
        spinType?: SpinTypeEnum | null;
      } | null;
      pocketingIntentionFeatures?: {
        __typename?: "PocketingIntentionFeaturesGQL";
        make?: boolean | null;
        targetPocketDistance?: number | null;
        targetPocketAngle?: number | null;
        targetPocketAngleDirection?: ShotDirectionEnum | null;
        marginOfErrorInDegrees?: number | null;
        intendedPocketType?: PocketEnum | null;
      } | null;
      pocketingIntentionInfo?: {
        __typename?: "PocketingIntentionInfoGQL";
        ballId: number;
        pocketId: PocketIdentifier;
        pathMetadataIndex: number;
      } | null;
      serializedShotPaths?: {
        __typename?: "SerializedShotPathsGQL";
        b64EncodedBuffer?: string | null;
      } | null;
      annotations: Array<{
        __typename?: "ShotAnnotationGQL";
        shotId: number;
        notes: string;
        type: {
          __typename?: "ShotAnnotationTypeGQL";
          id: number;
          name: string;
        };
      }>;
    }>;
  };
};

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

export type GetShotsByIdsQuery = {
  __typename?: "Query";
  getShotsByIds: Array<{
    __typename?: "ShotGQL";
    id: number;
    videoId: number;
    startFrame: number;
    endFrame: number;
    startTime: number;
    endTime: number;
    falsePositiveScore?: number | null;
    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;
      spinType?: SpinTypeEnum | null;
    } | null;
    pocketingIntentionFeatures?: {
      __typename?: "PocketingIntentionFeaturesGQL";
      make?: boolean | null;
      targetPocketDistance?: number | null;
      targetPocketAngle?: number | null;
      targetPocketAngleDirection?: ShotDirectionEnum | null;
      marginOfErrorInDegrees?: number | null;
      intendedPocketType?: PocketEnum | null;
    } | null;
    pocketingIntentionInfo?: {
      __typename?: "PocketingIntentionInfoGQL";
      ballId: number;
      pocketId: PocketIdentifier;
      pathMetadataIndex: number;
    } | null;
    serializedShotPaths?: {
      __typename?: "SerializedShotPathsGQL";
      b64EncodedBuffer?: string | null;
    } | null;
    annotations: Array<{
      __typename?: "ShotAnnotationGQL";
      shotId: number;
      notes: string;
      type: { __typename?: "ShotAnnotationTypeGQL"; id: number; name: string };
    }>;
  }>;
};

export type ShotWithAllFeaturesFragment = {
  __typename?: "ShotGQL";
  id: number;
  videoId: number;
  startFrame: number;
  endFrame: number;
  startTime: number;
  endTime: number;
  falsePositiveScore?: number | null;
  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;
    spinType?: SpinTypeEnum | null;
  } | null;
  pocketingIntentionFeatures?: {
    __typename?: "PocketingIntentionFeaturesGQL";
    make?: boolean | null;
    targetPocketDistance?: number | null;
    targetPocketAngle?: number | null;
    targetPocketAngleDirection?: ShotDirectionEnum | null;
    marginOfErrorInDegrees?: number | null;
    intendedPocketType?: PocketEnum | null;
  } | null;
  pocketingIntentionInfo?: {
    __typename?: "PocketingIntentionInfoGQL";
    ballId: number;
    pocketId: PocketIdentifier;
    pathMetadataIndex: number;
  } | null;
  serializedShotPaths?: {
    __typename?: "SerializedShotPathsGQL";
    b64EncodedBuffer?: string | null;
  } | null;
  annotations: Array<{
    __typename?: "ShotAnnotationGQL";
    shotId: number;
    notes: string;
    type: { __typename?: "ShotAnnotationTypeGQL"; id: number; name: string };
  }>;
};

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

export type GetProfileImageUploadLinkMutation = {
  __typename?: "Mutation";
  getProfileImageUploadLink: {
    __typename?: "GetProfileUploadLinkReturn";
    value:
      | {
          __typename?: "GetProfileUploadLinkErrors";
          error: {
            __typename?: "TooManyProfileImageUploadsErr";
            linksRequested: number;
          };
        }
      | {
          __typename?: "UploadLink";
          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 | null;
    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 | null;
    username: string;
    isAdmin?: boolean | null;
    profileImageUri?: string | null;
    fargoRating?: number | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
  } | null;
};

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

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

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

export type GetUsernamesQuery = {
  __typename?: "Query";
  getUsernames: Array<string>;
};

export type GetUserRelationshipsMatchingQueryVariables = Exact<{
  userId: Scalars["Int"]["input"];
  matchString: Scalars["String"]["input"];
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  after?: InputMaybe<Scalars["String"]["input"]>;
}>;

export type GetUserRelationshipsMatchingQuery = {
  __typename?: "Query";
  getUserRelationshipsMatching: {
    __typename?: "UserRelationshipsResult";
    relationships: Array<{
      __typename?: "UserRelationship";
      toUserFollows: boolean;
      toUserIsFollowedBy: boolean;
      toUser: { __typename?: "UserGQL"; username: string; id: number };
    }>;
  };
};

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

export type GetUserTagsQuery = {
  __typename?: "Query";
  getUserTags: Array<{ __typename?: "TagGQL"; id: number; name: string }>;
};

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

export type FollowUserMutation = {
  __typename?: "Mutation";
  followUser: {
    __typename?: "UserGQL";
    username: string;
    id: number;
    following?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
    followers?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
  };
};

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

export type UnfollowUserMutation = {
  __typename?: "Mutation";
  unfollowUser: {
    __typename?: "UserGQL";
    username: string;
    id: number;
    following?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
    followers?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
  };
};

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

export type GetUserFollowingFollowersQuery = {
  __typename?: "Query";
  getLoggedInUser?: {
    __typename?: "UserGQL";
    id: number;
    following?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
    followers?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
    }> | null;
  } | null;
};

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

export type DoesUsernameExistQuery = {
  __typename?: "Query";
  doesUsernameExist: boolean;
};

export type EditUserMutationVariables = Exact<{
  username?: InputMaybe<Scalars["String"]["input"]>;
  fargoRating?: InputMaybe<Scalars["Int"]["input"]>;
  videosPrivateByDefault?: InputMaybe<Scalars["Boolean"]["input"]>;
}>;

export type EditUserMutation = {
  __typename?: "Mutation";
  editUser: {
    __typename?: "UserGQL";
    id: number;
    firebaseUid?: string | null;
    username: string;
    fargoRating?: number | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
  };
};

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

export type GetStreamMonitoringDetailsQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    totalShots: number;
    makePercentage: number;
    elapsedTime?: number | null;
    currentHomography?: {
      __typename?: "HomographyInfoGQL";
      frameIndex: number;
      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;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      linksRequested: number;
      uploadsCompleted: number;
      segmentProcessingCursor: number;
      isCompleted: boolean;
      uploadCompletionCursor: number;
      lastIntendedSegmentBound?: number | null;
      initPlaylistUploadStatus?: InitPlaylistUploadStatusEnum | 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;
    tableSize: number;
    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;
    tableSize: number;
    owner?: {
      __typename?: "UserGQL";
      id: number;
      firebaseUid?: string | null;
      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;
    framesPerSecond: number;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      streamSegmentType: StreamSegmentTypeEnum;
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        uploaded: boolean;
        valid: boolean;
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
    } | null;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      segmentDurations: Array<number>;
    } | null;
  }>;
};

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

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

export type GetVideoForShotTimeQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    framesPerSecond: number;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      streamSegmentType: StreamSegmentTypeEnum;
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        uploaded: boolean;
        valid: boolean;
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
    } | null;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      segmentDurations: Array<number>;
    } | 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;
    homographyHistory: Array<{
      __typename?: "HomographyInfoGQL";
      frameIndex: number;
      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";
      id: string;
      streamSegmentType: StreamSegmentTypeEnum;
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
      resolution: {
        __typename?: "VideoResolutionGQL";
        width?: number | null;
        height?: number | null;
      };
    } | null;
  };
};

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

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

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

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

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

export type GetMedianRunForVideoQuery = {
  __typename?: "Query";
  getVideo: { __typename?: "VideoGQL"; id: number; medianRun?: number | null };
};

export type StreamWithEndFramesFragment = {
  __typename?: "UploadStreamGQL";
  id: string;
  streamSegmentType: StreamSegmentTypeEnum;
  segmentEndFrames: Array<number>;
  resolution: {
    __typename?: "VideoResolutionGQL";
    width?: number | null;
    height?: number | null;
  };
  segments: Array<{
    __typename?: "UploadSegmentGQL";
    uploaded: boolean;
    valid: boolean;
    segmentIndex: number;
    endFrameIndex?: number | null;
    framesPerSecond?: number | null;
  }>;
};

export type SegmentEndFramesFragment = {
  __typename?: "SegmentEndFramesGQL";
  id: number;
  segmentEndFrames: Array<number>;
};

export type SegmentStartTimesFragment = {
  __typename?: "SegmentStartTimesGQL";
  id: number;
  segmentStartTimes: Array<number>;
};

export type PlaylistWithSegmentStartTimesFragment = {
  __typename?: "HLSPlaylistGQL";
  videoId: number;
  segmentDurations: Array<number>;
  segmentStartTimes: Array<number>;
};

export type VideoDurationDataFragment = {
  __typename?: "VideoGQL";
  id: number;
  framesPerSecond: number;
  playlist?: {
    __typename?: "HLSPlaylistGQL";
    videoId: number;
    segmentDurations: Array<number>;
    segmentStartTimes: Array<number>;
  } | null;
  stream?: {
    __typename?: "UploadStreamGQL";
    id: string;
    streamSegmentType: StreamSegmentTypeEnum;
    segmentEndFrames: Array<number>;
    resolution: {
      __typename?: "VideoResolutionGQL";
      width?: number | null;
      height?: number | null;
    };
    segments: Array<{
      __typename?: "UploadSegmentGQL";
      uploaded: boolean;
      valid: boolean;
      segmentIndex: number;
      endFrameIndex?: number | null;
      framesPerSecond?: number | null;
    }>;
  } | null;
};

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

export type GetVideoForClipTimesQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    framesPerSecond: number;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      videoId: number;
      segmentDurations: Array<number>;
      segmentStartTimes: Array<number>;
    } | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      streamSegmentType: StreamSegmentTypeEnum;
      segmentEndFrames: Array<number>;
      resolution: {
        __typename?: "VideoResolutionGQL";
        width?: number | null;
        height?: number | null;
      };
      segments: Array<{
        __typename?: "UploadSegmentGQL";
        uploaded: boolean;
        valid: boolean;
        segmentIndex: number;
        endFrameIndex?: number | null;
        framesPerSecond?: number | null;
      }>;
    } | null;
  };
};

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

export type GetHeaderInfoByVideoIdQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    startTime?: any | null;
  };
};

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

export type FindPrerecordTableLayoutMutation = {
  __typename?: "Mutation";
  findPrerecordTableLayout?: {
    __typename?: "HomographyInfoGQL";
    frameIndex: number;
    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 HomographyInfoFragment = {
  __typename?: "HomographyInfoGQL";
  frameIndex: number;
  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 };
  };
};

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";
    value:
      | {
          __typename?: "GetUploadLinkErrors";
          error:
            | { __typename?: "InitUploadAlreadyCompletedErr" }
            | {
                __typename?: "MustHaveSetForUploadLinkErr";
                resolution?: boolean | null;
                framesPerSecond?: boolean | null;
              }
            | { __typename?: "NoInitForChunkedUploadErr" }
            | {
                __typename?: "ProcessingFailedErr";
                processing: {
                  __typename?: "VideoProcessingGQL";
                  status: ProcessingStatusEnum;
                  errors: Array<{
                    __typename?: "VideoProcessingErrorGQL";
                    message: string;
                  }>;
                };
              }
            | { __typename?: "SegmentAlreadyUploadedErr"; segmentId: number }
            | { __typename?: "TooManyInitUploadsErr" }
            | { __typename?: "TooManyProfileImageUploadsErr" };
        }
      | {
          __typename?: "UploadLink";
          uploadUrl: string;
          headers: Array<{
            __typename?: "Header";
            key: string;
            value: string;
          } | null>;
        };
    stream?: {
      __typename?: "UploadStreamGQL";
      uploadCompletionCursor: number;
    } | null;
  };
};

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

export type GetHlsInitUploadLinkMutation = {
  __typename?: "Mutation";
  getHlsInitUploadLink: {
    __typename?: "GetUploadLinkReturn";
    value:
      | {
          __typename?: "GetUploadLinkErrors";
          error:
            | {
                __typename?: "InitUploadAlreadyCompletedErr";
                segmentType: StreamSegmentTypeEnum;
              }
            | { __typename?: "MustHaveSetForUploadLinkErr" }
            | {
                __typename?: "NoInitForChunkedUploadErr";
                segmentType: StreamSegmentTypeEnum;
              }
            | { __typename?: "ProcessingFailedErr" }
            | { __typename?: "SegmentAlreadyUploadedErr" }
            | { __typename?: "TooManyInitUploadsErr"; linksRequested: number }
            | { __typename?: "TooManyProfileImageUploadsErr" };
        }
      | {
          __typename?: "UploadLink";
          uploadUrl: string;
          headers: Array<{
            __typename?: "Header";
            key: string;
            value: string;
          } | null>;
        };
  };
};

export type SetSegmentDurationMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  segmentIndex: Scalars["Int"]["input"];
  duration: Scalars["Float"]["input"];
}>;

export type SetSegmentDurationMutation = {
  __typename?: "Mutation";
  setSegmentDuration: boolean;
};

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;
        uploadsCompleted: number;
      } | null;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export const VideoCardFieldsFragmentDoc = gql`
  fragment VideoCardFields on VideoGQL {
    id
    owner {
      id
      username
      profileImageUri
    }
    name
    screenshotUri
    totalShotsMade
    totalShots
    makePercentage
    createdAt
    updatedAt
    startTime
    endTime
    private
    elapsedTime
    screenshotUri
    stream {
      id
      isCompleted
    }
    tableSize
    tags {
      tagClasses {
        name
      }
      name
    }
    currentProcessing {
      id
      errors {
        message
      }
      status
      statuses {
        status
      }
    }
  }
`;
export const ShotWithAllFeaturesFragmentDoc = gql`
  fragment ShotWithAllFeatures on ShotGQL {
    id
    videoId
    startFrame
    endFrame
    startTime @client
    endTime @client
    user {
      id
    }
    falsePositiveScore
    createdAt
    updatedAt
    cueObjectFeatures {
      cueObjectDistance
      cueObjectAngle
      cueBallSpeed
      shotDirection
      spinType
    }
    pocketingIntentionFeatures {
      make
      targetPocketDistance
      targetPocketAngle
      targetPocketAngleDirection
      marginOfErrorInDegrees
      intendedPocketType
    }
    pocketingIntentionInfo {
      ballId
      pocketId
      pathMetadataIndex
    }
    serializedShotPaths {
      b64EncodedBuffer
    }
    annotations {
      shotId
      type {
        id
        name
      }
      notes
    }
  }
`;
export const VideoStreamMetadataFragmentDoc = gql`
  fragment VideoStreamMetadata on VideoGQL {
    id
    framesPerSecond
    stream {
      id
      streamSegmentType
      segments {
        uploaded
        valid
        segmentIndex
        endFrameIndex
        framesPerSecond
      }
    }
    playlist {
      segmentDurations
    }
  }
`;
export const SegmentEndFramesFragmentDoc = gql`
  fragment SegmentEndFrames on SegmentEndFramesGQL {
    id
    segmentEndFrames
  }
`;
export const SegmentStartTimesFragmentDoc = gql`
  fragment SegmentStartTimes on SegmentStartTimesGQL {
    id
    segmentStartTimes
  }
`;
export const PlaylistWithSegmentStartTimesFragmentDoc = gql`
  fragment PlaylistWithSegmentStartTimes on HLSPlaylistGQL {
    videoId
    segmentDurations
    segmentStartTimes @client
  }
`;
export const StreamWithEndFramesFragmentDoc = gql`
  fragment StreamWithEndFrames on UploadStreamGQL {
    id
    streamSegmentType
    segmentEndFrames @client
    resolution {
      width
      height
    }
    segments {
      uploaded
      valid
      segmentIndex
      endFrameIndex
      framesPerSecond
    }
  }
`;
export const VideoDurationDataFragmentDoc = gql`
  fragment VideoDurationData on VideoGQL {
    id
    framesPerSecond
    playlist {
      ...PlaylistWithSegmentStartTimes
    }
    stream {
      ...StreamWithEndFrames
    }
  }
  ${PlaylistWithSegmentStartTimesFragmentDoc}
  ${StreamWithEndFramesFragmentDoc}
`;
export const HomographyInfoFragmentDoc = gql`
  fragment HomographyInfo on HomographyInfoGQL {
    frameIndex
    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
      }
    }
  }
`;
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
      minimumAllowedAppVersion
    }
  }
`;

/**
 * __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 {
          id
          isCompleted
        }
        tableSize
        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 GetVideoFeedDocument = gql`
  query GetVideoFeed(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
  ) {
    getFeedVideos(limit: $limit, after: $after, filters: $filters) {
      videos {
        ...VideoCardFields
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
  ${VideoCardFieldsFragmentDoc}
`;

/**
 * __useGetVideoFeedQuery__
 *
 * To run a query within a React component, call `useGetVideoFeedQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoFeedQuery` 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 } = useGetVideoFeedQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *      filters: // value for 'filters'
 *   },
 * });
 */
export function useGetVideoFeedQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetVideoFeedQuery,
    GetVideoFeedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
    GetVideoFeedDocument,
    options,
  );
}
export function useGetVideoFeedLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoFeedQuery,
    GetVideoFeedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
    GetVideoFeedDocument,
    options,
  );
}
export function useGetVideoFeedSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoFeedQuery,
    GetVideoFeedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
    GetVideoFeedDocument,
    options,
  );
}
export type GetVideoFeedQueryHookResult = ReturnType<
  typeof useGetVideoFeedQuery
>;
export type GetVideoFeedLazyQueryHookResult = ReturnType<
  typeof useGetVideoFeedLazyQuery
>;
export type GetVideoFeedSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoFeedSuspenseQuery
>;
export type GetVideoFeedQueryResult = Apollo.QueryResult<
  GetVideoFeedQuery,
  GetVideoFeedQueryVariables
>;
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 GetSerializedShotPathsDocument = gql`
  query GetSerializedShotPaths($filterInput: FilterInput!) {
    getShots(filterInput: $filterInput) {
      id
      videoId
      startFrame
      endFrame
      serializedShotPaths {
        b64EncodedBuffer
      }
    }
  }
`;

/**
 * __useGetSerializedShotPathsQuery__
 *
 * To run a query within a React component, call `useGetSerializedShotPathsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSerializedShotPathsQuery` 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 } = useGetSerializedShotPathsQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *   },
 * });
 */
export function useGetSerializedShotPathsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >(GetSerializedShotPathsDocument, options);
}
export function useGetSerializedShotPathsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >(GetSerializedShotPathsDocument, options);
}
export function useGetSerializedShotPathsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetSerializedShotPathsQuery,
    GetSerializedShotPathsQueryVariables
  >(GetSerializedShotPathsDocument, options);
}
export type GetSerializedShotPathsQueryHookResult = ReturnType<
  typeof useGetSerializedShotPathsQuery
>;
export type GetSerializedShotPathsLazyQueryHookResult = ReturnType<
  typeof useGetSerializedShotPathsLazyQuery
>;
export type GetSerializedShotPathsSuspenseQueryHookResult = ReturnType<
  typeof useGetSerializedShotPathsSuspenseQuery
>;
export type GetSerializedShotPathsQueryResult = Apollo.QueryResult<
  GetSerializedShotPathsQuery,
  GetSerializedShotPathsQueryVariables
>;
export const GetShotAnnotationTypesDocument = gql`
  query GetShotAnnotationTypes {
    getShotAnnotationTypes {
      id
      name
    }
  }
`;

/**
 * __useGetShotAnnotationTypesQuery__
 *
 * To run a query within a React component, call `useGetShotAnnotationTypesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotAnnotationTypesQuery` 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 } = useGetShotAnnotationTypesQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetShotAnnotationTypesQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >(GetShotAnnotationTypesDocument, options);
}
export function useGetShotAnnotationTypesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >(GetShotAnnotationTypesDocument, options);
}
export function useGetShotAnnotationTypesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotAnnotationTypesQuery,
    GetShotAnnotationTypesQueryVariables
  >(GetShotAnnotationTypesDocument, options);
}
export type GetShotAnnotationTypesQueryHookResult = ReturnType<
  typeof useGetShotAnnotationTypesQuery
>;
export type GetShotAnnotationTypesLazyQueryHookResult = ReturnType<
  typeof useGetShotAnnotationTypesLazyQuery
>;
export type GetShotAnnotationTypesSuspenseQueryHookResult = ReturnType<
  typeof useGetShotAnnotationTypesSuspenseQuery
>;
export type GetShotAnnotationTypesQueryResult = Apollo.QueryResult<
  GetShotAnnotationTypesQuery,
  GetShotAnnotationTypesQueryVariables
>;
export const UpdateShotAnnotationsDocument = gql`
  mutation UpdateShotAnnotations(
    $shotId: Int!
    $annotations: [UpdateAnnotationInputGQL!]!
  ) {
    updateShotAnnotations(shotId: $shotId, annotations: $annotations) {
      shot {
        id
        annotations {
          shotId
          type {
            id
            name
          }
          notes
        }
      }
      error {
        shotId
        msg
      }
    }
  }
`;
export type UpdateShotAnnotationsMutationFn = Apollo.MutationFunction<
  UpdateShotAnnotationsMutation,
  UpdateShotAnnotationsMutationVariables
>;

/**
 * __useUpdateShotAnnotationsMutation__
 *
 * To run a mutation, you first call `useUpdateShotAnnotationsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateShotAnnotationsMutation` 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 [updateShotAnnotationsMutation, { data, loading, error }] = useUpdateShotAnnotationsMutation({
 *   variables: {
 *      shotId: // value for 'shotId'
 *      annotations: // value for 'annotations'
 *   },
 * });
 */
export function useUpdateShotAnnotationsMutation(
  baseOptions?: Apollo.MutationHookOptions<
    UpdateShotAnnotationsMutation,
    UpdateShotAnnotationsMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    UpdateShotAnnotationsMutation,
    UpdateShotAnnotationsMutationVariables
  >(UpdateShotAnnotationsDocument, options);
}
export type UpdateShotAnnotationsMutationHookResult = ReturnType<
  typeof useUpdateShotAnnotationsMutation
>;
export type UpdateShotAnnotationsMutationResult =
  Apollo.MutationResult<UpdateShotAnnotationsMutation>;
export type UpdateShotAnnotationsMutationOptions = Apollo.BaseMutationOptions<
  UpdateShotAnnotationsMutation,
  UpdateShotAnnotationsMutationVariables
>;
export const GetShotsWithVideoGqlDocument = gql`
  query GetShotsWithVideoGql(
    $filterInput: FilterInput!
    $shotsOrdering: GetShotsOrdering
    $limit: Int
  ) {
    getOrderedShots(
      filterInput: $filterInput
      shotsOrdering: $shotsOrdering
      limit: $limit
    ) {
      shots {
        id
        videoId
        video {
          screenshotUri
          endTime
        }
      }
    }
  }
`;

/**
 * __useGetShotsWithVideoGqlQuery__
 *
 * To run a query within a React component, call `useGetShotsWithVideoGqlQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsWithVideoGqlQuery` 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 } = useGetShotsWithVideoGqlQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      shotsOrdering: // value for 'shotsOrdering'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetShotsWithVideoGqlQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >(GetShotsWithVideoGqlDocument, options);
}
export function useGetShotsWithVideoGqlLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >(GetShotsWithVideoGqlDocument, options);
}
export function useGetShotsWithVideoGqlSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotsWithVideoGqlQuery,
    GetShotsWithVideoGqlQueryVariables
  >(GetShotsWithVideoGqlDocument, options);
}
export type GetShotsWithVideoGqlQueryHookResult = ReturnType<
  typeof useGetShotsWithVideoGqlQuery
>;
export type GetShotsWithVideoGqlLazyQueryHookResult = ReturnType<
  typeof useGetShotsWithVideoGqlLazyQuery
>;
export type GetShotsWithVideoGqlSuspenseQueryHookResult = ReturnType<
  typeof useGetShotsWithVideoGqlSuspenseQuery
>;
export type GetShotsWithVideoGqlQueryResult = Apollo.QueryResult<
  GetShotsWithVideoGqlQuery,
  GetShotsWithVideoGqlQueryVariables
>;
export const GetShotsWithJustIdsDocument = gql`
  query GetShotsWithJustIds(
    $filterInput: FilterInput!
    $shotsOrdering: GetShotsOrdering
    $limit: Int
    $countRespectsLimit: Boolean
  ) {
    getOrderedShots(
      filterInput: $filterInput
      shotsOrdering: $shotsOrdering
      limit: $limit
      countRespectsLimit: $countRespectsLimit
    ) {
      count
      shots {
        id
        videoId
      }
    }
  }
`;

/**
 * __useGetShotsWithJustIdsQuery__
 *
 * To run a query within a React component, call `useGetShotsWithJustIdsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsWithJustIdsQuery` 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 } = useGetShotsWithJustIdsQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      shotsOrdering: // value for 'shotsOrdering'
 *      limit: // value for 'limit'
 *      countRespectsLimit: // value for 'countRespectsLimit'
 *   },
 * });
 */
export function useGetShotsWithJustIdsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >(GetShotsWithJustIdsDocument, options);
}
export function useGetShotsWithJustIdsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >(GetShotsWithJustIdsDocument, options);
}
export function useGetShotsWithJustIdsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotsWithJustIdsQuery,
    GetShotsWithJustIdsQueryVariables
  >(GetShotsWithJustIdsDocument, options);
}
export type GetShotsWithJustIdsQueryHookResult = ReturnType<
  typeof useGetShotsWithJustIdsQuery
>;
export type GetShotsWithJustIdsLazyQueryHookResult = ReturnType<
  typeof useGetShotsWithJustIdsLazyQuery
>;
export type GetShotsWithJustIdsSuspenseQueryHookResult = ReturnType<
  typeof useGetShotsWithJustIdsSuspenseQuery
>;
export type GetShotsWithJustIdsQueryResult = Apollo.QueryResult<
  GetShotsWithJustIdsQuery,
  GetShotsWithJustIdsQueryVariables
>;
export const GetShotsWithMetadataFilterResultDocument = gql`
  query GetShotsWithMetadataFilterResult(
    $filterInput: FilterInput!
    $shotsOrdering: GetShotsOrdering
    $limit: Int
    $ids: [Int!]
    $countRespectsLimit: Boolean
  ) {
    getOrderedShots(
      filterInput: $filterInput
      shotsOrdering: $shotsOrdering
      limit: $limit
      ids: $ids
      countRespectsLimit: $countRespectsLimit
    ) {
      count
      shots {
        ...ShotWithAllFeatures
      }
      ids
    }
  }
  ${ShotWithAllFeaturesFragmentDoc}
`;

/**
 * __useGetShotsWithMetadataFilterResultQuery__
 *
 * To run a query within a React component, call `useGetShotsWithMetadataFilterResultQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsWithMetadataFilterResultQuery` 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 } = useGetShotsWithMetadataFilterResultQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      shotsOrdering: // value for 'shotsOrdering'
 *      limit: // value for 'limit'
 *      ids: // value for 'ids'
 *      countRespectsLimit: // value for 'countRespectsLimit'
 *   },
 * });
 */
export function useGetShotsWithMetadataFilterResultQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >(GetShotsWithMetadataFilterResultDocument, options);
}
export function useGetShotsWithMetadataFilterResultLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >(GetShotsWithMetadataFilterResultDocument, options);
}
export function useGetShotsWithMetadataFilterResultSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotsWithMetadataFilterResultQuery,
    GetShotsWithMetadataFilterResultQueryVariables
  >(GetShotsWithMetadataFilterResultDocument, options);
}
export type GetShotsWithMetadataFilterResultQueryHookResult = ReturnType<
  typeof useGetShotsWithMetadataFilterResultQuery
>;
export type GetShotsWithMetadataFilterResultLazyQueryHookResult = ReturnType<
  typeof useGetShotsWithMetadataFilterResultLazyQuery
>;
export type GetShotsWithMetadataFilterResultSuspenseQueryHookResult =
  ReturnType<typeof useGetShotsWithMetadataFilterResultSuspenseQuery>;
export type GetShotsWithMetadataFilterResultQueryResult = Apollo.QueryResult<
  GetShotsWithMetadataFilterResultQuery,
  GetShotsWithMetadataFilterResultQueryVariables
>;
export const GetShotsWithMetadataDocument = gql`
  query GetShotsWithMetadata(
    $filterInput: FilterInput!
    $shotsPagination: GetShotsPagination
    $limit: Int
    $ids: [Int!]
  ) {
    getShotsWithMetadata(
      filterInput: $filterInput
      shotsPagination: $shotsPagination
      limit: $limit
      ids: $ids
    ) {
      count
      shots {
        ...ShotWithAllFeatures
      }
      ids
    }
  }
  ${ShotWithAllFeaturesFragmentDoc}
`;

/**
 * __useGetShotsWithMetadataQuery__
 *
 * To run a query within a React component, call `useGetShotsWithMetadataQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsWithMetadataQuery` 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 } = useGetShotsWithMetadataQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      shotsPagination: // value for 'shotsPagination'
 *      limit: // value for 'limit'
 *      ids: // value for 'ids'
 *   },
 * });
 */
export function useGetShotsWithMetadataQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >(GetShotsWithMetadataDocument, options);
}
export function useGetShotsWithMetadataLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >(GetShotsWithMetadataDocument, options);
}
export function useGetShotsWithMetadataSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotsWithMetadataQuery,
    GetShotsWithMetadataQueryVariables
  >(GetShotsWithMetadataDocument, options);
}
export type GetShotsWithMetadataQueryHookResult = ReturnType<
  typeof useGetShotsWithMetadataQuery
>;
export type GetShotsWithMetadataLazyQueryHookResult = ReturnType<
  typeof useGetShotsWithMetadataLazyQuery
>;
export type GetShotsWithMetadataSuspenseQueryHookResult = ReturnType<
  typeof useGetShotsWithMetadataSuspenseQuery
>;
export type GetShotsWithMetadataQueryResult = Apollo.QueryResult<
  GetShotsWithMetadataQuery,
  GetShotsWithMetadataQueryVariables
>;
export const GetShotsByIdsDocument = gql`
  query GetShotsByIds($ids: [Int!]!) {
    getShotsByIds(ids: $ids) {
      ...ShotWithAllFeatures
    }
  }
  ${ShotWithAllFeaturesFragmentDoc}
`;

/**
 * __useGetShotsByIdsQuery__
 *
 * To run a query within a React component, call `useGetShotsByIdsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotsByIdsQuery` 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 } = useGetShotsByIdsQuery({
 *   variables: {
 *      ids: // value for 'ids'
 *   },
 * });
 */
export function useGetShotsByIdsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotsByIdsQuery,
    GetShotsByIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>(
    GetShotsByIdsDocument,
    options,
  );
}
export function useGetShotsByIdsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotsByIdsQuery,
    GetShotsByIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>(
    GetShotsByIdsDocument,
    options,
  );
}
export function useGetShotsByIdsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotsByIdsQuery,
    GetShotsByIdsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotsByIdsQuery,
    GetShotsByIdsQueryVariables
  >(GetShotsByIdsDocument, options);
}
export type GetShotsByIdsQueryHookResult = ReturnType<
  typeof useGetShotsByIdsQuery
>;
export type GetShotsByIdsLazyQueryHookResult = ReturnType<
  typeof useGetShotsByIdsLazyQuery
>;
export type GetShotsByIdsSuspenseQueryHookResult = ReturnType<
  typeof useGetShotsByIdsSuspenseQuery
>;
export type GetShotsByIdsQueryResult = Apollo.QueryResult<
  GetShotsByIdsQuery,
  GetShotsByIdsQueryVariables
>;
export const GetProfileImageUploadLinkDocument = gql`
  mutation getProfileImageUploadLink($fileExt: String = ".png") {
    getProfileImageUploadLink(fileExt: $fileExt) {
      value {
        ... on UploadLink {
          uploadUrl
          headers {
            key
            value
          }
        }
        ... on GetProfileUploadLinkErrors {
          error {
            ... on TooManyProfileImageUploadsErr {
              linksRequested
            }
          }
        }
      }
    }
  }
`;
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
      isAdmin
      profileImageUri
      fargoRating
      activeVideoId
      createdAt
      updatedAt
      videosPrivateByDefault
    }
  }
`;

/**
 * __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!, $filters: VideoFilterInput) {
    getPlayTime(userId: $userId, filters: $filters) {
      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'
 *      filters: // value for 'filters'
 *   },
 * });
 */
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 GetUsernamesDocument = gql`
  query getUsernames(
    $matchString: String!
    $limit: Int = null
    $after: String = null
  ) {
    getUsernames(matchString: $matchString, limit: $limit, after: $after)
  }
`;

/**
 * __useGetUsernamesQuery__
 *
 * To run a query within a React component, call `useGetUsernamesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUsernamesQuery` 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 } = useGetUsernamesQuery({
 *   variables: {
 *      matchString: // value for 'matchString'
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *   },
 * });
 */
export function useGetUsernamesQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetUsernamesQuery,
    GetUsernamesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
    GetUsernamesDocument,
    options,
  );
}
export function useGetUsernamesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUsernamesQuery,
    GetUsernamesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
    GetUsernamesDocument,
    options,
  );
}
export function useGetUsernamesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUsernamesQuery,
    GetUsernamesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
    GetUsernamesDocument,
    options,
  );
}
export type GetUsernamesQueryHookResult = ReturnType<
  typeof useGetUsernamesQuery
>;
export type GetUsernamesLazyQueryHookResult = ReturnType<
  typeof useGetUsernamesLazyQuery
>;
export type GetUsernamesSuspenseQueryHookResult = ReturnType<
  typeof useGetUsernamesSuspenseQuery
>;
export type GetUsernamesQueryResult = Apollo.QueryResult<
  GetUsernamesQuery,
  GetUsernamesQueryVariables
>;
export const GetUserRelationshipsMatchingDocument = gql`
  query getUserRelationshipsMatching(
    $userId: Int!
    $matchString: String!
    $limit: Int = null
    $after: String = null
  ) {
    getUserRelationshipsMatching(
      userId: $userId
      matchString: $matchString
      limit: $limit
      after: $after
    ) {
      relationships {
        toUser {
          username
          id
        }
        toUserFollows
        toUserIsFollowedBy
      }
    }
  }
`;

/**
 * __useGetUserRelationshipsMatchingQuery__
 *
 * To run a query within a React component, call `useGetUserRelationshipsMatchingQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserRelationshipsMatchingQuery` 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 } = useGetUserRelationshipsMatchingQuery({
 *   variables: {
 *      userId: // value for 'userId'
 *      matchString: // value for 'matchString'
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *   },
 * });
 */
export function useGetUserRelationshipsMatchingQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >(GetUserRelationshipsMatchingDocument, options);
}
export function useGetUserRelationshipsMatchingLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >(GetUserRelationshipsMatchingDocument, options);
}
export function useGetUserRelationshipsMatchingSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUserRelationshipsMatchingQuery,
    GetUserRelationshipsMatchingQueryVariables
  >(GetUserRelationshipsMatchingDocument, options);
}
export type GetUserRelationshipsMatchingQueryHookResult = ReturnType<
  typeof useGetUserRelationshipsMatchingQuery
>;
export type GetUserRelationshipsMatchingLazyQueryHookResult = ReturnType<
  typeof useGetUserRelationshipsMatchingLazyQuery
>;
export type GetUserRelationshipsMatchingSuspenseQueryHookResult = ReturnType<
  typeof useGetUserRelationshipsMatchingSuspenseQuery
>;
export type GetUserRelationshipsMatchingQueryResult = Apollo.QueryResult<
  GetUserRelationshipsMatchingQuery,
  GetUserRelationshipsMatchingQueryVariables
>;
export const GetUserTagsDocument = gql`
  query GetUserTags {
    getUserTags {
      id
      name
    }
  }
`;

/**
 * __useGetUserTagsQuery__
 *
 * To run a query within a React component, call `useGetUserTagsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserTagsQuery` 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 } = useGetUserTagsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetUserTagsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUserTagsQuery,
    GetUserTagsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUserTagsQuery, GetUserTagsQueryVariables>(
    GetUserTagsDocument,
    options,
  );
}
export function useGetUserTagsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUserTagsQuery,
    GetUserTagsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetUserTagsQuery, GetUserTagsQueryVariables>(
    GetUserTagsDocument,
    options,
  );
}
export function useGetUserTagsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUserTagsQuery,
    GetUserTagsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetUserTagsQuery, GetUserTagsQueryVariables>(
    GetUserTagsDocument,
    options,
  );
}
export type GetUserTagsQueryHookResult = ReturnType<typeof useGetUserTagsQuery>;
export type GetUserTagsLazyQueryHookResult = ReturnType<
  typeof useGetUserTagsLazyQuery
>;
export type GetUserTagsSuspenseQueryHookResult = ReturnType<
  typeof useGetUserTagsSuspenseQuery
>;
export type GetUserTagsQueryResult = Apollo.QueryResult<
  GetUserTagsQuery,
  GetUserTagsQueryVariables
>;
export const FollowUserDocument = gql`
  mutation followUser($followedUserId: Int!) {
    followUser(followedUserId: $followedUserId) {
      username
      id
      following {
        id
        username
      }
      followers {
        id
        username
      }
    }
  }
`;
export type FollowUserMutationFn = Apollo.MutationFunction<
  FollowUserMutation,
  FollowUserMutationVariables
>;

/**
 * __useFollowUserMutation__
 *
 * To run a mutation, you first call `useFollowUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useFollowUserMutation` 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 [followUserMutation, { data, loading, error }] = useFollowUserMutation({
 *   variables: {
 *      followedUserId: // value for 'followedUserId'
 *   },
 * });
 */
export function useFollowUserMutation(
  baseOptions?: Apollo.MutationHookOptions<
    FollowUserMutation,
    FollowUserMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<FollowUserMutation, FollowUserMutationVariables>(
    FollowUserDocument,
    options,
  );
}
export type FollowUserMutationHookResult = ReturnType<
  typeof useFollowUserMutation
>;
export type FollowUserMutationResult =
  Apollo.MutationResult<FollowUserMutation>;
export type FollowUserMutationOptions = Apollo.BaseMutationOptions<
  FollowUserMutation,
  FollowUserMutationVariables
>;
export const UnfollowUserDocument = gql`
  mutation unfollowUser($followedUserId: Int!) {
    unfollowUser(followedUserId: $followedUserId) {
      username
      id
      following {
        id
        username
      }
      followers {
        id
        username
      }
    }
  }
`;
export type UnfollowUserMutationFn = Apollo.MutationFunction<
  UnfollowUserMutation,
  UnfollowUserMutationVariables
>;

/**
 * __useUnfollowUserMutation__
 *
 * To run a mutation, you first call `useUnfollowUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUnfollowUserMutation` 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 [unfollowUserMutation, { data, loading, error }] = useUnfollowUserMutation({
 *   variables: {
 *      followedUserId: // value for 'followedUserId'
 *   },
 * });
 */
export function useUnfollowUserMutation(
  baseOptions?: Apollo.MutationHookOptions<
    UnfollowUserMutation,
    UnfollowUserMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    UnfollowUserMutation,
    UnfollowUserMutationVariables
  >(UnfollowUserDocument, options);
}
export type UnfollowUserMutationHookResult = ReturnType<
  typeof useUnfollowUserMutation
>;
export type UnfollowUserMutationResult =
  Apollo.MutationResult<UnfollowUserMutation>;
export type UnfollowUserMutationOptions = Apollo.BaseMutationOptions<
  UnfollowUserMutation,
  UnfollowUserMutationVariables
>;
export const GetUserFollowingFollowersDocument = gql`
  query getUserFollowingFollowers {
    getLoggedInUser {
      id
      following {
        id
        username
      }
      followers {
        id
        username
      }
    }
  }
`;

/**
 * __useGetUserFollowingFollowersQuery__
 *
 * To run a query within a React component, call `useGetUserFollowingFollowersQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserFollowingFollowersQuery` 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 } = useGetUserFollowingFollowersQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetUserFollowingFollowersQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >(GetUserFollowingFollowersDocument, options);
}
export function useGetUserFollowingFollowersLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >(GetUserFollowingFollowersDocument, options);
}
export function useGetUserFollowingFollowersSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUserFollowingFollowersQuery,
    GetUserFollowingFollowersQueryVariables
  >(GetUserFollowingFollowersDocument, options);
}
export type GetUserFollowingFollowersQueryHookResult = ReturnType<
  typeof useGetUserFollowingFollowersQuery
>;
export type GetUserFollowingFollowersLazyQueryHookResult = ReturnType<
  typeof useGetUserFollowingFollowersLazyQuery
>;
export type GetUserFollowingFollowersSuspenseQueryHookResult = ReturnType<
  typeof useGetUserFollowingFollowersSuspenseQuery
>;
export type GetUserFollowingFollowersQueryResult = Apollo.QueryResult<
  GetUserFollowingFollowersQuery,
  GetUserFollowingFollowersQueryVariables
>;
export const DoesUsernameExistDocument = gql`
  query doesUsernameExist($candidateUsername: String!) {
    doesUsernameExist(candidateUsername: $candidateUsername)
  }
`;

/**
 * __useDoesUsernameExistQuery__
 *
 * To run a query within a React component, call `useDoesUsernameExistQuery` and pass it any options that fit your needs.
 * When your component renders, `useDoesUsernameExistQuery` 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 } = useDoesUsernameExistQuery({
 *   variables: {
 *      candidateUsername: // value for 'candidateUsername'
 *   },
 * });
 */
export function useDoesUsernameExistQuery(
  baseOptions: Apollo.QueryHookOptions<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >(DoesUsernameExistDocument, options);
}
export function useDoesUsernameExistLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >(DoesUsernameExistDocument, options);
}
export function useDoesUsernameExistSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    DoesUsernameExistQuery,
    DoesUsernameExistQueryVariables
  >(DoesUsernameExistDocument, options);
}
export type DoesUsernameExistQueryHookResult = ReturnType<
  typeof useDoesUsernameExistQuery
>;
export type DoesUsernameExistLazyQueryHookResult = ReturnType<
  typeof useDoesUsernameExistLazyQuery
>;
export type DoesUsernameExistSuspenseQueryHookResult = ReturnType<
  typeof useDoesUsernameExistSuspenseQuery
>;
export type DoesUsernameExistQueryResult = Apollo.QueryResult<
  DoesUsernameExistQuery,
  DoesUsernameExistQueryVariables
>;
export const EditUserDocument = gql`
  mutation editUser(
    $username: String
    $fargoRating: Int
    $videosPrivateByDefault: Boolean
  ) {
    editUser(
      input: {
        username: $username
        fargoRating: $fargoRating
        videosPrivateByDefault: $videosPrivateByDefault
      }
    ) {
      id
      firebaseUid
      username
      fargoRating
      updatedAt
      videosPrivateByDefault
    }
  }
`;
export type EditUserMutationFn = Apollo.MutationFunction<
  EditUserMutation,
  EditUserMutationVariables
>;

/**
 * __useEditUserMutation__
 *
 * To run a mutation, you first call `useEditUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditUserMutation` 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 [editUserMutation, { data, loading, error }] = useEditUserMutation({
 *   variables: {
 *      username: // value for 'username'
 *      fargoRating: // value for 'fargoRating'
 *      videosPrivateByDefault: // value for 'videosPrivateByDefault'
 *   },
 * });
 */
export function useEditUserMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EditUserMutation,
    EditUserMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<EditUserMutation, EditUserMutationVariables>(
    EditUserDocument,
    options,
  );
}
export type EditUserMutationHookResult = ReturnType<typeof useEditUserMutation>;
export type EditUserMutationResult = Apollo.MutationResult<EditUserMutation>;
export type EditUserMutationOptions = Apollo.BaseMutationOptions<
  EditUserMutation,
  EditUserMutationVariables
>;
export const GetStreamMonitoringDetailsDocument = gql`
  query GetStreamMonitoringDetails($videoId: Int!, $debuggingJson: JSON) {
    getVideo(videoId: $videoId, debuggingJson: $debuggingJson) {
      id
      totalShots
      makePercentage
      elapsedTime
      currentHomography {
        ...HomographyInfo
      }
      stream {
        id
        linksRequested
        uploadsCompleted
        segmentProcessingCursor
        isCompleted
        uploadCompletionCursor
        lastIntendedSegmentBound
        initPlaylistUploadStatus
      }
      currentProcessing {
        errors {
          message
          startSegmentIndex
          endSegmentIndex
        }
      }
    }
  }
  ${HomographyInfoFragmentDoc}
`;

/**
 * __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'
 *      debuggingJson: // value for 'debuggingJson'
 *   },
 * });
 */
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
      tableSize
      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
      tableSize
      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) {
      ...VideoStreamMetadata
    }
  }
  ${VideoStreamMetadataFragmentDoc}
`;

/**
 * __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 GetVideoForShotTimeDocument = gql`
  query GetVideoForShotTime($videoId: Int!) {
    getVideo(videoId: $videoId) {
      ...VideoStreamMetadata
    }
  }
  ${VideoStreamMetadataFragmentDoc}
`;

/**
 * __useGetVideoForShotTimeQuery__
 *
 * To run a query within a React component, call `useGetVideoForShotTimeQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoForShotTimeQuery` 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 } = useGetVideoForShotTimeQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoForShotTimeQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >(GetVideoForShotTimeDocument, options);
}
export function useGetVideoForShotTimeLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >(GetVideoForShotTimeDocument, options);
}
export function useGetVideoForShotTimeSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoForShotTimeQuery,
    GetVideoForShotTimeQueryVariables
  >(GetVideoForShotTimeDocument, options);
}
export type GetVideoForShotTimeQueryHookResult = ReturnType<
  typeof useGetVideoForShotTimeQuery
>;
export type GetVideoForShotTimeLazyQueryHookResult = ReturnType<
  typeof useGetVideoForShotTimeLazyQuery
>;
export type GetVideoForShotTimeSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoForShotTimeSuspenseQuery
>;
export type GetVideoForShotTimeQueryResult = Apollo.QueryResult<
  GetVideoForShotTimeQuery,
  GetVideoForShotTimeQueryVariables
>;
export const GetVideoDocument = gql`
  query GetVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      playlist {
        segmentDurations
      }
      homographyHistory {
        ...HomographyInfo
      }
      stream {
        id
        streamSegmentType
        segments {
          segmentIndex
          endFrameIndex
          framesPerSecond
        }
        resolution {
          width
          height
        }
      }
    }
  }
  ${HomographyInfoFragmentDoc}
`;

/**
 * __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) {
      id
      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) {
      id
      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) {
      id
      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 GetVideoForClipTimesDocument = gql`
  query GetVideoForClipTimes($videoId: Int!) {
    getVideo(videoId: $videoId) {
      ...VideoDurationData
    }
  }
  ${VideoDurationDataFragmentDoc}
`;

/**
 * __useGetVideoForClipTimesQuery__
 *
 * To run a query within a React component, call `useGetVideoForClipTimesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoForClipTimesQuery` 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 } = useGetVideoForClipTimesQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoForClipTimesQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >(GetVideoForClipTimesDocument, options);
}
export function useGetVideoForClipTimesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >(GetVideoForClipTimesDocument, options);
}
export function useGetVideoForClipTimesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoForClipTimesQuery,
    GetVideoForClipTimesQueryVariables
  >(GetVideoForClipTimesDocument, options);
}
export type GetVideoForClipTimesQueryHookResult = ReturnType<
  typeof useGetVideoForClipTimesQuery
>;
export type GetVideoForClipTimesLazyQueryHookResult = ReturnType<
  typeof useGetVideoForClipTimesLazyQuery
>;
export type GetVideoForClipTimesSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoForClipTimesSuspenseQuery
>;
export type GetVideoForClipTimesQueryResult = Apollo.QueryResult<
  GetVideoForClipTimesQuery,
  GetVideoForClipTimesQueryVariables
>;
export const GetHeaderInfoByVideoIdDocument = gql`
  query GetHeaderInfoByVideoId($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      name
      startTime
    }
  }
`;

/**
 * __useGetHeaderInfoByVideoIdQuery__
 *
 * To run a query within a React component, call `useGetHeaderInfoByVideoIdQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetHeaderInfoByVideoIdQuery` 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 } = useGetHeaderInfoByVideoIdQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetHeaderInfoByVideoIdQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >(GetHeaderInfoByVideoIdDocument, options);
}
export function useGetHeaderInfoByVideoIdLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >(GetHeaderInfoByVideoIdDocument, options);
}
export function useGetHeaderInfoByVideoIdSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetHeaderInfoByVideoIdQuery,
    GetHeaderInfoByVideoIdQueryVariables
  >(GetHeaderInfoByVideoIdDocument, options);
}
export type GetHeaderInfoByVideoIdQueryHookResult = ReturnType<
  typeof useGetHeaderInfoByVideoIdQuery
>;
export type GetHeaderInfoByVideoIdLazyQueryHookResult = ReturnType<
  typeof useGetHeaderInfoByVideoIdLazyQuery
>;
export type GetHeaderInfoByVideoIdSuspenseQueryHookResult = ReturnType<
  typeof useGetHeaderInfoByVideoIdSuspenseQuery
>;
export type GetHeaderInfoByVideoIdQueryResult = Apollo.QueryResult<
  GetHeaderInfoByVideoIdQuery,
  GetHeaderInfoByVideoIdQueryVariables
>;
export const FindPrerecordTableLayoutDocument = gql`
  mutation FindPrerecordTableLayout($b64Image: String!, $videoId: Int!) {
    findPrerecordTableLayout(b64Image: $b64Image, videoId: $videoId) {
      ...HomographyInfo
    }
  }
  ${HomographyInfoFragmentDoc}
`;
export type FindPrerecordTableLayoutMutationFn = Apollo.MutationFunction<
  FindPrerecordTableLayoutMutation,
  FindPrerecordTableLayoutMutationVariables
>;

/**
 * __useFindPrerecordTableLayoutMutation__
 *
 * To run a mutation, you first call `useFindPrerecordTableLayoutMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useFindPrerecordTableLayoutMutation` 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 [findPrerecordTableLayoutMutation, { data, loading, error }] = useFindPrerecordTableLayoutMutation({
 *   variables: {
 *      b64Image: // value for 'b64Image'
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useFindPrerecordTableLayoutMutation(
  baseOptions?: Apollo.MutationHookOptions<
    FindPrerecordTableLayoutMutation,
    FindPrerecordTableLayoutMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    FindPrerecordTableLayoutMutation,
    FindPrerecordTableLayoutMutationVariables
  >(FindPrerecordTableLayoutDocument, options);
}
export type FindPrerecordTableLayoutMutationHookResult = ReturnType<
  typeof useFindPrerecordTableLayoutMutation
>;
export type FindPrerecordTableLayoutMutationResult =
  Apollo.MutationResult<FindPrerecordTableLayoutMutation>;
export type FindPrerecordTableLayoutMutationOptions =
  Apollo.BaseMutationOptions<
    FindPrerecordTableLayoutMutation,
    FindPrerecordTableLayoutMutationVariables
  >;
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) {
      value {
        ... on UploadLink {
          uploadUrl
          headers {
            key
            value
          }
        }
        ... on GetUploadLinkErrors {
          error {
            ... on MustHaveSetForUploadLinkErr {
              resolution
              framesPerSecond
            }
            ... on SegmentAlreadyUploadedErr {
              segmentId
            }
            ... on ProcessingFailedErr {
              processing {
                status
                errors {
                  message
                }
              }
            }
          }
        }
      }
      stream {
        uploadCompletionCursor
      }
    }
  }
`;
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 GetHlsInitUploadLinkDocument = gql`
  mutation GetHlsInitUploadLink($videoId: Int!) {
    getHlsInitUploadLink(videoId: $videoId) {
      value {
        ... on UploadLink {
          uploadUrl
          headers {
            key
            value
          }
        }
        ... on GetUploadLinkErrors {
          error {
            ... on NoInitForChunkedUploadErr {
              segmentType
            }
            ... on InitUploadAlreadyCompletedErr {
              segmentType
            }
            ... on TooManyInitUploadsErr {
              linksRequested
            }
          }
        }
      }
    }
  }
`;
export type GetHlsInitUploadLinkMutationFn = Apollo.MutationFunction<
  GetHlsInitUploadLinkMutation,
  GetHlsInitUploadLinkMutationVariables
>;

/**
 * __useGetHlsInitUploadLinkMutation__
 *
 * To run a mutation, you first call `useGetHlsInitUploadLinkMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useGetHlsInitUploadLinkMutation` 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 [getHlsInitUploadLinkMutation, { data, loading, error }] = useGetHlsInitUploadLinkMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetHlsInitUploadLinkMutation(
  baseOptions?: Apollo.MutationHookOptions<
    GetHlsInitUploadLinkMutation,
    GetHlsInitUploadLinkMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    GetHlsInitUploadLinkMutation,
    GetHlsInitUploadLinkMutationVariables
  >(GetHlsInitUploadLinkDocument, options);
}
export type GetHlsInitUploadLinkMutationHookResult = ReturnType<
  typeof useGetHlsInitUploadLinkMutation
>;
export type GetHlsInitUploadLinkMutationResult =
  Apollo.MutationResult<GetHlsInitUploadLinkMutation>;
export type GetHlsInitUploadLinkMutationOptions = Apollo.BaseMutationOptions<
  GetHlsInitUploadLinkMutation,
  GetHlsInitUploadLinkMutationVariables
>;
export const SetSegmentDurationDocument = gql`
  mutation SetSegmentDuration(
    $videoId: Int!
    $segmentIndex: Int!
    $duration: Float!
  ) {
    setSegmentDuration(
      videoId: $videoId
      segmentIndex: $segmentIndex
      duration: $duration
    )
  }
`;
export type SetSegmentDurationMutationFn = Apollo.MutationFunction<
  SetSegmentDurationMutation,
  SetSegmentDurationMutationVariables
>;

/**
 * __useSetSegmentDurationMutation__
 *
 * To run a mutation, you first call `useSetSegmentDurationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetSegmentDurationMutation` 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 [setSegmentDurationMutation, { data, loading, error }] = useSetSegmentDurationMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      segmentIndex: // value for 'segmentIndex'
 *      duration: // value for 'duration'
 *   },
 * });
 */
export function useSetSegmentDurationMutation(
  baseOptions?: Apollo.MutationHookOptions<
    SetSegmentDurationMutation,
    SetSegmentDurationMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    SetSegmentDurationMutation,
    SetSegmentDurationMutationVariables
  >(SetSegmentDurationDocument, options);
}
export type SetSegmentDurationMutationHookResult = ReturnType<
  typeof useSetSegmentDurationMutation
>;
export type SetSegmentDurationMutationResult =
  Apollo.MutationResult<SetSegmentDurationMutation>;
export type SetSegmentDurationMutationOptions = Apollo.BaseMutationOptions<
  SetSegmentDurationMutation,
  SetSegmentDurationMutationVariables
>;
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
          uploadsCompleted
        }
      }
      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
>;