railbird-gql/src/index.tsx

import * as Apollo from "@apollo/client";
import { gql } from "@apollo/client";
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = {
  [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
  [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<
  T extends { [key: string]: unknown },
  K extends keyof T,
> = { [_ in K]?: never };
export type Incremental<T> =
  | T
  | {
      [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
    };
const defaultOptions = {} as const;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string };
  String: { input: string; output: string };
  Boolean: { input: boolean; output: boolean };
  Int: { input: number; output: number };
  Float: { input: number; output: number };
  /** Integer value that can exceed GraphQL Int's 32-bit range. */
  BigInt: { input: any; output: any };
  /** 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 AppleIapSubscriptionOptionsGql = {
  __typename?: "AppleIapSubscriptionOptionsGQL";
  enabled: Scalars["Boolean"]["output"];
  proMonthlyProductId?: Maybe<Scalars["String"]["output"]>;
  productIds: Array<Scalars["String"]["output"]>;
};

export type BallTrajectoryGql = {
  __typename?: "BallTrajectoryGQL";
  ballId: Scalars["Int"]["output"];
  points: Array<TrajectoryPointGql>;
};

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

export type BannerGql = {
  __typename?: "BannerGQL";
  color: Scalars["String"]["output"];
  dismissible: Scalars["Boolean"]["output"];
  id: Scalars["Int"]["output"];
  kind: BannerKindEnum;
  message: Scalars["String"]["output"];
  priority: Scalars["Int"]["output"];
};

export enum BannerKindEnum {
  Error = "ERROR",
  Info = "INFO",
  Warning = "WARNING",
}

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

export type BoundingBoxInputGql = {
  height: Scalars["Float"]["input"];
  left: Scalars["Float"]["input"];
  top: Scalars["Float"]["input"];
  width: Scalars["Float"]["input"];
};

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 CameraClaimSession = {
  __typename?: "CameraClaimSession";
  agreedTermsVersion?: Maybe<Scalars["Int"]["output"]>;
  camera: PoolHallCamera;
  cameraId: Scalars["ID"]["output"];
  challengeCode: Scalars["String"]["output"];
  createdAt: Scalars["DateTime"]["output"];
  detectedAt?: Maybe<Scalars["DateTime"]["output"]>;
  expiresAt: Scalars["DateTime"]["output"];
  failedAt?: Maybe<Scalars["DateTime"]["output"]>;
  failureReason?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["ID"]["output"];
  status: Scalars["String"]["output"];
  updatedAt: Scalars["DateTime"]["output"];
  userId: Scalars["ID"]["output"];
};

export type CameraLease = {
  __typename?: "CameraLease";
  camera: PoolHallCamera;
  cameraId: Scalars["ID"]["output"];
  claimSessionId?: Maybe<Scalars["ID"]["output"]>;
  createdAt: Scalars["DateTime"]["output"];
  endReason?: Maybe<Scalars["String"]["output"]>;
  endedAt?: Maybe<Scalars["DateTime"]["output"]>;
  expiresAt?: Maybe<Scalars["DateTime"]["output"]>;
  id: Scalars["ID"]["output"];
  startedAt: Scalars["DateTime"]["output"];
  status: Scalars["String"]["output"];
  updatedAt: Scalars["DateTime"]["output"];
  userId: Scalars["ID"]["output"];
  videoId?: Maybe<Scalars["ID"]["output"]>;
};

export type CancellationFeedbackMetadataInput = {
  appVersion?: InputMaybe<Scalars["String"]["input"]>;
  gitRevision?: InputMaybe<Scalars["String"]["input"]>;
  platform?: InputMaybe<Scalars["String"]["input"]>;
};

export enum CancellationReasonEnum {
  DataNotAccurate = "DATA_NOT_ACCURATE",
  DontPlayEnough = "DONT_PLAY_ENOUGH",
  MissingFeatures = "MISSING_FEATURES",
  Other = "OTHER",
  TechnicalIssues = "TECHNICAL_ISSUES",
  TooExpensive = "TOO_EXPENSIVE",
}

export type Challenge = {
  __typename?: "Challenge";
  createdAt: Scalars["DateTime"]["output"];
  createdBy: UserGql;
  description?: Maybe<Scalars["String"]["output"]>;
  endDate: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  invitations: Array<ChallengeInvitation>;
  isPublic: Scalars["Boolean"]["output"];
  maxAttempts?: Maybe<Scalars["Int"]["output"]>;
  minimumShots: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
  participantCount: Scalars["Int"]["output"];
  requiredPocketSize?: Maybe<Scalars["Float"]["output"]>;
  requiredTableSize?: Maybe<Scalars["Float"]["output"]>;
  ruleSet: RuleSet;
  startDate: Scalars["DateTime"]["output"];
  updatedAt: Scalars["DateTime"]["output"];
};

export type ChallengeEntry = {
  __typename?: "ChallengeEntry";
  attemptCount?: Maybe<Scalars["Int"]["output"]>;
  challenge: Challenge;
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  makeRate?: Maybe<Scalars["Float"]["output"]>;
  makesCount?: Maybe<Scalars["Int"]["output"]>;
  qualified?: Maybe<Scalars["Boolean"]["output"]>;
  shotsCount?: Maybe<Scalars["Int"]["output"]>;
  status: Scalars["String"]["output"];
  user: UserGql;
  video?: Maybe<VideoGql>;
};

export type ChallengeInvitation = {
  __typename?: "ChallengeInvitation";
  challenge: Challenge;
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  invitee: UserGql;
  inviter: UserGql;
  status: Scalars["String"]["output"];
};

export enum ClientUploadStatusEnum {
  UploadDisabled = "UPLOAD_DISABLED",
  UploadEnabled = "UPLOAD_ENABLED",
}

export type ClusterAssignmentInput = {
  clusterId: Scalars["Int"]["input"];
  score?: InputMaybe<Scalars["Int"]["input"]>;
  userId?: InputMaybe<Scalars["Int"]["input"]>;
};

export type CohortStatsGql = {
  __typename?: "CohortStatsGQL";
  activated7d: Scalars["Int"]["output"];
  activatedNotPaid7d: Scalars["Int"]["output"];
  paid7d: Scalars["Int"]["output"];
  paidTotal: Scalars["Int"]["output"];
  signups: Scalars["Int"]["output"];
  weekStart: Scalars["Date"]["output"];
};

export type CommentGql = {
  __typename?: "CommentGQL";
  id: Scalars["Int"]["output"];
  message: Scalars["String"]["output"];
  replies: Array<CommentGql>;
  replyToCommentId?: Maybe<Scalars["Int"]["output"]>;
  user: UserGql;
};

export type CountLeaderboardGql = {
  __typename?: "CountLeaderboardGQL";
  entries: Array<UserShotCountEntry>;
};

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

export type CreateCustomerPortalSessionResultGql = {
  __typename?: "CreateCustomerPortalSessionResultGQL";
  portalUrl: Scalars["String"]["output"];
};

export type CreatePoolHallCameraInput = {
  allowsPrivateVideos?: InputMaybe<Scalars["Boolean"]["input"]>;
  claimTermsText?: InputMaybe<Scalars["String"]["input"]>;
  name: Scalars["String"]["input"];
  pocketSize?: InputMaybe<Scalars["Float"]["input"]>;
  poolHallId: Scalars["ID"]["input"];
  streamPath?: InputMaybe<Scalars["String"]["input"]>;
  tableLabel?: InputMaybe<Scalars["String"]["input"]>;
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
};

export type CreatePoolHallInput = {
  address?: InputMaybe<Scalars["String"]["input"]>;
  city?: InputMaybe<Scalars["String"]["input"]>;
  latitude?: InputMaybe<Scalars["Float"]["input"]>;
  longitude?: InputMaybe<Scalars["Float"]["input"]>;
  name: Scalars["String"]["input"];
  state?: InputMaybe<Scalars["String"]["input"]>;
  timezone?: InputMaybe<Scalars["String"]["input"]>;
};

export type CreateShotShareLinkInput = {
  paddingSeconds?: InputMaybe<Scalars["Float"]["input"]>;
  shotIds: Array<Scalars["Int"]["input"]>;
};

export type CreateSubscriptionResultGql = {
  __typename?: "CreateSubscriptionResultGQL";
  checkoutUrl: Scalars["String"]["output"];
  sessionId: Scalars["String"]["output"];
};

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 CueStrikeInputGql = {
  a?: Scalars["Float"]["input"];
  b?: Scalars["Float"]["input"];
  phi: Scalars["Float"]["input"];
  theta?: Scalars["Float"]["input"];
  v0: Scalars["Float"]["input"];
};

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 DatetimeOrdering = {
  descending?: Scalars["Boolean"]["input"];
  startingAt?: InputMaybe<Scalars["DateTime"]["input"]>;
};

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

export type DeployedConfigGql = {
  __typename?: "DeployedConfigGQL";
  allowNewUsers: Scalars["Boolean"]["output"];
  bannerMessages: Array<BannerGql>;
  bucketUrl: Scalars["String"]["output"];
  capabilityEnforcementEnabled: Scalars["Boolean"]["output"];
  defaultAndroidRecordingFormat: StreamSegmentTypeEnum;
  devMode: Scalars["Boolean"]["output"];
  environment: Scalars["String"]["output"];
  firebase: Scalars["Boolean"]["output"];
  minimumAllowedAppVersion: Scalars["String"]["output"];
  quotaEnforcementEnabled: Scalars["Boolean"]["output"];
  storageLimitEnforcementEnabled: Scalars["Boolean"]["output"];
  subscriptionGatingEnabled: Scalars["Boolean"]["output"];
};

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

export type DoesNotOwnShotErrOtherErrorNeedsNote =
  | DoesNotOwnShotErr
  | OtherErrorNeedsNote;

export type DrillRunLeaderboardGql = {
  __typename?: "DrillRunLeaderboardGQL";
  entries: Array<RunGql>;
  totalPlayers: Scalars["Int"]["output"];
  youRank?: Maybe<Scalars["Int"]["output"]>;
  youRun?: Maybe<RunGql>;
};

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

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

export type EditableShotFieldInputGql = {
  backcut?: InputMaybe<Scalars["Boolean"]["input"]>;
  excludeFromStats?: InputMaybe<Scalars["Boolean"]["input"]>;
  intendedPocketType?: InputMaybe<PocketEnum>;
  make?: InputMaybe<Scalars["Boolean"]["input"]>;
  notes?: InputMaybe<Scalars["String"]["input"]>;
  shotDirection?: InputMaybe<ShotDirectionEnum>;
  spinType?: InputMaybe<SpinTypeEnum>;
  targetPocketAngleDirection?: InputMaybe<ShotDirectionEnum>;
};

export enum EntitlementSourceTypeEnum {
  Admin = "ADMIN",
  AlphaLegacy = "ALPHA_LEGACY",
  Apple = "APPLE",
  Manual = "MANUAL",
  Stripe = "STRIPE",
}

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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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>;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic: Array<Scalars["Boolean"]["input"]>;
      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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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>;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId: Array<Scalars["Int"]["input"]>;
      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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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;
      isBreakHeuristic?: 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;
      runId?: 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 FinalizePlayerAssignmentsInput = {
  clusterAssignments?: Array<ClusterAssignmentInput>;
  shotMoves?: Array<ShotMoveInput>;
  videoId: Scalars["Int"]["input"];
};

export type FloatOrdering = {
  descending?: Scalars["Boolean"]["input"];
  startingAt?: InputMaybe<Scalars["Float"]["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 FunnelStatsGql = {
  __typename?: "FunnelStatsGQL";
  activationActivated: Scalars["Int"]["output"];
  activationCohort: Scalars["Int"]["output"];
  eraPaying: Scalars["Int"]["output"];
  eraSignups: Scalars["Int"]["output"];
  freemiumEpoch: Scalars["Date"]["output"];
  newPaid7d: Scalars["Int"]["output"];
  newPaid30d: Scalars["Int"]["output"];
  newPaidToday: Scalars["Int"]["output"];
  pastDueUsers: Scalars["Int"]["output"];
  payingUsers: Scalars["Int"]["output"];
  retentionPrevActive: Scalars["Int"]["output"];
  retentionReturned: Scalars["Int"]["output"];
};

export type GameTypeTagMetric = {
  __typename?: "GameTypeTagMetric";
  madeShots: Scalars["Int"]["output"];
  makeRate: Scalars["Float"]["output"];
  shotCount: Scalars["Int"]["output"];
  tableSize?: Maybe<Scalars["Float"]["output"]>;
  tagLabel: Scalars["String"]["output"];
  tagName: Scalars["String"]["output"];
};

export type GameTypeTagMetricsInput = {
  createdAt?: InputMaybe<DateRangeFilter>;
  groupByTableSize?: Scalars["Boolean"]["input"];
  includePrivate?: IncludePrivateEnum;
  includeUnknown?: Scalars["Boolean"]["input"];
  maxTags?: InputMaybe<Scalars["Int"]["input"]>;
  tagClass?: InputMaybe<Scalars["String"]["input"]>;
  userId: Scalars["Int"]["input"];
};

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

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

export type GetRunsOrdering = {
  orderings: Array<RunsOrderingComponent>;
};

export type GetRunsResult = {
  __typename?: "GetRunsResult";
  count?: Maybe<Scalars["Int"]["output"]>;
  runIds: Array<Scalars["Int"]["output"]>;
  runs: Array<RunGql>;
};

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

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

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

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 enum HomographyBackendGql {
  Classic = "CLASSIC",
  Tablenet = "TABLENET",
}

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

export type HomographyInputGql = {
  crop: BoundingBoxInputGql;
  destPoints: PocketPointsInputGql;
  pockets: Array<BoundingBoxInputGql>;
  sourcePoints: PocketPointsInputGql;
};

export enum IncludePrivateEnum {
  All = "ALL",
  Mine = "MINE",
  None = "NONE",
}

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

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

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

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

export type IntPoint2DInput = {
  x: Scalars["Int"]["input"];
  y: Scalars["Int"]["input"];
};

export type LiveTableStateGql = {
  __typename?: "LiveTableStateGQL";
  frameIndex: Scalars["Int"]["output"];
  tableState: TableStateGql;
  videoId: Scalars["Int"]["output"];
};

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

export type MedalGql = {
  __typename?: "MedalGQL";
  count: Scalars["Int"]["output"];
  nickname?: Maybe<Scalars["String"]["output"]>;
};

export type MedalScope =
  | {
      datetimeRange: DatetimeRangeAggregationInput;
      interval?: never;
      videoId?: never;
    } /** @deprecated NO LONGER SUPPORTED, USE DATETIME_RANGE */
  | { datetimeRange?: never; interval: TimeInterval; videoId?: never }
  | {
      datetimeRange?: never;
      interval?: never;
      videoId: Scalars["Int"]["input"];
    };

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

export type MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErrStorageLimitExceededErr =

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

export type Mutation = {
  __typename?: "Mutation";
  addAnnotationToShot: AddShotAnnotationReturn;
  blockContent: Scalars["Boolean"]["output"];
  blockUser: Scalars["Boolean"]["output"];
  cancelCameraClaimSession: CameraClaimSession;
  cancelSubscription: UserSubscriptionStatusGql;
  commentOnVideo: Scalars["Boolean"]["output"];
  createBucketSet: BucketSetGql;
  createCameraClaimSession: CameraClaimSession;
  createChallenge: Challenge;
  createCustomerPortalSession: CreateCustomerPortalSessionResultGql;
  createPoolHall: PoolHall;
  createPoolHallCamera: PoolHallCameraStreamCredentials;
  createRuleSet: RuleSet;
  createShotShareLink: ShareLinkGql;
  createSubscription: CreateSubscriptionResultGql;
  createUploadStream: CreateUploadStreamReturn;
  deleteComment: Scalars["Boolean"]["output"];
  deleteNotification: Scalars["Boolean"]["output"];
  deleteTags: Scalars["Boolean"]["output"];
  deleteUser: Scalars["Boolean"]["output"];
  deleteVideo: Scalars["Boolean"]["output"];
  dismissChallenge: Scalars["Boolean"]["output"];
  dismissVideoExport: Scalars["Boolean"]["output"];
  editComment: Scalars["Boolean"]["output"];
  editProfileImageUri: UserGql;
  editShot: EditShotReturn;
  editUploadStream: Scalars["Boolean"]["output"];
  editUser: UserGql;
  endCameraLease: CameraLease;
  ensureStripeCustomerExists: UserGql;
  extendCameraLease: CameraLease;
  finalizePlayerAssignments: Array<PlayerClusterGql>;
  findPrerecordTableLayout?: Maybe<HomographyInfoGql>;
  followUser: UserGql;
  getHlsInitUploadLink: GetUploadLinkReturn;
  getProfileImageUploadLink: GetProfileUploadLinkReturn;
  getUploadLink: GetUploadLinkReturn;
  getUploadLinks: GetUploadLinksReturn;
  grantManualEntitlement: UserSubscriptionStatusGql;
  inviteUsersToChallenge: Array<ChallengeInvitation>;
  markAllNotificationsAsRead: Scalars["Boolean"]["output"];
  markNotificationAsRead: Scalars["Boolean"]["output"];
  markNotificationsAsRead: Scalars["Boolean"]["output"];
  reactToVideo: Scalars["Boolean"]["output"];
  recalculateChallengeEntry: ChallengeEntry;
  reportContent: Scalars["Boolean"]["output"];
  requestSessionCoachGeneration: SessionCoachGql;
  requestVideoExport: VideoExportJobGql;
  respondToChallengeInvitation: ChallengeInvitation;
  retireTags: Scalars["Boolean"]["output"];
  revokeManualEntitlement: UserSubscriptionStatusGql;
  rotatePoolHallCameraStreamKey: PoolHallCameraStreamCredentials;
  setLoggerLevel: Scalars["Boolean"]["output"];
  setSegmentDuration: Scalars["Boolean"]["output"];
  startChallenge: ChallengeEntry;
  submitCancellationFeedback: Scalars["Boolean"]["output"];
  submitChallengeEntry: ChallengeEntry;
  syncAppleSubscription: SyncAppleSubscriptionResultGql;
  undismissChallenge: Scalars["Boolean"]["output"];
  unfollowUser: UserGql;
  updatePoolHall: PoolHall;
  updatePoolHallCamera: PoolHallCamera;
  updateShotAnnotations: UpdateShotAnnotationReturn;
};

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

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

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

export type MutationCancelCameraClaimSessionArgs = {
  claimSessionId: Scalars["ID"]["input"];
};

export type MutationCommentOnVideoArgs = {
  message: Scalars["String"]["input"];
  parentCommentId?: InputMaybe<Scalars["Int"]["input"]>;
  videoId: Scalars["Int"]["input"];
};

export type MutationCreateBucketSetArgs = {
  params: CreateBucketSetInput;
};

export type MutationCreateCameraClaimSessionArgs = {
  agreedTermsVersion?: InputMaybe<Scalars["Int"]["input"]>;
  cameraId: Scalars["ID"]["input"];
  durationMinutes?: InputMaybe<Scalars["Int"]["input"]>;
  tags?: InputMaybe<Array<VideoTagInput>>;
  videoName?: InputMaybe<Scalars["String"]["input"]>;
  videoPrivate?: InputMaybe<Scalars["Boolean"]["input"]>;
};

export type MutationCreateChallengeArgs = {
  description?: InputMaybe<Scalars["String"]["input"]>;
  endDate: Scalars["DateTime"]["input"];
  isPublic?: Scalars["Boolean"]["input"];
  maxAttempts?: InputMaybe<Scalars["Int"]["input"]>;
  minimumShots: Scalars["Int"]["input"];
  name: Scalars["String"]["input"];
  requiredPocketSize?: InputMaybe<Scalars["Float"]["input"]>;
  requiredTableSize?: InputMaybe<Scalars["Float"]["input"]>;
  ruleSetId: Scalars["ID"]["input"];
  startDate: Scalars["DateTime"]["input"];
};

export type MutationCreatePoolHallArgs = {
  input: CreatePoolHallInput;
};

export type MutationCreatePoolHallCameraArgs = {
  input: CreatePoolHallCameraInput;
};

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

export type MutationCreateShotShareLinkArgs = {
  input: CreateShotShareLinkInput;
};

export type MutationCreateSubscriptionArgs = {
  priceId: Scalars["String"]["input"];
};

export type MutationCreateUploadStreamArgs = {
  expectedDurationSeconds?: InputMaybe<Scalars["Float"]["input"]>;
  videoMetadata: VideoMetadataInput;
};

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

export type MutationDeleteNotificationArgs = {
  notificationId: Scalars["Int"]["input"];
};

export type MutationDeleteTagsArgs = {
  tagsToDelete: Array<VideoTagInput>;
  videoId: Scalars["Int"]["input"];
};

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

export type MutationDismissChallengeArgs = {
  challengeId: Scalars["ID"]["input"];
};

export type MutationDismissVideoExportArgs = {
  jobId: Scalars["Int"]["input"];
};

export type MutationEditCommentArgs = {
  commentId: Scalars["Int"]["input"];
  newMessage: Scalars["String"]["input"];
  videoId: Scalars["Int"]["input"];
};

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

export type MutationEditShotArgs = {
  fieldsToEdit: EditableShotFieldInputGql;
  shotId: Scalars["Int"]["input"];
};

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

export type MutationEditUserArgs = {
  input: EditUserInputGql;
};

export type MutationEndCameraLeaseArgs = {
  leaseId: Scalars["ID"]["input"];
};

export type MutationExtendCameraLeaseArgs = {
  additionalMinutes?: Scalars["Int"]["input"];
  leaseId: Scalars["ID"]["input"];
};

export type MutationFinalizePlayerAssignmentsArgs = {
  input: FinalizePlayerAssignmentsInput;
};

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

export type MutationGrantManualEntitlementArgs = {
  endsAt?: InputMaybe<Scalars["DateTime"]["input"]>;
  reason?: InputMaybe<Scalars["String"]["input"]>;
  startsAt?: InputMaybe<Scalars["DateTime"]["input"]>;
  tierName?: Scalars["String"]["input"];
  userId: Scalars["Int"]["input"];
};

export type MutationInviteUsersToChallengeArgs = {
  challengeId: Scalars["ID"]["input"];
  userIds: Array<Scalars["ID"]["input"]>;
};

export type MutationMarkNotificationAsReadArgs = {
  notificationId: Scalars["Int"]["input"];
};

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

export type MutationReactToVideoArgs = {
  reaction?: InputMaybe<ReactionEnum>;
  videoId: Scalars["Int"]["input"];
};

export type MutationRecalculateChallengeEntryArgs = {
  entryId: Scalars["ID"]["input"];
};

export type MutationReportContentArgs = {
  customReason?: InputMaybe<Scalars["String"]["input"]>;
  reason: ReportReasonEnum;
  videoId: Scalars["Int"]["input"];
};

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

export type MutationRequestVideoExportArgs = {
  input: RequestVideoExportInput;
};

export type MutationRespondToChallengeInvitationArgs = {
  accept: Scalars["Boolean"]["input"];
  invitationId: Scalars["ID"]["input"];
};

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

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

export type MutationRotatePoolHallCameraStreamKeyArgs = {
  cameraId: Scalars["ID"]["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 MutationStartChallengeArgs = {
  challengeId: Scalars["ID"]["input"];
};

export type MutationSubmitCancellationFeedbackArgs = {
  feedback?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<CancellationFeedbackMetadataInput>;
  reasons?: InputMaybe<Array<CancellationReasonEnum>>;
};

export type MutationSubmitChallengeEntryArgs = {
  entryId: Scalars["ID"]["input"];
  videoId: Scalars["ID"]["input"];
};

export type MutationSyncAppleSubscriptionArgs = {
  input: SyncAppleSubscriptionInputGql;
};

export type MutationUndismissChallengeArgs = {
  challengeId: Scalars["ID"]["input"];
};

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

export type MutationUpdatePoolHallArgs = {
  input: UpdatePoolHallInput;
};

export type MutationUpdatePoolHallCameraArgs = {
  input: UpdatePoolHallCameraInput;
};

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

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

export type NotificationConnection = {
  __typename?: "NotificationConnection";
  hasMore: Scalars["Boolean"]["output"];
  notifications: Array<NotificationGql>;
  totalCount: Scalars["Int"]["output"];
  unreadCount: Scalars["Int"]["output"];
};

export type NotificationFilters = {
  isRead?: InputMaybe<Scalars["Boolean"]["input"]>;
  notificationTypes?: InputMaybe<Array<NotificationTypeEnum>>;
};

export type NotificationGql = {
  __typename?: "NotificationGQL";
  actor: UserGql;
  challenge?: Maybe<Challenge>;
  challengeId?: Maybe<Scalars["Int"]["output"]>;
  comment?: Maybe<CommentGql>;
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["Int"]["output"];
  isRead: Scalars["Boolean"]["output"];
  notificationType: NotificationTypeEnum;
  reactionType?: Maybe<Scalars["String"]["output"]>;
  readAt?: Maybe<Scalars["DateTime"]["output"]>;
  videoId?: Maybe<Scalars["Int"]["output"]>;
};

export enum NotificationTypeEnum {
  ChallengeInvite = "CHALLENGE_INVITE",
  Comment = "COMMENT",
  CommentReply = "COMMENT_REPLY",
  ExportReady = "EXPORT_READY",
  Follow = "FOLLOW",
  Reaction = "REACTION",
}

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 type PlayerClusterGql = {
  __typename?: "PlayerClusterGQL";
  clusterId: Scalars["Int"]["output"];
  confirmed: Scalars["Boolean"]["output"];
  nShots: Scalars["Int"]["output"];
  profileImageUri?: Maybe<Scalars["String"]["output"]>;
  score?: Maybe<Scalars["Int"]["output"]>;
  shots: Array<PlayerClusterShotGql>;
  userId?: Maybe<Scalars["Int"]["output"]>;
  username?: Maybe<Scalars["String"]["output"]>;
  videoId: Scalars["Int"]["output"];
};

export type PlayerClusterShotGql = {
  __typename?: "PlayerClusterShotGQL";
  bboxX1: Scalars["Int"]["output"];
  bboxX2: Scalars["Int"]["output"];
  bboxY1: Scalars["Int"]["output"];
  bboxY2: Scalars["Int"]["output"];
  confidence: Scalars["Float"]["output"];
  cropUrl?: Maybe<Scalars["String"]["output"]>;
  fullFrameUrl?: Maybe<Scalars["String"]["output"]>;
  isConfirmed: Scalars["Boolean"]["output"];
  shotId: Scalars["Int"]["output"];
};

export type PlayerSummaryGql = {
  __typename?: "PlayerSummaryGQL";
  averageDifficulty?: Maybe<Scalars["Float"]["output"]>;
  averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
  clusterId: Scalars["Int"]["output"];
  longestRun: Scalars["Int"]["output"];
  makePercentage: Scalars["Float"]["output"];
  profileImageUri?: Maybe<Scalars["String"]["output"]>;
  representativeFullFrameUrl?: Maybe<Scalars["String"]["output"]>;
  runLengths: Array<Scalars["Int"]["output"]>;
  score?: Maybe<Scalars["Int"]["output"]>;
  spinTypeBreakdown: SpinTypeBreakdownGql;
  totalShots: Scalars["Int"]["output"];
  totalShotsMade: Scalars["Int"]["output"];
  userId?: Maybe<Scalars["Int"]["output"]>;
  username?: Maybe<Scalars["String"]["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 PocketPointsInputGql = {
  bottomLeft: IntPoint2DInput;
  bottomRight: IntPoint2DInput;
  bottomSide: IntPoint2DInput;
  topLeft: IntPoint2DInput;
  topRight: IntPoint2DInput;
  topSide: IntPoint2DInput;
};

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 PoolHall = {
  __typename?: "PoolHall";
  address?: Maybe<Scalars["String"]["output"]>;
  city?: Maybe<Scalars["String"]["output"]>;
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  latitude?: Maybe<Scalars["Float"]["output"]>;
  longitude?: Maybe<Scalars["Float"]["output"]>;
  name: Scalars["String"]["output"];
  state?: Maybe<Scalars["String"]["output"]>;
  status: Scalars["String"]["output"];
  timezone?: Maybe<Scalars["String"]["output"]>;
  updatedAt: Scalars["DateTime"]["output"];
};

export type PoolHallCamera = {
  __typename?: "PoolHallCamera";
  allowsPrivateVideos: Scalars["Boolean"]["output"];
  claimTermsText?: Maybe<Scalars["String"]["output"]>;
  claimTermsVersion?: Maybe<Scalars["Int"]["output"]>;
  createdAt: Scalars["DateTime"]["output"];
  id: Scalars["ID"]["output"];
  inUse: Scalars["Boolean"]["output"];
  lastPublishedAt?: Maybe<Scalars["DateTime"]["output"]>;
  lastUnpublishedAt?: Maybe<Scalars["DateTime"]["output"]>;
  name: Scalars["String"]["output"];
  pocketSize?: Maybe<Scalars["Float"]["output"]>;
  poolHall: PoolHall;
  poolHallId: Scalars["ID"]["output"];
  status: Scalars["String"]["output"];
  streamPath: Scalars["String"]["output"];
  tableLabel?: Maybe<Scalars["String"]["output"]>;
  tableSize?: Maybe<Scalars["Float"]["output"]>;
  updatedAt: Scalars["DateTime"]["output"];
};

export type PoolHallCameraStreamCredentials = {
  __typename?: "PoolHallCameraStreamCredentials";
  camera: PoolHallCamera;
  rtmpPath: Scalars["String"]["output"];
  streamKey: Scalars["String"]["output"];
};

export type PotAimGql = {
  __typename?: "PotAimGQL";
  converged: Scalars["Boolean"]["output"];
  cutAngle: Scalars["Float"]["output"];
  feasible: Scalars["Boolean"]["output"];
  geometricPhi: Scalars["Float"]["output"];
  occludingBallIds: Array<Scalars["Int"]["output"]>;
  phi: Scalars["Float"]["output"];
  potted: Scalars["Boolean"]["output"];
  requiredPrecision: Scalars["Float"]["output"];
};

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

export type ProcessingStatusCountGql = {
  __typename?: "ProcessingStatusCountGQL";
  count: Scalars["Int"]["output"];
  status: Scalars["String"]["output"];
};

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";
  activeCameraLease?: Maybe<CameraLease>;
  cameraClaimSession?: Maybe<CameraClaimSession>;
  challenge?: Maybe<Challenge>;
  challengeLeaderboard: Array<ChallengeEntry>;
  challenges: Array<Challenge>;
  claimableCameras: Array<PoolHallCamera>;
  claimablePoolHalls: Array<PoolHall>;
  computePotAim: PotAimGql;
  doesUsernameExist: Scalars["Boolean"]["output"];
  getAggregatedShotMetrics: Array<AggregateResultGql>;
  getAppleAppAccountToken: Scalars["String"]["output"];
  getAvailableSubscriptionOptions: StripeSubscriptionOptionsGql;
  getBucketSet?: Maybe<BucketSetGql>;
  getDeployedConfig: DeployedConfigGql;
  getDrillRunLeaderboard: DrillRunLeaderboardGql;
  getFeedVideos: VideoHistoryGql;
  getGameTypeTagMetrics: Array<GameTypeTagMetric>;
  getLiveTableState: LiveTableStateGql;
  getLoggedInUser?: Maybe<UserGql>;
  getLongestRunsLeaderboard: RunLeaderboardGql;
  getMakesLeaderboard: CountLeaderboardGql;
  getMedals: RequestedMedalsGql;
  getMyDrillRuns: Array<RunGql>;
  getOrderedShots: GetShotsResult;
  getPlayTime: UserPlayTimeGql;
  getQuotaStatus: QuotaStatusGql;
  getResolvedTier: ResolvedTierGql;
  getRuns: GetRunsResult;
  getSessionCoach: SessionCoachGql;
  getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
  getShotTableState: ShotTableStateGql;
  getShots: Array<ShotGql>;
  getShotsByIds: Array<ShotGql>;
  getShotsWithMetadata: GetShotsResult;
  getStorageStatus?: Maybe<StorageStatusGql>;
  getTableState: TableStateGql;
  getUsageStats: UsageStatsGql;
  getUser?: Maybe<UserGql>;
  getUserRelationshipsMatching: UserRelationshipsResult;
  getUserSubscriptionStatus: UserSubscriptionStatusGql;
  getUserTags: Array<TagGql>;
  getUserVideos: VideoHistoryGql;
  getUsernames: Array<Scalars["String"]["output"]>;
  getUsersMatching: Array<UserGql>;
  getVideo: VideoGql;
  getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
  getVideos: Array<VideoGql>;
  isChallengeDismissed: Scalars["Boolean"]["output"];
  myChallengeEntries: Array<ChallengeEntry>;
  myChallengeInvitations: Array<ChallengeInvitation>;
  myDismissedChallenges: Array<Challenge>;
  myVideoExports: Array<VideoExportJobGql>;
  notifications: NotificationConnection;
  poolHallCameras: Array<PoolHallCamera>;
  poolHalls: Array<PoolHall>;
  ruleSets: Array<RuleSet>;
  simulateShot: ShotProjectionGql;
  unreadNotificationCount: Scalars["Int"]["output"];
  videoExportJob?: Maybe<VideoExportJobGql>;
  videoPlayerClusters: Array<PlayerClusterGql>;
  waitFor: Scalars["Float"]["output"];
};

export type QueryCameraClaimSessionArgs = {
  id: Scalars["ID"]["input"];
};

export type QueryChallengeArgs = {
  id: Scalars["ID"]["input"];
};

export type QueryChallengeLeaderboardArgs = {
  challengeId: Scalars["ID"]["input"];
  limit?: Scalars["Int"]["input"];
};

export type QueryChallengesArgs = {
  includeDismissed?: Scalars["Boolean"]["input"];
};

export type QueryClaimableCamerasArgs = {
  poolHallId: Scalars["ID"]["input"];
};

export type QueryComputePotAimArgs = {
  pocket: PocketIdentifier;
  simulationInput: SimulateShotInputGql;
  targetBallId: Scalars["Int"]["input"];
};

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

export type QueryGetAggregatedShotMetricsArgs = {
  aggregateInput: AggregateInputGql;
};

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

export type QueryGetDrillRunLeaderboardArgs = {
  drillTag: Scalars["String"]["input"];
  interval?: InputMaybe<TimeInterval>;
  limit?: Scalars["Int"]["input"];
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
};

export type QueryGetFeedVideosArgs = {
  after?: InputMaybe<Scalars["String"]["input"]>;
  feedInput?: InputMaybe<VideoFeedInputGql>;
  filters?: InputMaybe<VideoFilterInput>;
  includeCallersVideos?: InputMaybe<Scalars["Boolean"]["input"]>;
  includePrivate?: IncludePrivateEnum;
  limit?: Scalars["Int"]["input"];
};

export type QueryGetGameTypeTagMetricsArgs = {
  input: GameTypeTagMetricsInput;
};

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

export type QueryGetLongestRunsLeaderboardArgs = {
  excludeDrills?: Scalars["Boolean"]["input"];
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  interval?: InputMaybe<TimeInterval>;
  limit?: Scalars["Int"]["input"];
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  rankedOnly?: Scalars["Boolean"]["input"];
  requiredTags?: InputMaybe<Array<Scalars["String"]["input"]>>;
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  when?: InputMaybe<Scalars["DateTime"]["input"]>;
};

export type QueryGetMakesLeaderboardArgs = {
  excludeDrills?: Scalars["Boolean"]["input"];
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  interval?: InputMaybe<TimeInterval>;
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  rankedOnly?: Scalars["Boolean"]["input"];
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  when?: InputMaybe<Scalars["DateTime"]["input"]>;
};

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

export type QueryGetMyDrillRunsArgs = {
  drillTag: Scalars["String"]["input"];
  limit?: 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 QueryGetRunsArgs = {
  countRespectsLimit?: Scalars["Boolean"]["input"];
  filterInput: RunFilterInput;
  limit?: Scalars["Int"]["input"];
  runIds?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  runsOrdering?: InputMaybe<GetRunsOrdering>;
};

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

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

export type QueryGetShotTableStateArgs = {
  shotId: Scalars["Int"]["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 QueryGetTableStateArgs = {
  b64Image: Scalars["String"]["input"];
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
  useHomography?: InputMaybe<HomographyInputGql>;
};

export type QueryGetUsageStatsArgs = {
  days?: Scalars["Int"]["input"];
};

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 QueryGetUserTagsArgs = {
  includeRetiredTags?: InputMaybe<Scalars["Boolean"]["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 QueryGetUsersMatchingArgs = {
  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 QueryIsChallengeDismissedArgs = {
  challengeId: Scalars["ID"]["input"];
};

export type QueryMyVideoExportsArgs = {
  limit?: Scalars["Int"]["input"];
  offset?: Scalars["Int"]["input"];
};

export type QueryNotificationsArgs = {
  filters?: InputMaybe<NotificationFilters>;
  limit?: Scalars["Int"]["input"];
  offset?: Scalars["Int"]["input"];
};

export type QueryPoolHallCamerasArgs = {
  poolHallId: Scalars["ID"]["input"];
};

export type QuerySimulateShotArgs = {
  simulationInput: SimulateShotInputGql;
};

export type QueryVideoExportJobArgs = {
  jobId: Scalars["Int"]["input"];
};

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

export type QueryWaitForArgs = {
  duration: Scalars["Float"]["input"];
};

export type QuotaBucketStatusGql = {
  __typename?: "QuotaBucketStatusGQL";
  appliesToUploadKind: Scalars["String"]["output"];
  canUpload: Scalars["Boolean"]["output"];
  durationLimitSeconds?: Maybe<Scalars["Int"]["output"]>;
  durationRemainingSeconds?: Maybe<Scalars["Float"]["output"]>;
  durationUsedSeconds: Scalars["Float"]["output"];
  periodEnd: Scalars["DateTime"]["output"];
  periodStart: Scalars["DateTime"]["output"];
  quotaKey: Scalars["String"]["output"];
};

export type QuotaStatusGql = {
  __typename?: "QuotaStatusGQL";
  canUpload: Scalars["Boolean"]["output"];
  durationLimitSeconds?: Maybe<Scalars["Int"]["output"]>;
  durationRemainingSeconds?: Maybe<Scalars["Float"]["output"]>;
  durationUsedSeconds: Scalars["Float"]["output"];
  importQuotaBuckets: Array<QuotaBucketStatusGql>;
  maxVideoDurationSeconds?: Maybe<Scalars["Int"]["output"]>;
  periodEnd: Scalars["DateTime"]["output"];
  periodStart: Scalars["DateTime"]["output"];
  recordingQuotaBuckets: Array<QuotaBucketStatusGql>;
  tierName: Scalars["String"]["output"];
};

export type RgbColorGql = {
  __typename?: "RGBColorGQL";
  b: Scalars["Int"]["output"];
  g: Scalars["Int"]["output"];
  hex: Scalars["String"]["output"];
  r: Scalars["Int"]["output"];
};

export enum ReactionEnum {
  Bullseye = "BULLSEYE",
  Heart = "HEART",
  Hundred = "HUNDRED",
  Like = "LIKE",
}

export type ReactionGql = {
  __typename?: "ReactionGQL";
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  reaction: ReactionEnum;
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  user: UserGql;
  videoId: Scalars["Int"]["output"];
};

export enum ReportReasonEnum {
  Copyright = "COPYRIGHT",
  Hate = "HATE",
  Nudity = "NUDITY",
  Other = "OTHER",
  Spam = "SPAM",
  Violence = "VIOLENCE",
}

export type RequestVideoExportInput = {
  mode: VideoExportModeEnum;
  runId?: InputMaybe<Scalars["Int"]["input"]>;
  shotIds?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  videoId: Scalars["Int"]["input"];
};

export type RequestedMedalsGql = {
  __typename?: "RequestedMedalsGQL";
  dailyMakes50?: Maybe<MedalGql>;
  dailyMakes100?: Maybe<MedalGql>;
  dailyMakes150?: Maybe<MedalGql>;
  dailyMakes200?: Maybe<MedalGql>;
  dailyMakes250?: 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>;
  /** @deprecated no longer supported */
  totalMakes25?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes50?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes75?: Maybe<MedalGql>;
  totalMakes100?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes200?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes300?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes400?: Maybe<MedalGql>;
  totalMakes500?: Maybe<MedalGql>;
  /** @deprecated no longer supported */
  totalMakes750?: Maybe<MedalGql>;
  totalMakes1000?: Maybe<MedalGql>;
  totalMakes5000?: Maybe<MedalGql>;
  totalMakes10000?: Maybe<MedalGql>;
};

export type ResolvedTierGql = {
  __typename?: "ResolvedTierGQL";
  capabilities: Array<Scalars["String"]["output"]>;
  entitlementEndsAt?: Maybe<Scalars["DateTime"]["output"]>;
  entitlementSource?: Maybe<EntitlementSourceTypeEnum>;
  entitlementStartsAt?: Maybe<Scalars["DateTime"]["output"]>;
  entitlementStatus?: Maybe<Scalars["String"]["output"]>;
  hasActiveSubscription: Scalars["Boolean"]["output"];
  tierDisplayName: Scalars["String"]["output"];
  tierName: Scalars["String"]["output"];
};

export type RuleSet = {
  __typename?: "RuleSet";
  createdAt: Scalars["DateTime"]["output"];
  description?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["ID"]["output"];
  name: Scalars["String"]["output"];
  updatedAt: Scalars["DateTime"]["output"];
};

export type RunFeaturesGql = {
  __typename?: "RunFeaturesGQL";
  indexInRun: Scalars["Int"]["output"];
  runId: Scalars["Int"]["output"];
};

export type RunFilterInput = {
  andFilters?: InputMaybe<Array<RunFilterInput>>;
  createdAt?: InputMaybe<DateRangeFilter>;
  notFilter?: InputMaybe<RunFilterInput>;
  orFilters?: InputMaybe<Array<RunFilterInput>>;
  runLength?: InputMaybe<FloatRangeFilter>;
  tableSize?: InputMaybe<FloatRangeFilter>;
  userId?: InputMaybe<Array<Scalars["Int"]["input"]>>;
  username?: InputMaybe<Array<Scalars["String"]["input"]>>;
  videoId?: InputMaybe<Array<Scalars["Int"]["input"]>>;
};

export type RunGql = {
  __typename?: "RunGQL";
  id: Scalars["Int"]["output"];
  runLength: Scalars["Int"]["output"];
  shots: Array<ShotGql>;
  user: UserGql;
  userId: Scalars["Int"]["output"];
  video: VideoGql;
  videoId: Scalars["Int"]["output"];
};

export type RunLeaderboardGql = {
  __typename?: "RunLeaderboardGQL";
  entries: Array<RunGql>;
};

export type RunsOrderingComponent =
  | { runLength: IntOrdering; videoCreation?: never; videoId?: never }
  | { runLength?: never; videoCreation: DatetimeOrdering; videoId?: never }
  | { runLength?: never; videoCreation?: never; videoId: IntOrdering };

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 SegmentInfo = {
  __typename?: "SegmentInfo";
  index: Scalars["Int"]["output"];
  time: Scalars["Float"]["output"];
};

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

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

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

export type SessionCoachBaselineGql = {
  __typename?: "SessionCoachBaselineGQL";
  attemptCount: Scalars["Int"]["output"];
  madeCount: Scalars["Int"]["output"];
  makePercentage: Scalars["Float"]["output"];
  sessionCount: Scalars["Int"]["output"];
};

export enum SessionCoachCandidateFamilyEnum {
  Aiming = "AIMING",
  BackCut = "BACK_CUT",
  CueToObjectDistance = "CUE_TO_OBJECT_DISTANCE",
  CutAngle = "CUT_ANGLE",
  ObjectToPocketDistance = "OBJECT_TO_POCKET_DISTANCE",
  Overall = "OVERALL",
  Spin = "SPIN",
}

export type SessionCoachCandidateGql = {
  __typename?: "SessionCoachCandidateGQL";
  action: Scalars["String"]["output"];
  body: Scalars["String"]["output"];
  drillId?: Maybe<Scalars["String"]["output"]>;
  evidence: SessionCoachEvidenceGql;
  family: SessionCoachCandidateFamilyEnum;
  id: Scalars["ID"]["output"];
  kind: SessionCoachCandidateKindEnum;
  limitations: Array<Scalars["String"]["output"]>;
  rank: Scalars["Int"]["output"];
  supportingShotIds: Array<Scalars["Int"]["output"]>;
  title: Scalars["String"]["output"];
};

export enum SessionCoachCandidateKindEnum {
  BaselineComparison = "BASELINE_COMPARISON",
  DirectionalMiss = "DIRECTIONAL_MISS",
  OutcomePattern = "OUTCOME_PATTERN",
  SessionStreak = "SESSION_STREAK",
  StrengthPattern = "STRENGTH_PATTERN",
  UsagePattern = "USAGE_PATTERN",
}

export type SessionCoachDecisionGql = {
  __typename?: "SessionCoachDecisionGQL";
  body?: Maybe<Scalars["String"]["output"]>;
  drillId?: Maybe<Scalars["String"]["output"]>;
  drillReason?: Maybe<Scalars["String"]["output"]>;
  positiveBody?: Maybe<Scalars["String"]["output"]>;
  positiveTitle?: Maybe<Scalars["String"]["output"]>;
  practiceAttemptCount?: Maybe<Scalars["Int"]["output"]>;
  practiceTarget?: Maybe<Scalars["String"]["output"]>;
  selectedCandidateId?: Maybe<Scalars["ID"]["output"]>;
  selectedPositiveCandidateId?: Maybe<Scalars["ID"]["output"]>;
  sessionSummary?: Maybe<Scalars["String"]["output"]>;
  suggestedAction?: Maybe<Scalars["String"]["output"]>;
  supportingCandidateIds: Array<Scalars["ID"]["output"]>;
  supportingShotIds: Array<Scalars["Int"]["output"]>;
  title?: Maybe<Scalars["String"]["output"]>;
};

export type SessionCoachEvidenceGql = {
  __typename?: "SessionCoachEvidenceGQL";
  attemptCount: Scalars["Int"]["output"];
  baselineAttemptCount: Scalars["Int"]["output"];
  baselineMadeCount: Scalars["Int"]["output"];
  baselineMakePercentage?: Maybe<Scalars["Float"]["output"]>;
  baselineSessionCount: Scalars["Int"]["output"];
  bucketKey: Scalars["String"]["output"];
  bucketLabel: Scalars["String"]["output"];
  comparisonAttemptCount: Scalars["Int"]["output"];
  comparisonMadeCount: Scalars["Int"]["output"];
  comparisonMakePercentage?: Maybe<Scalars["Float"]["output"]>;
  madeCount: Scalars["Int"]["output"];
  makePercentage: Scalars["Float"]["output"];
  missedCount: Scalars["Int"]["output"];
  patternShotCount: Scalars["Int"]["output"];
  rankReason: Scalars["String"]["output"];
  score: Scalars["Float"]["output"];
};

export type SessionCoachGql = {
  __typename?: "SessionCoachGQL";
  agentGeneration?: Maybe<SessionCoachGenerationGql>;
  analysisVersion: Scalars["String"]["output"];
  analyzedShotCount: Scalars["Int"]["output"];
  candidates: Array<SessionCoachCandidateGql>;
  generatedAt: Scalars["DateTime"]["output"];
  ineligibilityReason?: Maybe<SessionCoachIneligibilityReasonEnum>;
  longestMakeStreak: Scalars["Int"]["output"];
  madeCount: Scalars["Int"]["output"];
  makePercentage?: Maybe<Scalars["Float"]["output"]>;
  missedCount: Scalars["Int"]["output"];
  positiveCandidates: Array<SessionCoachCandidateGql>;
  primaryCandidate?: Maybe<SessionCoachCandidateGql>;
  processingId?: Maybe<Scalars["Int"]["output"]>;
  processingStatus?: Maybe<Scalars["String"]["output"]>;
  recentBaseline?: Maybe<SessionCoachBaselineGql>;
  shotCount: Scalars["Int"]["output"];
  state: SessionCoachStateEnum;
  summary?: Maybe<Scalars["String"]["output"]>;
  unknownOutcomeCount: Scalars["Int"]["output"];
  videoId: Scalars["Int"]["output"];
};

export type SessionCoachGenerationDiagnosticsGql = {
  __typename?: "SessionCoachGenerationDiagnosticsGQL";
  abstentionReason?: Maybe<Scalars["String"]["output"]>;
  analysisVersion: Scalars["String"]["output"];
  attemptCount: Scalars["Int"]["output"];
  cachedInputTokens?: Maybe<Scalars["Int"]["output"]>;
  enqueueCount: Scalars["Int"]["output"];
  failureCode?: Maybe<Scalars["String"]["output"]>;
  inputHash: Scalars["String"]["output"];
  inputTokens?: Maybe<Scalars["Int"]["output"]>;
  lastEnqueuedAt?: Maybe<Scalars["DateTime"]["output"]>;
  latencyMs?: Maybe<Scalars["Int"]["output"]>;
  maxAttempts: Scalars["Int"]["output"];
  modelName: Scalars["String"]["output"];
  outputTokens?: Maybe<Scalars["Int"]["output"]>;
  promptVersion: Scalars["String"]["output"];
  providerKey: Scalars["String"]["output"];
  startedAt?: Maybe<Scalars["DateTime"]["output"]>;
  synthesisRationale?: Maybe<Scalars["String"]["output"]>;
  updatedAt: Scalars["DateTime"]["output"];
};

export type SessionCoachGenerationGql = {
  __typename?: "SessionCoachGenerationGQL";
  completedAt?: Maybe<Scalars["DateTime"]["output"]>;
  createdAt: Scalars["DateTime"]["output"];
  decision?: Maybe<SessionCoachDecisionGql>;
  diagnostics?: Maybe<SessionCoachGenerationDiagnosticsGql>;
  id: Scalars["ID"]["output"];
  state: SessionCoachGenerationStateEnum;
};

export enum SessionCoachGenerationStateEnum {
  Failed = "FAILED",
  Queued = "QUEUED",
  Ready = "READY",
  Running = "RUNNING",
}

export enum SessionCoachIneligibilityReasonEnum {
  Multiplayer = "MULTIPLAYER",
}

export enum SessionCoachStateEnum {
  Failed = "FAILED",
  Ineligible = "INELIGIBLE",
  NoTrackedShots = "NO_TRACKED_SHOTS",
  Processing = "PROCESSING",
  Ready = "READY",
}

export type ShareLinkGql = {
  __typename?: "ShareLinkGQL";
  slug: Scalars["String"]["output"];
  url: 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"];
  endSegment: SegmentInfo;
  endTime: Scalars["Float"]["output"];
  falsePositiveScore?: Maybe<Scalars["Float"]["output"]>;
  id: Scalars["Int"]["output"];
  pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
  pocketingIntentionInfo?: Maybe<PocketingIntentionInfoGql>;
  run?: Maybe<RunGql>;
  runFeatures?: Maybe<RunFeaturesGql>;
  serializedShotPaths?: Maybe<SerializedShotPathsGql>;
  startFrame: Scalars["Int"]["output"];
  startSegment: SegmentInfo;
  startTime: Scalars["Float"]["output"];
  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  user?: Maybe<UserGql>;
  video?: Maybe<VideoGql>;
  videoId: Scalars["Int"]["output"];
};

export type ShotMoveInput = {
  newClusterId: Scalars["Int"]["input"];
  shotId: Scalars["Int"]["input"];
};

export type ShotProjectionGql = {
  __typename?: "ShotProjectionGQL";
  events: Array<SimulationEventGql>;
  finalState: Array<SimulationBallStateGql>;
  pottedBallIds: Array<Scalars["Int"]["output"]>;
  trajectories: Array<BallTrajectoryGql>;
};

export type ShotTableStateGql = {
  __typename?: "ShotTableStateGQL";
  frameIndex: Scalars["Int"]["output"];
  shotId: Scalars["Int"]["output"];
  tableState: TableStateGql;
  videoId: Scalars["Int"]["output"];
};

export type ShotsOrderingComponent =
  | {
      difficulty: FloatOrdering;
      marginOfError?: never;
      runLength?: never;
      startFrame?: never;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      difficulty?: never;
      marginOfError: FloatOrdering;
      runLength?: never;
      startFrame?: never;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      difficulty?: never;
      marginOfError?: never;
      runLength: IntOrdering;
      startFrame?: never;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      difficulty?: never;
      marginOfError?: never;
      runLength?: never;
      startFrame: IntOrdering;
      videoCreation?: never;
      videoId?: never;
    }
  | {
      difficulty?: never;
      marginOfError?: never;
      runLength?: never;
      startFrame?: never;
      videoCreation: DatetimeOrdering;
      videoId?: never;
    }
  | {
      difficulty?: never;
      marginOfError?: never;
      runLength?: never;
      startFrame?: never;
      videoCreation?: never;
      videoId: IntOrdering;
    };

export type SimulateShotInputGql = {
  b64Image?: InputMaybe<Scalars["String"]["input"]>;
  balls?: InputMaybe<Array<SimulationBallStateInputGql>>;
  cueBallId: Scalars["Int"]["input"];
  strike: CueStrikeInputGql;
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
  useHomography?: InputMaybe<HomographyInputGql>;
};

export type SimulationBallStateGql = {
  __typename?: "SimulationBallStateGQL";
  ballId: Scalars["Int"]["output"];
  position: Array<Scalars["Float"]["output"]>;
};

export type SimulationBallStateInputGql = {
  ballId: Scalars["Int"]["input"];
  position: Array<Scalars["Float"]["input"]>;
};

export type SimulationEventGql = {
  __typename?: "SimulationEventGQL";
  ballIds: Array<Scalars["Int"]["output"]>;
  eventType: SimulationEventType;
  position?: Maybe<Array<Scalars["Float"]["output"]>>;
  time: Scalars["Float"]["output"];
};

export enum SimulationEventType {
  BallBall = "BALL_BALL",
  BallCushion = "BALL_CUSHION",
  BallPocket = "BALL_POCKET",
  BallStop = "BALL_STOP",
  StickBall = "STICK_BALL",
}

export type SpinTypeBreakdownGql = {
  __typename?: "SpinTypeBreakdownGQL";
  center: Scalars["Int"]["output"];
  draw: Scalars["Int"]["output"];
  follow: Scalars["Int"]["output"];
};

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 StorageLimitExceededErr = {
  __typename?: "StorageLimitExceededErr";
  reason: Scalars["String"]["output"];
  remainingStorageBytes?: Maybe<Scalars["BigInt"]["output"]>;
  retainedStorageLimitBytes?: Maybe<Scalars["BigInt"]["output"]>;
  retainedStorageUsedBytes: Scalars["BigInt"]["output"];
  tierName: Scalars["String"]["output"];
};

export type StorageStatusGql = {
  __typename?: "StorageStatusGQL";
  isNearLimit: Scalars["Boolean"]["output"];
  isOverLimit: Scalars["Boolean"]["output"];
  isUnlimited: Scalars["Boolean"]["output"];
  lastCalculatedAt?: Maybe<Scalars["DateTime"]["output"]>;
  policyConfigured: Scalars["Boolean"]["output"];
  remainingStorageBytes?: Maybe<Scalars["BigInt"]["output"]>;
  retainedStorageLimitBytes?: Maybe<Scalars["BigInt"]["output"]>;
  retainedStorageUsedBytes: Scalars["BigInt"]["output"];
  storageUsageRatio?: Maybe<Scalars["Float"]["output"]>;
  tierName: Scalars["String"]["output"];
  usageCalculated: Scalars["Boolean"]["output"];
  usageSource?: Maybe<Scalars["String"]["output"]>;
  userId: Scalars["Int"]["output"];
};

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

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

export type StripePriceGql = {
  __typename?: "StripePriceGQL";
  active: Scalars["Boolean"]["output"];
  currency: Scalars["String"]["output"];
  id: Scalars["String"]["output"];
  recurringInterval?: Maybe<Scalars["String"]["output"]>;
  recurringIntervalCount?: Maybe<Scalars["Int"]["output"]>;
  type: Scalars["String"]["output"];
  unitAmount?: Maybe<Scalars["Int"]["output"]>;
};

export type StripeProductGql = {
  __typename?: "StripeProductGQL";
  active: Scalars["Boolean"]["output"];
  description?: Maybe<Scalars["String"]["output"]>;
  id: Scalars["String"]["output"];
  name: Scalars["String"]["output"];
  prices: Array<StripePriceGql>;
};

export type StripeSubscriptionOptionsGql = {
  __typename?: "StripeSubscriptionOptionsGQL";
  appleIap: AppleIapSubscriptionOptionsGql;
  products: Array<StripeProductGql>;
  tierOptions: Array<SubscriptionTierPurchaseOptionGql>;
  trialPeriodDays?: Maybe<Scalars["Int"]["output"]>;
};

export enum StripeSubscriptionStatusEnum {
  Active = "ACTIVE",
  Canceled = "CANCELED",
  Incomplete = "INCOMPLETE",
  IncompleteExpired = "INCOMPLETE_EXPIRED",
  PastDue = "PAST_DUE",
  Paused = "PAUSED",
  Trialing = "TRIALING",
  Unpaid = "UNPAID",
}

export type SubscriptionTierPurchaseOptionGql = {
  __typename?: "SubscriptionTierPurchaseOptionGQL";
  appleProductId?: Maybe<Scalars["String"]["output"]>;
  billingInterval: Scalars["String"]["output"];
  currency?: Maybe<Scalars["String"]["output"]>;
  isAvailable: Scalars["Boolean"]["output"];
  isConfigured: Scalars["Boolean"]["output"];
  platform: Scalars["String"]["output"];
  recurringIntervalCount?: Maybe<Scalars["Int"]["output"]>;
  stripePriceId?: Maybe<Scalars["String"]["output"]>;
  stripeProductId?: Maybe<Scalars["String"]["output"]>;
  tierDisplayName: Scalars["String"]["output"];
  tierName: Scalars["String"]["output"];
  unitAmount?: Maybe<Scalars["Int"]["output"]>;
};

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

export type SuccessfulAddAddShotAnnotationErrors =
  | AddShotAnnotationErrors
  | SuccessfulAdd;

export type SyncAppleSubscriptionInputGql = {
  signedRenewalInfo?: InputMaybe<Scalars["String"]["input"]>;
  signedTransactionInfo: Scalars["String"]["input"];
};

export type SyncAppleSubscriptionResultGql = {
  __typename?: "SyncAppleSubscriptionResultGQL";
  appleStatus?: Maybe<Scalars["Int"]["output"]>;
  entitlementEndsAt?: Maybe<Scalars["DateTime"]["output"]>;
  entitlementSource?: Maybe<EntitlementSourceTypeEnum>;
  entitlementStartsAt?: Maybe<Scalars["DateTime"]["output"]>;
  errorCode?: Maybe<Scalars["String"]["output"]>;
  errorMessage?: Maybe<Scalars["String"]["output"]>;
  expiresAt?: Maybe<Scalars["DateTime"]["output"]>;
  hasActiveSubscription: Scalars["Boolean"]["output"];
  latestTransactionId?: Maybe<Scalars["String"]["output"]>;
  ok: Scalars["Boolean"]["output"];
  originalTransactionId?: Maybe<Scalars["String"]["output"]>;
  productId?: Maybe<Scalars["String"]["output"]>;
};

export type TableStateGql = {
  __typename?: "TableStateGQL";
  homography?: Maybe<HomographyInfoGql>;
  identifierToColor: Array<Maybe<RgbColorGql>>;
  identifierToPosition: Array<Array<Scalars["Float"]["output"]>>;
};

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

export type TagGql = {
  __typename?: "TagGQL";
  id: Scalars["Int"]["output"];
  name: Scalars["String"]["output"];
  retired: Scalars["Boolean"]["output"];
  tagClasses?: Maybe<Array<TagClassGql>>;
};

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 TrajectoryPointGql = {
  __typename?: "TrajectoryPointGQL";
  position: Array<Scalars["Float"]["output"]>;
  time: Scalars["Float"]["output"];
};

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

export type UpdatePoolHallCameraInput = {
  allowsPrivateVideos?: InputMaybe<Scalars["Boolean"]["input"]>;
  claimTermsText?: InputMaybe<Scalars["String"]["input"]>;
  id: Scalars["ID"]["input"];
  name?: InputMaybe<Scalars["String"]["input"]>;
  pocketSize?: InputMaybe<Scalars["Float"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  tableLabel?: InputMaybe<Scalars["String"]["input"]>;
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
};

export type UpdatePoolHallInput = {
  address?: InputMaybe<Scalars["String"]["input"]>;
  city?: InputMaybe<Scalars["String"]["input"]>;
  id: Scalars["ID"]["input"];
  latitude?: InputMaybe<Scalars["Float"]["input"]>;
  longitude?: InputMaybe<Scalars["Float"]["input"]>;
  name?: InputMaybe<Scalars["String"]["input"]>;
  state?: InputMaybe<Scalars["String"]["input"]>;
  status?: InputMaybe<Scalars["String"]["input"]>;
  timezone?: 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 UploadLinkBatch = {
  __typename?: "UploadLinkBatch";
  alreadyUploaded: Array<Scalars["Int"]["output"]>;
  links: Array<SegmentUploadLink>;
};

export type UploadLinkBatchGetUploadLinkErrors =
  | GetUploadLinkErrors
  | UploadLinkBatch;

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";
  clientUploadStatus?: Maybe<ClientUploadStatusEnum>;
  createdAt: Scalars["DateTime"]["output"];
  errors: Array<StreamErrorGql>;
  id: Scalars["ID"]["output"];
  initPlaylistUploadStatus?: Maybe<InitPlaylistUploadStatusEnum>;
  isCompleted: Scalars["Boolean"]["output"];
  lastIntendedSegmentBound?: Maybe<Scalars["Int"]["output"]>;
  lastSegmentUploadedAt?: Maybe<Scalars["DateTime"]["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 UsageStatsDailyGql = {
  __typename?: "UsageStatsDailyGQL";
  activeUsers: Scalars["Int"]["output"];
  day: Scalars["Date"]["output"];
  newUsers: Scalars["Int"]["output"];
  sessions: Scalars["Int"]["output"];
  shots: Scalars["Int"]["output"];
};

export type UsageStatsGql = {
  __typename?: "UsageStatsGQL";
  cohorts: Array<CohortStatsGql>;
  daily: Array<UsageStatsDailyGql>;
  funnel: FunnelStatsGql;
  processingLast24h: Array<ProcessingStatusCountGql>;
  totalRuns: Scalars["Int"]["output"];
  totalShots: Scalars["Int"]["output"];
  totalUsers: Scalars["Int"]["output"];
  totalVideos: Scalars["Int"]["output"];
  windows: Array<UsageStatsWindowGql>;
};

export type UsageStatsWindowGql = {
  __typename?: "UsageStatsWindowGQL";
  activeUsers: Scalars["Int"]["output"];
  label: Scalars["String"]["output"];
  newUsers: Scalars["Int"]["output"];
  sessions: Scalars["Int"]["output"];
  shots: Scalars["Int"]["output"];
};

export type UserGql = {
  __typename?: "UserGQL";
  activeVideoId?: Maybe<Scalars["Int"]["output"]>;
  agreesToMarketing?: Maybe<Scalars["Boolean"]["output"]>;
  bio?: Maybe<Scalars["String"]["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"]>;
  isFollowedByCurrentUser?: Maybe<Scalars["Boolean"]["output"]>;
  profileImageUri?: Maybe<Scalars["String"]["output"]>;
  stripeCustomerId?: 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 UserShotCountEntry = {
  __typename?: "UserShotCountEntry";
  proportionMade: Scalars["Float"]["output"];
  total: Scalars["Int"]["output"];
  user: UserGql;
  value: Scalars["Int"]["output"];
  videos: Scalars["Int"]["output"];
};

export type UserSubscriptionStatusGql = {
  __typename?: "UserSubscriptionStatusGQL";
  currentPeriodEnd?: Maybe<Scalars["DateTime"]["output"]>;
  currentPeriodStart?: Maybe<Scalars["DateTime"]["output"]>;
  entitlementEndsAt?: Maybe<Scalars["DateTime"]["output"]>;
  entitlementSource?: Maybe<EntitlementSourceTypeEnum>;
  entitlementStartsAt?: Maybe<Scalars["DateTime"]["output"]>;
  hasActiveSubscription: Scalars["Boolean"]["output"];
  stripePriceId?: Maybe<Scalars["String"]["output"]>;
  stripeSubscriptionId?: Maybe<Scalars["String"]["output"]>;
  subscriptionStatus?: Maybe<StripeSubscriptionStatusEnum>;
  validUntil?: Maybe<Scalars["DateTime"]["output"]>;
};

export type VideoExportJobGql = {
  __typename?: "VideoExportJobGQL";
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  downloadUrl?: Maybe<Scalars["String"]["output"]>;
  expiresAt?: Maybe<Scalars["DateTime"]["output"]>;
  fileSizeBytes?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["Int"]["output"];
  mode: VideoExportModeEnum;
  runId?: Maybe<Scalars["Int"]["output"]>;
  shotIds?: Maybe<Array<Scalars["Int"]["output"]>>;
  status: VideoExportStatusEnum;
  videoId: Scalars["Int"]["output"];
  videoName?: Maybe<Scalars["String"]["output"]>;
  videoThumbnailUri?: Maybe<Scalars["String"]["output"]>;
};

export enum VideoExportModeEnum {
  FullSession = "FULL_SESSION",
  Run = "RUN",
  Shots = "SHOTS",
}

export enum VideoExportStatusEnum {
  Created = "CREATED",
  Expired = "EXPIRED",
  Failed = "FAILED",
  Queued = "QUEUED",
  Running = "RUNNING",
  Succeeded = "SUCCEEDED",
}

export type VideoFeedInputGql =
  | {
      allUsers: Scalars["Boolean"]["input"];
      followedByUserId?: never;
      home?: never;
      userId?: never;
    }
  | {
      allUsers?: never;
      followedByUserId: Scalars["Int"]["input"];
      home?: never;
      userId?: never;
    }
  | {
      allUsers?: never;
      followedByUserId?: never;
      home: Scalars["Boolean"]["input"];
      userId?: never;
    }
  | {
      allUsers?: never;
      followedByUserId?: never;
      home?: never;
      userId: Scalars["Int"]["input"];
    };

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

export type VideoGql = {
  __typename?: "VideoGQL";
  averageDifficulty?: Maybe<Scalars["Float"]["output"]>;
  averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
  comments: Array<CommentGql>;
  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
  currentHomography?: Maybe<HomographyInfoGql>;
  currentProcessing?: Maybe<VideoProcessingGql>;
  elapsedTime?: Maybe<Scalars["Float"]["output"]>;
  endTime?: Maybe<Scalars["DateTime"]["output"]>;
  framesPerSecond?: Maybe<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>;
  playerSummaries: Array<PlayerSummaryGql>;
  playlist?: Maybe<HlsPlaylistGql>;
  pocketSize?: Maybe<Scalars["Float"]["output"]>;
  private: Scalars["Boolean"]["output"];
  reactions: Array<ReactionGql>;
  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";
  followingCount: Scalars["Int"]["output"];
  hasFollowing: Scalars["Boolean"]["output"];
  pageInfo: PageInfoGql;
  videos: Array<VideoGql>;
};

export type VideoMetadataInput = {
  clientUploadStatus?: InputMaybe<ClientUploadStatusEnum>;
  endStream?: Scalars["Boolean"]["input"];
  endTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
  /** @deprecated `game_type` is deprecated. Use `tags` instead. */
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  homographyBackend?: InputMaybe<HomographyBackendGql>;
  lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
  pocketSize?: InputMaybe<Scalars["Float"]["input"]>;
  private?: InputMaybe<Scalars["Boolean"]["input"]>;
  resolution?: InputMaybe<VideoResolution>;
  startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
  streamSegmentType?: InputMaybe<StreamSegmentTypeEnum>;
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
  /** A list of tags associated with the video. Replace `game_type` */
  tags?: InputMaybe<Array<VideoTagInput>>;
  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";
  currentSegment?: Maybe<Scalars["Int"]["output"]>;
  errors: Array<VideoProcessingErrorGql>;
  framesProcessed?: Maybe<Scalars["Int"]["output"]>;
  id: Scalars["Int"]["output"];
  labels: Array<Scalars["String"]["output"]>;
  parentProcessingId?: Maybe<Scalars["Int"]["output"]>;
  progressPercentage?: Maybe<Scalars["Float"]["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;
      averageDifficulty?: number | null;
    };
  }>;
};

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

export type GetChallengesQuery = {
  __typename?: "Query";
  challenges: Array<{
    __typename?: "Challenge";
    id: string;
    name: string;
    description?: string | null;
    minimumShots: number;
    startDate: any;
    endDate: any;
    createdAt: any;
    updatedAt: any;
    requiredTableSize?: number | null;
    requiredPocketSize?: number | null;
    isPublic: boolean;
    maxAttempts?: number | null;
    ruleSet: {
      __typename?: "RuleSet";
      id: string;
      name: string;
      description?: string | null;
    };
    createdBy: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
  }>;
};

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

export type GetMyDismissedChallengesQuery = {
  __typename?: "Query";
  myDismissedChallenges: Array<{
    __typename?: "Challenge";
    id: string;
    name: string;
    description?: string | null;
    minimumShots: number;
    startDate: any;
    endDate: any;
    createdAt: any;
    updatedAt: any;
    requiredTableSize?: number | null;
    requiredPocketSize?: number | null;
    isPublic: boolean;
    maxAttempts?: number | null;
    ruleSet: {
      __typename?: "RuleSet";
      id: string;
      name: string;
      description?: string | null;
    };
    createdBy: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
  }>;
};

export type GetChallengeQueryVariables = Exact<{
  id: Scalars["ID"]["input"];
}>;

export type GetChallengeQuery = {
  __typename?: "Query";
  challenge?: {
    __typename?: "Challenge";
    id: string;
    name: string;
    description?: string | null;
    minimumShots: number;
    startDate: any;
    endDate: any;
    createdAt: any;
    updatedAt: any;
    requiredTableSize?: number | null;
    requiredPocketSize?: number | null;
    isPublic: boolean;
    maxAttempts?: number | null;
    participantCount: number;
    ruleSet: {
      __typename?: "RuleSet";
      id: string;
      name: string;
      description?: string | null;
    };
    createdBy: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
    invitations: Array<{
      __typename?: "ChallengeInvitation";
      id: string;
      status: string;
      createdAt: any;
      invitee: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
      inviter: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
    }>;
  } | null;
};

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

export type GetRuleSetsQuery = {
  __typename?: "Query";
  ruleSets: Array<{
    __typename?: "RuleSet";
    id: string;
    name: string;
    description?: string | null;
  }>;
};

export type GetChallengeLeaderboardQueryVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
  limit?: InputMaybe<Scalars["Int"]["input"]>;
}>;

export type GetChallengeLeaderboardQuery = {
  __typename?: "Query";
  challengeLeaderboard: Array<{
    __typename?: "ChallengeEntry";
    id: string;
    status: string;
    shotsCount?: number | null;
    makesCount?: number | null;
    makeRate?: number | null;
    qualified?: boolean | null;
    createdAt: any;
    attemptCount?: number | null;
    user: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
    video?: {
      __typename?: "VideoGQL";
      id: number;
      createdAt?: any | null;
    } | null;
  }>;
};

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

export type GetMyChallengeInvitationsQuery = {
  __typename?: "Query";
  myChallengeInvitations: Array<{
    __typename?: "ChallengeInvitation";
    id: string;
    status: string;
    createdAt: any;
    challenge: {
      __typename?: "Challenge";
      id: string;
      name: string;
      description?: string | null;
      startDate: any;
      endDate: any;
      createdBy: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
    };
    inviter: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
  }>;
};

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

export type GetMyChallengeEntriesQuery = {
  __typename?: "Query";
  myChallengeEntries: Array<{
    __typename?: "ChallengeEntry";
    id: string;
    status: string;
    shotsCount?: number | null;
    makesCount?: number | null;
    makeRate?: number | null;
    qualified?: boolean | null;
    createdAt: any;
    challenge: { __typename?: "Challenge"; id: string; name: string };
    video?: { __typename?: "VideoGQL"; id: number } | null;
  }>;
};

export type CreateRuleSetMutationVariables = Exact<{
  name: Scalars["String"]["input"];
  description?: InputMaybe<Scalars["String"]["input"]>;
}>;

export type CreateRuleSetMutation = {
  __typename?: "Mutation";
  createRuleSet: {
    __typename?: "RuleSet";
    id: string;
    name: string;
    description?: string | null;
  };
};

export type CreateChallengeMutationVariables = Exact<{
  name: Scalars["String"]["input"];
  ruleSetId: Scalars["ID"]["input"];
  minimumShots: Scalars["Int"]["input"];
  startDate: Scalars["DateTime"]["input"];
  endDate: Scalars["DateTime"]["input"];
  description?: InputMaybe<Scalars["String"]["input"]>;
  requiredTableSize?: InputMaybe<Scalars["Float"]["input"]>;
  requiredPocketSize?: InputMaybe<Scalars["Float"]["input"]>;
  isPublic?: Scalars["Boolean"]["input"];
  maxAttempts?: InputMaybe<Scalars["Int"]["input"]>;
}>;

export type CreateChallengeMutation = {
  __typename?: "Mutation";
  createChallenge: {
    __typename?: "Challenge";
    id: string;
    name: string;
    description?: string | null;
    requiredTableSize?: number | null;
    requiredPocketSize?: number | null;
    isPublic: boolean;
    maxAttempts?: number | null;
  };
};

export type InviteUsersToChallengeMutationVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
  userIds: Array<Scalars["ID"]["input"]> | Scalars["ID"]["input"];
}>;

export type InviteUsersToChallengeMutation = {
  __typename?: "Mutation";
  inviteUsersToChallenge: Array<{
    __typename?: "ChallengeInvitation";
    id: string;
    status: string;
    inviter: { __typename?: "UserGQL"; id: number; username: string };
  }>;
};

export type RespondToChallengeInvitationMutationVariables = Exact<{
  invitationId: Scalars["ID"]["input"];
  accept: Scalars["Boolean"]["input"];
}>;

export type RespondToChallengeInvitationMutation = {
  __typename?: "Mutation";
  respondToChallengeInvitation: {
    __typename?: "ChallengeInvitation";
    id: string;
    status: string;
    challenge: { __typename?: "Challenge"; id: string };
  };
};

export type StartChallengeMutationVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
}>;

export type StartChallengeMutation = {
  __typename?: "Mutation";
  startChallenge: {
    __typename?: "ChallengeEntry";
    id: string;
    status: string;
    createdAt: any;
    challenge: { __typename?: "Challenge"; id: string; name: string };
  };
};

export type SubmitChallengeEntryMutationVariables = Exact<{
  entryId: Scalars["ID"]["input"];
  videoId: Scalars["ID"]["input"];
}>;

export type SubmitChallengeEntryMutation = {
  __typename?: "Mutation";
  submitChallengeEntry: {
    __typename?: "ChallengeEntry";
    id: string;
    status: string;
    qualified?: boolean | null;
    makeRate?: number | null;
    shotsCount?: number | null;
    makesCount?: number | null;
    video?: { __typename?: "VideoGQL"; id: number } | null;
  };
};

export type RecalculateChallengeEntryMutationVariables = Exact<{
  entryId: Scalars["ID"]["input"];
}>;

export type RecalculateChallengeEntryMutation = {
  __typename?: "Mutation";
  recalculateChallengeEntry: {
    __typename?: "ChallengeEntry";
    id: string;
    status: string;
    qualified?: boolean | null;
    makeRate?: number | null;
    shotsCount?: number | null;
    makesCount?: number | null;
  };
};

export type IsChallengeDismissedQueryVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
}>;

export type IsChallengeDismissedQuery = {
  __typename?: "Query";
  isChallengeDismissed: boolean;
};

export type DismissChallengeMutationVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
}>;

export type DismissChallengeMutation = {
  __typename?: "Mutation";
  dismissChallenge: boolean;
};

export type UndismissChallengeMutationVariables = Exact<{
  challengeId: Scalars["ID"]["input"];
}>;

export type UndismissChallengeMutation = {
  __typename?: "Mutation";
  undismissChallenge: boolean;
};

export type CommentOnVideoMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  message: Scalars["String"]["input"];
  parentCommentId?: InputMaybe<Scalars["Int"]["input"]>;
}>;

export type CommentOnVideoMutation = {
  __typename?: "Mutation";
  commentOnVideo: boolean;
};

export type EditCommentMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  commentId: Scalars["Int"]["input"];
  newMessage: Scalars["String"]["input"];
}>;

export type EditCommentMutation = {
  __typename?: "Mutation";
  editComment: boolean;
};

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

export type DeleteCommentMutation = {
  __typename?: "Mutation";
  deleteComment: boolean;
};

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;
    subscriptionGatingEnabled: boolean;
    quotaEnforcementEnabled: boolean;
    storageLimitEnforcementEnabled: boolean;
    capabilityEnforcementEnabled: boolean;
    defaultAndroidRecordingFormat: StreamSegmentTypeEnum;
    bucketUrl: string;
    bannerMessages: Array<{
      __typename?: "BannerGQL";
      color: string;
      dismissible: boolean;
      id: number;
      kind: BannerKindEnum;
      message: string;
      priority: number;
    }>;
  };
};

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

export type BlockContentMutation = {
  __typename?: "Mutation";
  blockContent: boolean;
};

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

export type BlockUserMutation = { __typename?: "Mutation"; blockUser: boolean };

export type ReportContentMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  reason: ReportReasonEnum;
  customReason?: InputMaybe<Scalars["String"]["input"]>;
}>;

export type ReportContentMutation = {
  __typename?: "Mutation";
  reportContent: boolean;
};

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

export type GetFeedQuery = {
  __typename?: "Query";
  getUserVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      screenshotUri?: string | null;
      totalShots: number;
      makePercentage: number;
      averageTimeBetweenShots?: number | null;
      averageDifficulty?: number | null;
      startTime?: any | null;
      private: boolean;
      elapsedTime?: number | null;
      tableSize: number;
      pocketSize?: number | null;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        lastIntendedSegmentBound?: number | null;
        uploadCompletionCursor: number;
        streamSegmentType: StreamSegmentTypeEnum;
        isCompleted: boolean;
        lastSegmentUploadedAt?: any | null;
        clientUploadStatus?: ClientUploadStatusEnum | null;
      } | null;
      tags: Array<{
        __typename?: "VideoTag";
        name: string;
        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
      }>;
      playerSummaries: Array<{
        __typename?: "PlayerSummaryGQL";
        clusterId: number;
        userId?: number | null;
        username?: string | null;
        profileImageUri?: string | null;
        representativeFullFrameUrl?: string | null;
        totalShots: number;
        totalShotsMade: number;
        makePercentage: number;
        score?: number | null;
        longestRun: number;
        runLengths: Array<number>;
        averageDifficulty?: number | null;
        averageTimeBetweenShots?: number | null;
        spinTypeBreakdown: {
          __typename?: "SpinTypeBreakdownGQL";
          draw: number;
          center: number;
          follow: number;
        };
      }>;
      currentProcessing?: {
        __typename?: "VideoProcessingGQL";
        id: number;
        status: ProcessingStatusEnum;
      } | null;
      reactions: Array<{
        __typename?: "ReactionGQL";
        videoId: number;
        reaction: ReactionEnum;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
      }>;
      comments: Array<{
        __typename?: "CommentGQL";
        id: number;
        message: string;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
        replies: Array<{
          __typename?: "CommentGQL";
          id: number;
          message: string;
          replyToCommentId?: number | null;
          user: {
            __typename?: "UserGQL";
            id: number;
            username: string;
            profileImageUri?: string | null;
            isFollowedByCurrentUser?: boolean | null;
          };
        }>;
      }>;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export type UserSocialsFieldsFragment = {
  __typename?: "UserGQL";
  id: number;
  username: string;
  profileImageUri?: string | null;
  isFollowedByCurrentUser?: boolean | null;
};

export type VideoCardFieldsFragment = {
  __typename?: "VideoGQL";
  id: number;
  name?: string | null;
  screenshotUri?: string | null;
  totalShots: number;
  makePercentage: number;
  averageTimeBetweenShots?: number | null;
  averageDifficulty?: number | null;
  startTime?: any | null;
  private: boolean;
  elapsedTime?: number | null;
  tableSize: number;
  pocketSize?: number | null;
  owner?: {
    __typename?: "UserGQL";
    id: number;
    username: string;
    profileImageUri?: string | null;
  } | null;
  stream?: {
    __typename?: "UploadStreamGQL";
    id: string;
    lastIntendedSegmentBound?: number | null;
    uploadCompletionCursor: number;
    streamSegmentType: StreamSegmentTypeEnum;
    isCompleted: boolean;
    lastSegmentUploadedAt?: any | null;
    clientUploadStatus?: ClientUploadStatusEnum | null;
  } | null;
  tags: Array<{
    __typename?: "VideoTag";
    name: string;
    tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
  }>;
  playerSummaries: Array<{
    __typename?: "PlayerSummaryGQL";
    clusterId: number;
    userId?: number | null;
    username?: string | null;
    profileImageUri?: string | null;
    representativeFullFrameUrl?: string | null;
    totalShots: number;
    totalShotsMade: number;
    makePercentage: number;
    score?: number | null;
    longestRun: number;
    runLengths: Array<number>;
    averageDifficulty?: number | null;
    averageTimeBetweenShots?: number | null;
    spinTypeBreakdown: {
      __typename?: "SpinTypeBreakdownGQL";
      draw: number;
      center: number;
      follow: number;
    };
  }>;
  currentProcessing?: {
    __typename?: "VideoProcessingGQL";
    id: number;
    status: ProcessingStatusEnum;
  } | null;
  reactions: Array<{
    __typename?: "ReactionGQL";
    videoId: number;
    reaction: ReactionEnum;
    user: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
      isFollowedByCurrentUser?: boolean | null;
    };
  }>;
  comments: Array<{
    __typename?: "CommentGQL";
    id: number;
    message: string;
    user: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
      isFollowedByCurrentUser?: boolean | null;
    };
    replies: Array<{
      __typename?: "CommentGQL";
      id: number;
      message: string;
      replyToCommentId?: number | null;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
        isFollowedByCurrentUser?: boolean | null;
      };
    }>;
  }>;
};

export type GetVideoFeedSessionCountQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
  filters?: InputMaybe<VideoFilterInput>;
  includePrivate?: InputMaybe<IncludePrivateEnum>;
  feedInput?: InputMaybe<VideoFeedInputGql>;
}>;

export type GetVideoFeedSessionCountQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{ __typename?: "VideoGQL"; id: number; totalShots: number }>;
  };
};

export type GetLastSessionDateQueryVariables = Exact<{
  filters?: InputMaybe<VideoFilterInput>;
  includePrivate?: InputMaybe<IncludePrivateEnum>;
  feedInput?: InputMaybe<VideoFeedInputGql>;
}>;

export type GetLastSessionDateQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      startTime?: any | null;
    }>;
  };
};

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

export type GetVideoFeedQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    hasFollowing: boolean;
    followingCount: number;
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      screenshotUri?: string | null;
      totalShots: number;
      makePercentage: number;
      averageTimeBetweenShots?: number | null;
      averageDifficulty?: number | null;
      startTime?: any | null;
      private: boolean;
      elapsedTime?: number | null;
      tableSize: number;
      pocketSize?: number | null;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        lastIntendedSegmentBound?: number | null;
        uploadCompletionCursor: number;
        streamSegmentType: StreamSegmentTypeEnum;
        isCompleted: boolean;
        lastSegmentUploadedAt?: any | null;
        clientUploadStatus?: ClientUploadStatusEnum | null;
      } | null;
      tags: Array<{
        __typename?: "VideoTag";
        name: string;
        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
      }>;
      playerSummaries: Array<{
        __typename?: "PlayerSummaryGQL";
        clusterId: number;
        userId?: number | null;
        username?: string | null;
        profileImageUri?: string | null;
        representativeFullFrameUrl?: string | null;
        totalShots: number;
        totalShotsMade: number;
        makePercentage: number;
        score?: number | null;
        longestRun: number;
        runLengths: Array<number>;
        averageDifficulty?: number | null;
        averageTimeBetweenShots?: number | null;
        spinTypeBreakdown: {
          __typename?: "SpinTypeBreakdownGQL";
          draw: number;
          center: number;
          follow: number;
        };
      }>;
      currentProcessing?: {
        __typename?: "VideoProcessingGQL";
        id: number;
        status: ProcessingStatusEnum;
      } | null;
      reactions: Array<{
        __typename?: "ReactionGQL";
        videoId: number;
        reaction: ReactionEnum;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
      }>;
      comments: Array<{
        __typename?: "CommentGQL";
        id: number;
        message: string;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
        replies: Array<{
          __typename?: "CommentGQL";
          id: number;
          message: string;
          replyToCommentId?: number | null;
          user: {
            __typename?: "UserGQL";
            id: number;
            username: string;
            profileImageUri?: string | null;
            isFollowedByCurrentUser?: boolean | null;
          };
        }>;
      }>;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export type GetMakesLeaderboardQueryVariables = Exact<{
  interval?: InputMaybe<TimeInterval>;
  when?: InputMaybe<Scalars["DateTime"]["input"]>;
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
}>;

export type GetMakesLeaderboardQuery = {
  __typename?: "Query";
  getMakesLeaderboard: {
    __typename?: "CountLeaderboardGQL";
    entries: Array<{
      __typename?: "UserShotCountEntry";
      value: number;
      proportionMade: number;
      total: number;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
    }>;
  };
};

export type GetRunsLeaderboardQueryVariables = Exact<{
  interval?: InputMaybe<TimeInterval>;
  when?: InputMaybe<Scalars["DateTime"]["input"]>;
  gameType?: InputMaybe<Scalars["String"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
}>;

export type GetRunsLeaderboardQuery = {
  __typename?: "Query";
  getLongestRunsLeaderboard: {
    __typename?: "RunLeaderboardGQL";
    entries: Array<{
      __typename?: "RunGQL";
      id: number;
      runLength: number;
      video: {
        __typename?: "VideoGQL";
        name?: string | null;
        createdAt?: any | null;
      };
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
    }>;
  };
};

export type GetDrillRunLeaderboardQueryVariables = Exact<{
  drillTag: Scalars["String"]["input"];
  interval?: InputMaybe<TimeInterval>;
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  tableSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  tableSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMin?: InputMaybe<Scalars["Float"]["input"]>;
  pocketSizeMax?: InputMaybe<Scalars["Float"]["input"]>;
}>;

export type GetDrillRunLeaderboardQuery = {
  __typename?: "Query";
  getDrillRunLeaderboard: {
    __typename?: "DrillRunLeaderboardGQL";
    youRank?: number | null;
    totalPlayers: number;
    entries: Array<{
      __typename?: "RunGQL";
      id: number;
      runLength: number;
      videoId: number;
      video: {
        __typename?: "VideoGQL";
        tableSize: number;
        pocketSize?: number | null;
        createdAt?: any | null;
      };
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
    }>;
    youRun?: {
      __typename?: "RunGQL";
      id: number;
      runLength: number;
      videoId: number;
    } | null;
  };
};

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

export type GetMyDrillRunsQuery = {
  __typename?: "Query";
  getMyDrillRuns: Array<{
    __typename?: "RunGQL";
    id: number;
    runLength: number;
    videoId: number;
    video: { __typename?: "VideoGQL"; createdAt?: any | null };
  }>;
};

export type GetRecordedStreamsQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
}>;

export type GetRecordedStreamsQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      createdAt?: any | null;
      screenshotUri?: string | null;
      framesPerSecond?: number | null;
      totalShots: number;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
    }>;
  };
};

export type GetLiveStreamsQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
}>;

export type GetLiveStreamsQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      startTime?: any | null;
      createdAt?: any | null;
      screenshotUri?: string | null;
      elapsedTime?: number | null;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        isCompleted: boolean;
        lastSegmentUploadedAt?: any | null;
      } | 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 MedalFieldsFragment = {
  __typename?: "MedalGQL";
  count: number;
  nickname?: string | null;
};

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

export type GetMedalsQuery = {
  __typename?: "Query";
  getMedals: {
    __typename?: "RequestedMedalsGQL";
    distanceOver78?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    distanceOver90?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength3?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength5?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength8?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength10?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength15?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength20?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength25?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength30?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength40?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    runLength50?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    totalMakes100?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    totalMakes500?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    totalMakes1000?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    totalMakes5000?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    totalMakes10000?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    dailyMakes50?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    dailyMakes100?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    dailyMakes150?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    dailyMakes200?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
    dailyMakes250?: {
      __typename?: "MedalGQL";
      count: number;
      nickname?: string | null;
    } | null;
  };
};

export type GetNotificationsQueryVariables = Exact<{
  limit?: Scalars["Int"]["input"];
  offset?: Scalars["Int"]["input"];
  filters?: InputMaybe<NotificationFilters>;
}>;

export type GetNotificationsQuery = {
  __typename?: "Query";
  notifications: {
    __typename?: "NotificationConnection";
    totalCount: number;
    unreadCount: number;
    hasMore: boolean;
    notifications: Array<{
      __typename?: "NotificationGQL";
      id: number;
      notificationType: NotificationTypeEnum;
      videoId?: number | null;
      challengeId?: number | null;
      reactionType?: string | null;
      isRead: boolean;
      createdAt: any;
      readAt?: any | null;
      actor: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      };
      challenge?: { __typename?: "Challenge"; id: string; name: string } | null;
      comment?: {
        __typename?: "CommentGQL";
        id: number;
        message: string;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
        };
      } | null;
    }>;
  };
};

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

export type GetUnreadNotificationCountQuery = {
  __typename?: "Query";
  unreadNotificationCount: number;
};

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

export type MarkNotificationAsReadMutation = {
  __typename?: "Mutation";
  markNotificationAsRead: boolean;
};

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

export type MarkNotificationsAsReadMutation = {
  __typename?: "Mutation";
  markNotificationsAsRead: boolean;
};

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

export type MarkAllNotificationsAsReadMutation = {
  __typename?: "Mutation";
  markAllNotificationsAsRead: boolean;
};

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

export type DeleteNotificationMutation = {
  __typename?: "Mutation";
  deleteNotification: boolean;
};

export type NotificationFragment = {
  __typename?: "NotificationGQL";
  id: number;
  notificationType: NotificationTypeEnum;
  videoId?: number | null;
  challengeId?: number | null;
  reactionType?: string | null;
  isRead: boolean;
  createdAt: any;
  readAt?: any | null;
  actor: {
    __typename?: "UserGQL";
    id: number;
    username: string;
    profileImageUri?: string | null;
  };
  challenge?: { __typename?: "Challenge"; id: string; name: string } | null;
  comment?: {
    __typename?: "CommentGQL";
    id: number;
    message: string;
    user: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    };
  } | null;
};

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

export type EnsureStripeCustomerExistsMutation = {
  __typename?: "Mutation";
  ensureStripeCustomerExists: {
    __typename?: "UserGQL";
    id: number;
    firebaseUid?: string | null;
    username: string;
    stripeCustomerId?: string | null;
    profileImageUri?: string | null;
    isAdmin?: boolean | null;
    fargoRating?: number | null;
    videosPrivateByDefault?: boolean | null;
    createdAt?: any | null;
    updatedAt?: any | null;
  };
};

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

export type CreateSubscriptionMutation = {
  __typename?: "Mutation";
  createSubscription: {
    __typename?: "CreateSubscriptionResultGQL";
    checkoutUrl: string;
    sessionId: string;
  };
};

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

export type CreateCustomerPortalSessionMutation = {
  __typename?: "Mutation";
  createCustomerPortalSession: {
    __typename?: "CreateCustomerPortalSessionResultGQL";
    portalUrl: string;
  };
};

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

export type GetAvailableSubscriptionOptionsQuery = {
  __typename?: "Query";
  getAvailableSubscriptionOptions: {
    __typename?: "StripeSubscriptionOptionsGQL";
    trialPeriodDays?: number | null;
    products: Array<{
      __typename?: "StripeProductGQL";
      id: string;
      name: string;
      description?: string | null;
      active: boolean;
      prices: Array<{
        __typename?: "StripePriceGQL";
        id: string;
        currency: string;
        unitAmount?: number | null;
        recurringInterval?: string | null;
        recurringIntervalCount?: number | null;
        type: string;
        active: boolean;
      }>;
    }>;
    appleIap: {
      __typename?: "AppleIapSubscriptionOptionsGQL";
      enabled: boolean;
      proMonthlyProductId?: string | null;
      productIds: Array<string>;
    };
    tierOptions: Array<{
      __typename?: "SubscriptionTierPurchaseOptionGQL";
      tierName: string;
      tierDisplayName: string;
      billingInterval: string;
      platform: string;
      isConfigured: boolean;
      isAvailable: boolean;
      stripeProductId?: string | null;
      stripePriceId?: string | null;
      appleProductId?: string | null;
      currency?: string | null;
      unitAmount?: number | null;
      recurringIntervalCount?: number | null;
    }>;
  };
};

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

export type GetSubscriptionStatusQuery = {
  __typename?: "Query";
  getUserSubscriptionStatus: {
    __typename?: "UserSubscriptionStatusGQL";
    hasActiveSubscription: boolean;
    entitlementSource?: EntitlementSourceTypeEnum | null;
    entitlementStartsAt?: any | null;
    entitlementEndsAt?: any | null;
    subscriptionStatus?: StripeSubscriptionStatusEnum | null;
    currentPeriodStart?: any | null;
    currentPeriodEnd?: any | null;
    validUntil?: any | null;
    stripePriceId?: string | null;
    stripeSubscriptionId?: string | null;
  };
};

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

export type GetResolvedTierQuery = {
  __typename?: "Query";
  getResolvedTier: {
    __typename?: "ResolvedTierGQL";
    tierName: string;
    tierDisplayName: string;
    hasActiveSubscription: boolean;
    entitlementSource?: EntitlementSourceTypeEnum | null;
    entitlementStatus?: string | null;
    entitlementStartsAt?: any | null;
    entitlementEndsAt?: any | null;
    capabilities: Array<string>;
  };
};

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

export type GetStorageStatusQuery = {
  __typename?: "Query";
  getStorageStatus?: {
    __typename?: "StorageStatusGQL";
    userId: number;
    tierName: string;
    retainedStorageUsedBytes: any;
    retainedStorageLimitBytes?: any | null;
    isUnlimited: boolean;
    policyConfigured: boolean;
    remainingStorageBytes?: any | null;
    storageUsageRatio?: number | null;
    isNearLimit: boolean;
    isOverLimit: boolean;
    usageCalculated: boolean;
    usageSource?: string | null;
    lastCalculatedAt?: any | null;
  } | null;
};

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

export type GetAppleAppAccountTokenQuery = {
  __typename?: "Query";
  getAppleAppAccountToken: string;
};

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

export type SyncAppleSubscriptionMutation = {
  __typename?: "Mutation";
  syncAppleSubscription: {
    __typename?: "SyncAppleSubscriptionResultGQL";
    ok: boolean;
    errorCode?: string | null;
    errorMessage?: string | null;
    hasActiveSubscription: boolean;
    entitlementSource?: EntitlementSourceTypeEnum | null;
    entitlementStartsAt?: any | null;
    entitlementEndsAt?: any | null;
    appleStatus?: number | null;
    originalTransactionId?: string | null;
    latestTransactionId?: string | null;
    productId?: string | null;
    expiresAt?: any | null;
  };
};

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

export type CancelSubscriptionMutation = {
  __typename?: "Mutation";
  cancelSubscription: {
    __typename?: "UserSubscriptionStatusGQL";
    hasActiveSubscription: boolean;
    entitlementSource?: EntitlementSourceTypeEnum | null;
    entitlementStartsAt?: any | null;
    entitlementEndsAt?: any | null;
    subscriptionStatus?: StripeSubscriptionStatusEnum | null;
    currentPeriodStart?: any | null;
    currentPeriodEnd?: any | null;
    validUntil?: any | null;
    stripePriceId?: string | null;
    stripeSubscriptionId?: string | null;
  };
};

export type SubmitCancellationFeedbackMutationVariables = Exact<{
  reasons?: InputMaybe<Array<CancellationReasonEnum> | CancellationReasonEnum>;
  feedback?: InputMaybe<Scalars["String"]["input"]>;
  metadata?: InputMaybe<CancellationFeedbackMetadataInput>;
}>;

export type SubmitCancellationFeedbackMutation = {
  __typename?: "Mutation";
  submitCancellationFeedback: boolean;
};

export type PoolHallFieldsFragment = {
  __typename?: "PoolHall";
  id: string;
  name: string;
  address?: string | null;
  city?: string | null;
  state?: string | null;
  latitude?: number | null;
  longitude?: number | null;
  timezone?: string | null;
  status: string;
  createdAt: any;
  updatedAt: any;
};

export type PoolHallCameraFieldsFragment = {
  __typename?: "PoolHallCamera";
  id: string;
  poolHallId: string;
  name: string;
  tableLabel?: string | null;
  streamPath: string;
  status: string;
  tableSize?: number | null;
  pocketSize?: number | null;
  allowsPrivateVideos: boolean;
  claimTermsText?: string | null;
  claimTermsVersion?: number | null;
  inUse: boolean;
  lastPublishedAt?: any | null;
  lastUnpublishedAt?: any | null;
  createdAt: any;
  updatedAt: any;
};

export type PoolHallCameraWithHallFieldsFragment = {
  __typename?: "PoolHallCamera";
  id: string;
  poolHallId: string;
  name: string;
  tableLabel?: string | null;
  streamPath: string;
  status: string;
  tableSize?: number | null;
  pocketSize?: number | null;
  allowsPrivateVideos: boolean;
  claimTermsText?: string | null;
  claimTermsVersion?: number | null;
  inUse: boolean;
  lastPublishedAt?: any | null;
  lastUnpublishedAt?: any | null;
  createdAt: any;
  updatedAt: any;
  poolHall: {
    __typename?: "PoolHall";
    id: string;
    name: string;
    address?: string | null;
    city?: string | null;
    state?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    timezone?: string | null;
    status: string;
    createdAt: any;
    updatedAt: any;
  };
};

export type PoolHallCameraStreamCredentialsFieldsFragment = {
  __typename?: "PoolHallCameraStreamCredentials";
  streamKey: string;
  rtmpPath: string;
  camera: {
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  };
};

export type CameraClaimSessionFieldsFragment = {
  __typename?: "CameraClaimSession";
  id: string;
  cameraId: string;
  userId: string;
  challengeCode: string;
  status: string;
  expiresAt: any;
  detectedAt?: any | null;
  failedAt?: any | null;
  failureReason?: string | null;
  agreedTermsVersion?: number | null;
  createdAt: any;
  updatedAt: any;
  camera: {
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  };
};

export type CameraLeaseFieldsFragment = {
  __typename?: "CameraLease";
  id: string;
  cameraId: string;
  claimSessionId?: string | null;
  userId: string;
  videoId?: string | null;
  status: string;
  startedAt: any;
  endedAt?: any | null;
  expiresAt?: any | null;
  endReason?: string | null;
  createdAt: any;
  updatedAt: any;
  camera: {
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  };
};

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

export type GetPoolHallsQuery = {
  __typename?: "Query";
  poolHalls: Array<{
    __typename?: "PoolHall";
    id: string;
    name: string;
    address?: string | null;
    city?: string | null;
    state?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    timezone?: string | null;
    status: string;
    createdAt: any;
    updatedAt: any;
  }>;
};

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

export type GetClaimablePoolHallsQuery = {
  __typename?: "Query";
  claimablePoolHalls: Array<{
    __typename?: "PoolHall";
    id: string;
    name: string;
    address?: string | null;
    city?: string | null;
    state?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    timezone?: string | null;
    status: string;
    createdAt: any;
    updatedAt: any;
  }>;
};

export type GetPoolHallCamerasQueryVariables = Exact<{
  poolHallId: Scalars["ID"]["input"];
}>;

export type GetPoolHallCamerasQuery = {
  __typename?: "Query";
  poolHallCameras: Array<{
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  }>;
};

export type GetClaimableCamerasQueryVariables = Exact<{
  poolHallId: Scalars["ID"]["input"];
}>;

export type GetClaimableCamerasQuery = {
  __typename?: "Query";
  claimableCameras: Array<{
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  }>;
};

export type GetCameraClaimSessionQueryVariables = Exact<{
  id: Scalars["ID"]["input"];
}>;

export type GetCameraClaimSessionQuery = {
  __typename?: "Query";
  cameraClaimSession?: {
    __typename?: "CameraClaimSession";
    id: string;
    cameraId: string;
    userId: string;
    challengeCode: string;
    status: string;
    expiresAt: any;
    detectedAt?: any | null;
    failedAt?: any | null;
    failureReason?: string | null;
    agreedTermsVersion?: number | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  } | null;
};

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

export type GetActiveCameraLeaseQuery = {
  __typename?: "Query";
  activeCameraLease?: {
    __typename?: "CameraLease";
    id: string;
    cameraId: string;
    claimSessionId?: string | null;
    userId: string;
    videoId?: string | null;
    status: string;
    startedAt: any;
    endedAt?: any | null;
    expiresAt?: any | null;
    endReason?: string | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  } | null;
};

export type CreatePoolHallMutationVariables = Exact<{
  input: CreatePoolHallInput;
}>;

export type CreatePoolHallMutation = {
  __typename?: "Mutation";
  createPoolHall: {
    __typename?: "PoolHall";
    id: string;
    name: string;
    address?: string | null;
    city?: string | null;
    state?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    timezone?: string | null;
    status: string;
    createdAt: any;
    updatedAt: any;
  };
};

export type UpdatePoolHallMutationVariables = Exact<{
  input: UpdatePoolHallInput;
}>;

export type UpdatePoolHallMutation = {
  __typename?: "Mutation";
  updatePoolHall: {
    __typename?: "PoolHall";
    id: string;
    name: string;
    address?: string | null;
    city?: string | null;
    state?: string | null;
    latitude?: number | null;
    longitude?: number | null;
    timezone?: string | null;
    status: string;
    createdAt: any;
    updatedAt: any;
  };
};

export type CreatePoolHallCameraMutationVariables = Exact<{
  input: CreatePoolHallCameraInput;
}>;

export type CreatePoolHallCameraMutation = {
  __typename?: "Mutation";
  createPoolHallCamera: {
    __typename?: "PoolHallCameraStreamCredentials";
    streamKey: string;
    rtmpPath: string;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type UpdatePoolHallCameraMutationVariables = Exact<{
  input: UpdatePoolHallCameraInput;
}>;

export type UpdatePoolHallCameraMutation = {
  __typename?: "Mutation";
  updatePoolHallCamera: {
    __typename?: "PoolHallCamera";
    id: string;
    poolHallId: string;
    name: string;
    tableLabel?: string | null;
    streamPath: string;
    status: string;
    tableSize?: number | null;
    pocketSize?: number | null;
    allowsPrivateVideos: boolean;
    claimTermsText?: string | null;
    claimTermsVersion?: number | null;
    inUse: boolean;
    lastPublishedAt?: any | null;
    lastUnpublishedAt?: any | null;
    createdAt: any;
    updatedAt: any;
    poolHall: {
      __typename?: "PoolHall";
      id: string;
      name: string;
      address?: string | null;
      city?: string | null;
      state?: string | null;
      latitude?: number | null;
      longitude?: number | null;
      timezone?: string | null;
      status: string;
      createdAt: any;
      updatedAt: any;
    };
  };
};

export type RotatePoolHallCameraStreamKeyMutationVariables = Exact<{
  cameraId: Scalars["ID"]["input"];
}>;

export type RotatePoolHallCameraStreamKeyMutation = {
  __typename?: "Mutation";
  rotatePoolHallCameraStreamKey: {
    __typename?: "PoolHallCameraStreamCredentials";
    streamKey: string;
    rtmpPath: string;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type CreateCameraClaimSessionMutationVariables = Exact<{
  cameraId: Scalars["ID"]["input"];
  durationMinutes?: InputMaybe<Scalars["Int"]["input"]>;
  videoName?: InputMaybe<Scalars["String"]["input"]>;
  videoPrivate?: InputMaybe<Scalars["Boolean"]["input"]>;
  agreedTermsVersion?: InputMaybe<Scalars["Int"]["input"]>;
  tags?: InputMaybe<Array<VideoTagInput> | VideoTagInput>;
}>;

export type CreateCameraClaimSessionMutation = {
  __typename?: "Mutation";
  createCameraClaimSession: {
    __typename?: "CameraClaimSession";
    id: string;
    cameraId: string;
    userId: string;
    challengeCode: string;
    status: string;
    expiresAt: any;
    detectedAt?: any | null;
    failedAt?: any | null;
    failureReason?: string | null;
    agreedTermsVersion?: number | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type CancelCameraClaimSessionMutationVariables = Exact<{
  claimSessionId: Scalars["ID"]["input"];
}>;

export type CancelCameraClaimSessionMutation = {
  __typename?: "Mutation";
  cancelCameraClaimSession: {
    __typename?: "CameraClaimSession";
    id: string;
    cameraId: string;
    userId: string;
    challengeCode: string;
    status: string;
    expiresAt: any;
    detectedAt?: any | null;
    failedAt?: any | null;
    failureReason?: string | null;
    agreedTermsVersion?: number | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type EndCameraLeaseMutationVariables = Exact<{
  leaseId: Scalars["ID"]["input"];
}>;

export type EndCameraLeaseMutation = {
  __typename?: "Mutation";
  endCameraLease: {
    __typename?: "CameraLease";
    id: string;
    cameraId: string;
    claimSessionId?: string | null;
    userId: string;
    videoId?: string | null;
    status: string;
    startedAt: any;
    endedAt?: any | null;
    expiresAt?: any | null;
    endReason?: string | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type ExtendCameraLeaseMutationVariables = Exact<{
  leaseId: Scalars["ID"]["input"];
  additionalMinutes?: Scalars["Int"]["input"];
}>;

export type ExtendCameraLeaseMutation = {
  __typename?: "Mutation";
  extendCameraLease: {
    __typename?: "CameraLease";
    id: string;
    cameraId: string;
    claimSessionId?: string | null;
    userId: string;
    videoId?: string | null;
    status: string;
    startedAt: any;
    endedAt?: any | null;
    expiresAt?: any | null;
    endReason?: string | null;
    createdAt: any;
    updatedAt: any;
    camera: {
      __typename?: "PoolHallCamera";
      id: string;
      poolHallId: string;
      name: string;
      tableLabel?: string | null;
      streamPath: string;
      status: string;
      tableSize?: number | null;
      pocketSize?: number | null;
      allowsPrivateVideos: boolean;
      claimTermsText?: string | null;
      claimTermsVersion?: number | null;
      inUse: boolean;
      lastPublishedAt?: any | null;
      lastUnpublishedAt?: any | null;
      createdAt: any;
      updatedAt: any;
      poolHall: {
        __typename?: "PoolHall";
        id: string;
        name: string;
        address?: string | null;
        city?: string | null;
        state?: string | null;
        latitude?: number | null;
        longitude?: number | null;
        timezone?: string | null;
        status: string;
        createdAt: any;
        updatedAt: any;
      };
    };
  };
};

export type ReactToVideoMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  reaction?: InputMaybe<ReactionEnum>;
}>;

export type ReactToVideoMutation = {
  __typename?: "Mutation";
  reactToVideo: boolean;
};

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

export type GetShotLabVideosQuery = {
  __typename?: "Query";
  getFeedVideos: {
    __typename?: "VideoHistoryGQL";
    videos: Array<{
      __typename?: "VideoGQL";
      id: number;
      name?: string | null;
      createdAt?: any | null;
      screenshotUri?: string | null;
      framesPerSecond?: number | null;
      totalShots: number;
      owner?: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
      } | null;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        isCompleted: boolean;
        lastSegmentUploadedAt?: any | null;
      } | null;
    }>;
  };
};

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

export type GetRecordedStreamShotsQuery = {
  __typename?: "Query";
  getOrderedShots: {
    __typename?: "GetShotsResult";
    shots: Array<{
      __typename?: "ShotGQL";
      id: number;
      videoId: number;
      startFrame: number;
      endFrame: number;
      serializedShotPaths?: {
        __typename?: "SerializedShotPathsGQL";
        b64EncodedBuffer?: string | null;
      } | null;
      pocketingIntentionFeatures?: {
        __typename?: "PocketingIntentionFeaturesGQL";
        make?: boolean | null;
      } | null;
      pocketingIntentionInfo?: {
        __typename?: "PocketingIntentionInfoGQL";
        pocketId: PocketIdentifier;
      } | null;
    }>;
  };
};

export type GetRunsForHighlightsQueryVariables = Exact<{
  filterInput: RunFilterInput;
  runIds?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
  runsOrdering?: InputMaybe<GetRunsOrdering>;
  limit?: Scalars["Int"]["input"];
  countRespectsLimit?: Scalars["Boolean"]["input"];
}>;

export type GetRunsForHighlightsQuery = {
  __typename?: "Query";
  getRuns: {
    __typename?: "GetRunsResult";
    count?: number | null;
    runIds: Array<number>;
    runs: Array<{
      __typename?: "RunGQL";
      id: number;
      runLength: number;
      userId: number;
      videoId: number;
      shots: Array<{ __typename?: "ShotGQL"; videoId: number; id: number }>;
    }>;
  };
};

export type PocketingIntentionFragmentFragment = {
  __typename?: "PocketingIntentionFeaturesGQL";
  make?: boolean | null;
  targetPocketDistance?: number | null;
  targetPocketAngle?: number | null;
  targetPocketAngleDirection?: ShotDirectionEnum | null;
  marginOfErrorInDegrees?: number | null;
  intendedPocketType?: PocketEnum | null;
  difficulty?: number | null;
};

export type GetRunsWithTimestampsQueryVariables = Exact<{
  filterInput: RunFilterInput;
  runIds?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
  runsOrdering?: InputMaybe<GetRunsOrdering>;
}>;

export type GetRunsWithTimestampsQuery = {
  __typename?: "Query";
  getRuns: {
    __typename?: "GetRunsResult";
    count?: number | null;
    runIds: Array<number>;
    runs: Array<{
      __typename?: "RunGQL";
      id: number;
      runLength: number;
      userId: number;
      videoId: number;
      shots: Array<{
        __typename?: "ShotGQL";
        videoId: number;
        id: number;
        createdAt?: any | null;
        pocketingIntentionFeatures?: {
          __typename?: "PocketingIntentionFeaturesGQL";
          make?: boolean | null;
          targetPocketDistance?: number | null;
          targetPocketAngle?: number | null;
          targetPocketAngleDirection?: ShotDirectionEnum | null;
          marginOfErrorInDegrees?: number | null;
          intendedPocketType?: PocketEnum | null;
          difficulty?: number | null;
        } | null;
      }>;
    }>;
  };
};

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

export type GetSessionCoachQuery = {
  __typename?: "Query";
  getSessionCoach: {
    __typename?: "SessionCoachGQL";
    videoId: number;
    processingId?: number | null;
    analysisVersion: string;
    state: SessionCoachStateEnum;
    generatedAt: any;
    processingStatus?: string | null;
    ineligibilityReason?: SessionCoachIneligibilityReasonEnum | null;
    summary?: string | null;
    shotCount: number;
    madeCount: number;
    missedCount: number;
    unknownOutcomeCount: number;
    analyzedShotCount: number;
    makePercentage?: number | null;
    primaryCandidate?: {
      __typename?: "SessionCoachCandidateGQL";
      id: string;
      rank: number;
      family: SessionCoachCandidateFamilyEnum;
      kind: SessionCoachCandidateKindEnum;
      title: string;
      body: string;
      action: string;
      supportingShotIds: Array<number>;
      drillId?: string | null;
      limitations: Array<string>;
      evidence: {
        __typename?: "SessionCoachEvidenceGQL";
        bucketKey: string;
        bucketLabel: string;
        attemptCount: number;
        madeCount: number;
        missedCount: number;
        makePercentage: number;
        comparisonAttemptCount: number;
        comparisonMadeCount: number;
        comparisonMakePercentage?: number | null;
        patternShotCount: number;
        score: number;
        rankReason: string;
      };
    } | null;
    candidates: Array<{
      __typename?: "SessionCoachCandidateGQL";
      id: string;
      rank: number;
      family: SessionCoachCandidateFamilyEnum;
      kind: SessionCoachCandidateKindEnum;
      title: string;
      body: string;
      action: string;
      supportingShotIds: Array<number>;
      drillId?: string | null;
      limitations: Array<string>;
      evidence: {
        __typename?: "SessionCoachEvidenceGQL";
        bucketKey: string;
        bucketLabel: string;
        attemptCount: number;
        madeCount: number;
        missedCount: number;
        makePercentage: number;
        comparisonAttemptCount: number;
        comparisonMadeCount: number;
        comparisonMakePercentage?: number | null;
        patternShotCount: number;
        score: number;
        rankReason: string;
      };
    }>;
    agentGeneration?: {
      __typename?: "SessionCoachGenerationGQL";
      id: string;
      state: SessionCoachGenerationStateEnum;
      createdAt: any;
      completedAt?: any | null;
      decision?: {
        __typename?: "SessionCoachDecisionGQL";
        selectedCandidateId?: string | null;
        title?: string | null;
        body?: string | null;
        suggestedAction?: string | null;
        drillId?: string | null;
        drillReason?: string | null;
        practiceAttemptCount?: number | null;
        practiceTarget?: string | null;
      } | null;
      diagnostics?: {
        __typename?: "SessionCoachGenerationDiagnosticsGQL";
        analysisVersion: string;
        promptVersion: string;
        providerKey: string;
        modelName: string;
        inputHash: string;
        attemptCount: number;
        maxAttempts: number;
        enqueueCount: number;
        latencyMs?: number | null;
        inputTokens?: number | null;
        cachedInputTokens?: number | null;
        outputTokens?: number | null;
        failureCode?: string | null;
        updatedAt: any;
        startedAt?: any | null;
        lastEnqueuedAt?: any | null;
        abstentionReason?: string | null;
      } | null;
    } | null;
  };
};

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

export type RequestSessionCoachGenerationMutation = {
  __typename?: "Mutation";
  requestSessionCoachGeneration: {
    __typename?: "SessionCoachGQL";
    state: SessionCoachStateEnum;
    agentGeneration?: {
      __typename?: "SessionCoachGenerationGQL";
      id: string;
      state: SessionCoachGenerationStateEnum;
      createdAt: any;
      completedAt?: any | null;
      decision?: {
        __typename?: "SessionCoachDecisionGQL";
        selectedCandidateId?: string | null;
        title?: string | null;
        body?: string | null;
        suggestedAction?: string | null;
        drillId?: string | null;
        drillReason?: string | null;
        practiceAttemptCount?: number | null;
        practiceTarget?: string | null;
      } | null;
      diagnostics?: {
        __typename?: "SessionCoachGenerationDiagnosticsGQL";
        analysisVersion: string;
        promptVersion: string;
        providerKey: string;
        modelName: string;
        inputHash: string;
        attemptCount: number;
        maxAttempts: number;
        enqueueCount: number;
        latencyMs?: number | null;
        inputTokens?: number | null;
        cachedInputTokens?: number | null;
        outputTokens?: number | null;
        failureCode?: string | null;
        updatedAt: any;
        startedAt?: any | null;
        lastEnqueuedAt?: any | null;
        abstentionReason?: string | null;
      } | null;
    } | null;
  };
};

export type SessionCoachCandidateFieldsFragment = {
  __typename?: "SessionCoachCandidateGQL";
  id: string;
  rank: number;
  family: SessionCoachCandidateFamilyEnum;
  kind: SessionCoachCandidateKindEnum;
  title: string;
  body: string;
  action: string;
  supportingShotIds: Array<number>;
  drillId?: string | null;
  limitations: Array<string>;
  evidence: {
    __typename?: "SessionCoachEvidenceGQL";
    bucketKey: string;
    bucketLabel: string;
    attemptCount: number;
    madeCount: number;
    missedCount: number;
    makePercentage: number;
    comparisonAttemptCount: number;
    comparisonMadeCount: number;
    comparisonMakePercentage?: number | null;
    patternShotCount: number;
    score: number;
    rankReason: string;
  };
};

export type SessionCoachGenerationFieldsFragment = {
  __typename?: "SessionCoachGenerationGQL";
  id: string;
  state: SessionCoachGenerationStateEnum;
  createdAt: any;
  completedAt?: any | null;
  decision?: {
    __typename?: "SessionCoachDecisionGQL";
    selectedCandidateId?: string | null;
    title?: string | null;
    body?: string | null;
    suggestedAction?: string | null;
    drillId?: string | null;
    drillReason?: string | null;
    practiceAttemptCount?: number | null;
    practiceTarget?: string | null;
  } | null;
  diagnostics?: {
    __typename?: "SessionCoachGenerationDiagnosticsGQL";
    analysisVersion: string;
    promptVersion: string;
    providerKey: string;
    modelName: string;
    inputHash: string;
    attemptCount: number;
    maxAttempts: number;
    enqueueCount: number;
    latencyMs?: number | null;
    inputTokens?: number | null;
    cachedInputTokens?: number | null;
    outputTokens?: number | null;
    failureCode?: string | null;
    updatedAt: any;
    startedAt?: any | null;
    lastEnqueuedAt?: any | null;
    abstentionReason?: string | null;
  } | null;
};

export type PlayerSummaryFieldsFragment = {
  __typename?: "PlayerSummaryGQL";
  clusterId: number;
  userId?: number | null;
  username?: string | null;
  profileImageUri?: string | null;
  representativeFullFrameUrl?: string | null;
  totalShots: number;
  totalShotsMade: number;
  makePercentage: number;
  score?: number | null;
  longestRun: number;
  runLengths: Array<number>;
  averageDifficulty?: number | null;
  averageTimeBetweenShots?: number | null;
  spinTypeBreakdown: {
    __typename?: "SpinTypeBreakdownGQL";
    draw: number;
    center: number;
    follow: number;
  };
};

export type PlayerClusterShotFieldsFragment = {
  __typename?: "PlayerClusterShotGQL";
  shotId: number;
  bboxX1: number;
  bboxY1: number;
  bboxX2: number;
  bboxY2: number;
  confidence: number;
  isConfirmed: boolean;
  cropUrl?: string | null;
  fullFrameUrl?: string | null;
};

export type PlayerClusterFieldsFragment = {
  __typename?: "PlayerClusterGQL";
  videoId: number;
  clusterId: number;
  nShots: number;
  userId?: number | null;
  username?: string | null;
  profileImageUri?: string | null;
  confirmed: boolean;
  score?: number | null;
  shots: Array<{
    __typename?: "PlayerClusterShotGQL";
    shotId: number;
    bboxX1: number;
    bboxY1: number;
    bboxX2: number;
    bboxY2: number;
    confidence: number;
    isConfirmed: boolean;
    cropUrl?: string | null;
    fullFrameUrl?: string | null;
  }>;
};

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

export type VideoPlayerClustersQuery = {
  __typename?: "Query";
  videoPlayerClusters: Array<{
    __typename?: "PlayerClusterGQL";
    videoId: number;
    clusterId: number;
    nShots: number;
    userId?: number | null;
    username?: string | null;
    profileImageUri?: string | null;
    confirmed: boolean;
    score?: number | null;
    shots: Array<{
      __typename?: "PlayerClusterShotGQL";
      shotId: number;
      bboxX1: number;
      bboxY1: number;
      bboxX2: number;
      bboxY2: number;
      confidence: number;
      isConfirmed: boolean;
      cropUrl?: string | null;
      fullFrameUrl?: string | null;
    }>;
  }>;
};

export type FinalizePlayerAssignmentsMutationVariables = Exact<{
  input: FinalizePlayerAssignmentsInput;
}>;

export type FinalizePlayerAssignmentsMutation = {
  __typename?: "Mutation";
  finalizePlayerAssignments: Array<{
    __typename?: "PlayerClusterGQL";
    videoId: number;
    clusterId: number;
    nShots: number;
    userId?: number | null;
    username?: string | null;
    profileImageUri?: string | null;
    confirmed: boolean;
    score?: number | null;
    shots: Array<{
      __typename?: "PlayerClusterShotGQL";
      shotId: number;
      bboxX1: number;
      bboxY1: number;
      bboxX2: number;
      bboxY2: number;
      confidence: number;
      isConfirmed: boolean;
      cropUrl?: string | null;
      fullFrameUrl?: string | null;
    }>;
  }>;
};

export type GetTableStateQueryVariables = Exact<{
  b64Image: Scalars["String"]["input"];
  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
  useHomography?: InputMaybe<HomographyInputGql>;
}>;

export type GetTableStateQuery = {
  __typename?: "Query";
  getTableState: {
    __typename?: "TableStateGQL";
    identifierToPosition: Array<Array<number>>;
    identifierToColor: Array<{
      __typename?: "RGBColorGQL";
      hex: string;
    } | null>;
  };
};

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

export type GetLiveTableStateQuery = {
  __typename?: "Query";
  getLiveTableState: {
    __typename?: "LiveTableStateGQL";
    videoId: number;
    frameIndex: number;
    tableState: {
      __typename?: "TableStateGQL";
      identifierToPosition: Array<Array<number>>;
      identifierToColor: Array<{
        __typename?: "RGBColorGQL";
        hex: string;
      } | null>;
    };
  };
};

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

export type GetShotTableStateQuery = {
  __typename?: "Query";
  getShotTableState: {
    __typename?: "ShotTableStateGQL";
    shotId: number;
    videoId: number;
    frameIndex: number;
    tableState: {
      __typename?: "TableStateGQL";
      identifierToPosition: Array<Array<number>>;
      identifierToColor: Array<{
        __typename?: "RGBColorGQL";
        hex: string;
      } | null>;
    };
  };
};

export type SimulateShotQueryVariables = Exact<{
  simulationInput: SimulateShotInputGql;
}>;

export type SimulateShotQuery = {
  __typename?: "Query";
  simulateShot: {
    __typename?: "ShotProjectionGQL";
    pottedBallIds: Array<number>;
    trajectories: Array<{
      __typename?: "BallTrajectoryGQL";
      ballId: number;
      points: Array<{
        __typename?: "TrajectoryPointGQL";
        time: number;
        position: Array<number>;
      }>;
    }>;
    events: Array<{
      __typename?: "SimulationEventGQL";
      eventType: SimulationEventType;
      time: number;
      ballIds: Array<number>;
      position?: Array<number> | null;
    }>;
    finalState: Array<{
      __typename?: "SimulationBallStateGQL";
      ballId: number;
      position: Array<number>;
    }>;
  };
};

export type ComputePotAimQueryVariables = Exact<{
  simulationInput: SimulateShotInputGql;
  targetBallId: Scalars["Int"]["input"];
  pocket: PocketIdentifier;
}>;

export type ComputePotAimQuery = {
  __typename?: "Query";
  computePotAim: {
    __typename?: "PotAimGQL";
    phi: number;
    geometricPhi: number;
    cutAngle: number;
    requiredPrecision: number;
    feasible: boolean;
    potted: boolean;
    converged: boolean;
    occludingBallIds: Array<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;
      startSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      endSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      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;
        difficulty?: number | 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;
        };
      }>;
      video?: {
        __typename?: "VideoGQL";
        id: number;
        stream?: {
          __typename?: "UploadStreamGQL";
          id: string;
          streamSegmentType: StreamSegmentTypeEnum;
        } | null;
        playlist?: {
          __typename?: "HLSPlaylistGQL";
          videoId: number;
          segmentDurations: Array<number>;
        } | null;
      } | null;
    }>;
  };
};

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;
      startSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      endSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      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;
        difficulty?: number | 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;
        };
      }>;
      video?: {
        __typename?: "VideoGQL";
        id: number;
        stream?: {
          __typename?: "UploadStreamGQL";
          id: string;
          streamSegmentType: StreamSegmentTypeEnum;
        } | null;
        playlist?: {
          __typename?: "HLSPlaylistGQL";
          videoId: number;
          segmentDurations: Array<number>;
        } | null;
      } | null;
    }>;
  };
};

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;
    startSegment: { __typename?: "SegmentInfo"; index: number; time: number };
    endSegment: { __typename?: "SegmentInfo"; index: number; time: number };
    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;
      difficulty?: number | 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 };
    }>;
    video?: {
      __typename?: "VideoGQL";
      id: number;
      stream?: {
        __typename?: "UploadStreamGQL";
        id: string;
        streamSegmentType: StreamSegmentTypeEnum;
      } | null;
      playlist?: {
        __typename?: "HLSPlaylistGQL";
        videoId: number;
        segmentDurations: Array<number>;
      } | null;
    } | null;
  }>;
};

export type ShotClipRangeFragment = {
  __typename?: "ShotGQL";
  id: number;
  videoId: number;
  startFrame: number;
  endFrame: number;
  startTime: number;
  endTime: number;
};

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

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

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;
  startSegment: { __typename?: "SegmentInfo"; index: number; time: number };
  endSegment: { __typename?: "SegmentInfo"; index: number; time: number };
  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;
    difficulty?: number | 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 };
  }>;
  video?: {
    __typename?: "VideoGQL";
    id: number;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      streamSegmentType: StreamSegmentTypeEnum;
    } | null;
    playlist?: {
      __typename?: "HLSPlaylistGQL";
      videoId: number;
      segmentDurations: Array<number>;
    } | null;
  } | null;
};

export type EditShotMutationVariables = Exact<{
  shotId: Scalars["Int"]["input"];
  fieldsToEdit: EditableShotFieldInputGql;
}>;

export type EditShotMutation = {
  __typename?: "Mutation";
  editShot: {
    __typename?: "EditShotReturn";
    error?: {
      __typename?: "DoesNotOwnShotErr";
      shotId: number;
      msg?: string | null;
    } | null;
    shot?: {
      __typename?: "ShotGQL";
      id: number;
      videoId: number;
      startFrame: number;
      endFrame: number;
      startTime: number;
      endTime: number;
      falsePositiveScore?: number | null;
      createdAt?: any | null;
      updatedAt?: any | null;
      startSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      endSegment: { __typename?: "SegmentInfo"; index: number; time: number };
      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;
        difficulty?: number | 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;
        };
      }>;
      video?: {
        __typename?: "VideoGQL";
        id: number;
        stream?: {
          __typename?: "UploadStreamGQL";
          id: string;
          streamSegmentType: StreamSegmentTypeEnum;
        } | null;
        playlist?: {
          __typename?: "HLSPlaylistGQL";
          videoId: number;
          segmentDurations: Array<number>;
        } | null;
      } | null;
    } | null;
  };
};

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

export type RetireTagsMutation = {
  __typename?: "Mutation";
  retireTags: boolean;
};

export type DeleteTagsMutationVariables = Exact<{
  videoId: Scalars["Int"]["input"];
  tagsToDelete: Array<VideoTagInput> | VideoTagInput;
}>;

export type DeleteTagsMutation = {
  __typename?: "Mutation";
  deleteTags: boolean;
};

export type GetUsageStatsQueryVariables = Exact<{
  days?: Scalars["Int"]["input"];
}>;

export type GetUsageStatsQuery = {
  __typename?: "Query";
  getUsageStats: {
    __typename?: "UsageStatsGQL";
    totalUsers: number;
    totalVideos: number;
    totalShots: number;
    totalRuns: number;
    funnel: {
      __typename?: "FunnelStatsGQL";
      freemiumEpoch: any;
      eraSignups: number;
      eraPaying: number;
      activationCohort: number;
      activationActivated: number;
      payingUsers: number;
      pastDueUsers: number;
      newPaidToday: number;
      newPaid7d: number;
      newPaid30d: number;
      retentionPrevActive: number;
      retentionReturned: number;
    };
    cohorts: Array<{
      __typename?: "CohortStatsGQL";
      weekStart: any;
      signups: number;
      activated7d: number;
      paid7d: number;
      activatedNotPaid7d: number;
      paidTotal: number;
    }>;
    windows: Array<{
      __typename?: "UsageStatsWindowGQL";
      label: string;
      newUsers: number;
      activeUsers: number;
      sessions: number;
      shots: number;
    }>;
    daily: Array<{
      __typename?: "UsageStatsDailyGQL";
      day: any;
      newUsers: number;
      activeUsers: number;
      sessions: number;
      shots: number;
    }>;
    processingLast24h: Array<{
      __typename?: "ProcessingStatusCountGQL";
      status: string;
      count: number;
    }>;
  };
};

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;
    isAdmin?: boolean | null;
    profileImageUri?: string | null;
    bio?: string | null;
    fargoRating?: number | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
    agreesToMarketing?: boolean | 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;
    bio?: string | null;
    fargoRating?: number | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
    agreesToMarketing?: boolean | null;
  } | null;
};

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

export type GetUserQuery = {
  __typename?: "Query";
  getUser?: {
    __typename?: "UserGQL";
    id: number;
    firebaseUid?: string | null;
    username: string;
    isAdmin?: boolean | null;
    profileImageUri?: string | null;
    bio?: string | null;
    fargoRating?: number | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
    agreesToMarketing?: boolean | null;
    following?: Array<{ __typename?: "UserGQL"; id: number }> | null;
    followers?: Array<{ __typename?: "UserGQL"; id: number }> | 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 GetUploadQuotaStatusQueryVariables = Exact<{
  [key: string]: never;
}>;

export type GetUploadQuotaStatusQuery = {
  __typename?: "Query";
  getQuotaStatus: {
    __typename?: "QuotaStatusGQL";
    tierName: string;
    periodStart: any;
    periodEnd: any;
    durationUsedSeconds: number;
    durationLimitSeconds?: number | null;
    maxVideoDurationSeconds?: number | null;
    durationRemainingSeconds?: number | null;
    canUpload: boolean;
    importQuotaBuckets: Array<{
      __typename?: "QuotaBucketStatusGQL";
      quotaKey: string;
      appliesToUploadKind: string;
      periodStart: any;
      periodEnd: any;
      durationUsedSeconds: number;
      durationLimitSeconds?: number | null;
      durationRemainingSeconds?: number | null;
      canUpload: boolean;
    }>;
    recordingQuotaBuckets: Array<{
      __typename?: "QuotaBucketStatusGQL";
      quotaKey: string;
      appliesToUploadKind: string;
      periodStart: any;
      periodEnd: any;
      durationUsedSeconds: number;
      durationLimitSeconds?: number | null;
      durationRemainingSeconds?: number | null;
      canUpload: boolean;
    }>;
  };
};

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;
        profileImageUri?: string | null;
        id: number;
      };
    }>;
  };
};

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

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

export type GetGameTypeTagMetricsQueryVariables = Exact<{
  input: GameTypeTagMetricsInput;
}>;

export type GetGameTypeTagMetricsQuery = {
  __typename?: "Query";
  getGameTypeTagMetrics: Array<{
    __typename?: "GameTypeTagMetric";
    tagName: string;
    tagLabel: string;
    tableSize?: number | null;
    shotCount: number;
    madeShots: number;
    makeRate: number;
  }>;
};

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

export type FollowUserMutation = {
  __typename?: "Mutation";
  followUser: { __typename?: "UserGQL"; id: number; username: string };
};

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

export type UnfollowUserMutation = {
  __typename?: "Mutation";
  unfollowUser: { __typename?: "UserGQL"; id: number; username: string };
};

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;
      profileImageUri?: string | null;
      isFollowedByCurrentUser?: boolean | null;
    }> | null;
    followers?: Array<{
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
      isFollowedByCurrentUser?: boolean | null;
    }> | 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"]>;
  agreesToMarketing?: InputMaybe<Scalars["Boolean"]["input"]>;
  bio?: InputMaybe<Scalars["String"]["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;
    agreesToMarketing?: boolean | null;
    bio?: string | null;
  };
};

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

export type DeleteUserMutation = {
  __typename?: "Mutation";
  deleteUser: boolean;
};

export type UserFragmentFragment = {
  __typename?: "UserGQL";
  id: number;
  firebaseUid?: string | null;
  username: string;
  isAdmin?: boolean | null;
  profileImageUri?: string | null;
  bio?: string | null;
  fargoRating?: number | null;
  activeVideoId?: number | null;
  createdAt?: any | null;
  updatedAt?: any | null;
  videosPrivateByDefault?: boolean | null;
  agreesToMarketing?: boolean | null;
};

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

export type GetUsersMatchingQuery = {
  __typename?: "Query";
  getUsersMatching: Array<{
    __typename?: "UserGQL";
    id: number;
    firebaseUid?: string | null;
    username: string;
    isAdmin?: boolean | null;
    profileImageUri?: string | null;
    bio?: string | null;
    fargoRating?: number | null;
    activeVideoId?: number | null;
    createdAt?: any | null;
    updatedAt?: any | null;
    videosPrivateByDefault?: boolean | null;
    agreesToMarketing?: 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";
      id?: number | null;
      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;
      lowestUnuploadedSegmentIndex: number;
      uploadsCompleted: number;
      segmentProcessingCursor: number;
      isCompleted: boolean;
      uploadCompletionCursor: number;
      lastIntendedSegmentBound?: number | null;
      initPlaylistUploadStatus?: InitPlaylistUploadStatusEnum | null;
    } | null;
    currentProcessing?: {
      __typename?: "VideoProcessingGQL";
      id: number;
      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;
    pocketSize?: number | null;
    private: boolean;
    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;
    averageDifficulty?: number | null;
    startTime?: any | null;
    totalShots: number;
    totalShotsMade: number;
    createdAt?: any | null;
    updatedAt?: any | null;
    tableSize: number;
    pocketSize?: number | null;
    private: boolean;
    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 }>;
    }>;
    playerSummaries: Array<{
      __typename?: "PlayerSummaryGQL";
      clusterId: number;
      userId?: number | null;
      username?: string | null;
      profileImageUri?: string | null;
      representativeFullFrameUrl?: string | null;
      totalShots: number;
      totalShotsMade: number;
      makePercentage: number;
      score?: number | null;
      longestRun: number;
      runLengths: Array<number>;
      averageDifficulty?: number | null;
      averageTimeBetweenShots?: number | null;
      spinTypeBreakdown: {
        __typename?: "SpinTypeBreakdownGQL";
        draw: number;
        center: number;
        follow: number;
      };
    }>;
  };
};

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

export type GetVideoSocialDetailsByIdQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    screenshotUri?: string | null;
    makePercentage: number;
    totalShots: 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 }>;
    }>;
    reactions: Array<{
      __typename?: "ReactionGQL";
      videoId: number;
      reaction: ReactionEnum;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
        isFollowedByCurrentUser?: boolean | null;
      };
    }>;
    comments: Array<{
      __typename?: "CommentGQL";
      id: number;
      message: string;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
        isFollowedByCurrentUser?: boolean | null;
      };
      replies: Array<{
        __typename?: "CommentGQL";
        id: number;
        message: string;
        replyToCommentId?: number | null;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
      }>;
    }>;
  };
};

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

export type GetVideoCardQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    screenshotUri?: string | null;
    totalShots: number;
    makePercentage: number;
    averageTimeBetweenShots?: number | null;
    averageDifficulty?: number | null;
    startTime?: any | null;
    private: boolean;
    elapsedTime?: number | null;
    tableSize: number;
    pocketSize?: number | null;
    owner?: {
      __typename?: "UserGQL";
      id: number;
      username: string;
      profileImageUri?: string | null;
    } | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      lastIntendedSegmentBound?: number | null;
      uploadCompletionCursor: number;
      streamSegmentType: StreamSegmentTypeEnum;
      isCompleted: boolean;
      lastSegmentUploadedAt?: any | null;
      clientUploadStatus?: ClientUploadStatusEnum | null;
    } | null;
    tags: Array<{
      __typename?: "VideoTag";
      name: string;
      tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
    }>;
    playerSummaries: Array<{
      __typename?: "PlayerSummaryGQL";
      clusterId: number;
      userId?: number | null;
      username?: string | null;
      profileImageUri?: string | null;
      representativeFullFrameUrl?: string | null;
      totalShots: number;
      totalShotsMade: number;
      makePercentage: number;
      score?: number | null;
      longestRun: number;
      runLengths: Array<number>;
      averageDifficulty?: number | null;
      averageTimeBetweenShots?: number | null;
      spinTypeBreakdown: {
        __typename?: "SpinTypeBreakdownGQL";
        draw: number;
        center: number;
        follow: number;
      };
    }>;
    currentProcessing?: {
      __typename?: "VideoProcessingGQL";
      id: number;
      status: ProcessingStatusEnum;
    } | null;
    reactions: Array<{
      __typename?: "ReactionGQL";
      videoId: number;
      reaction: ReactionEnum;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
        isFollowedByCurrentUser?: boolean | null;
      };
    }>;
    comments: Array<{
      __typename?: "CommentGQL";
      id: number;
      message: string;
      user: {
        __typename?: "UserGQL";
        id: number;
        username: string;
        profileImageUri?: string | null;
        isFollowedByCurrentUser?: boolean | null;
      };
      replies: Array<{
        __typename?: "CommentGQL";
        id: number;
        message: string;
        replyToCommentId?: number | null;
        user: {
          __typename?: "UserGQL";
          id: number;
          username: string;
          profileImageUri?: string | null;
          isFollowedByCurrentUser?: boolean | null;
        };
      }>;
    }>;
  };
};

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 | null;
    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 | null;
  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 | null;
    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";
      id?: number | null;
      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 GetAverageDifficultyForVideoQueryVariables = Exact<{
  videoId: Scalars["Int"]["input"];
}>;

export type GetAverageDifficultyForVideoQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    averageDifficulty?: 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 | null;
  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 | null;
    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 GetBannerInfoByVideoIdQueryVariables = Exact<{
  videoId: Scalars["Int"]["input"];
}>;

export type GetBannerInfoByVideoIdQuery = {
  __typename?: "Query";
  getVideo: {
    __typename?: "VideoGQL";
    id: number;
    name?: string | null;
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      lastIntendedSegmentBound?: number | null;
    } | null;
    owner?: { __typename?: "UserGQL"; id: number } | null;
    currentProcessing?: {
      __typename?: "VideoProcessingGQL";
      id: number;
      status: ProcessingStatusEnum;
    } | null;
  };
};

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

export type FindPrerecordTableLayoutMutation = {
  __typename?: "Mutation";
  findPrerecordTableLayout?: {
    __typename?: "HomographyInfoGQL";
    id?: number | null;
    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";
  id?: number | null;
  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 VideoExportJobFieldsFragment = {
  __typename?: "VideoExportJobGQL";
  id: number;
  videoId: number;
  mode: VideoExportModeEnum;
  status: VideoExportStatusEnum;
  videoName?: string | null;
  videoThumbnailUri?: string | null;
  shotIds?: Array<number> | null;
  runId?: number | null;
  downloadUrl?: string | null;
  fileSizeBytes?: number | null;
  expiresAt?: any | null;
  createdAt?: any | null;
};

export type RequestVideoExportMutationVariables = Exact<{
  input: RequestVideoExportInput;
}>;

export type RequestVideoExportMutation = {
  __typename?: "Mutation";
  requestVideoExport: {
    __typename?: "VideoExportJobGQL";
    id: number;
    videoId: number;
    mode: VideoExportModeEnum;
    status: VideoExportStatusEnum;
    videoName?: string | null;
    videoThumbnailUri?: string | null;
    shotIds?: Array<number> | null;
    runId?: number | null;
    downloadUrl?: string | null;
    fileSizeBytes?: number | null;
    expiresAt?: any | null;
    createdAt?: any | null;
  };
};

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

export type DismissVideoExportMutation = {
  __typename?: "Mutation";
  dismissVideoExport: boolean;
};

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

export type VideoExportJobQuery = {
  __typename?: "Query";
  videoExportJob?: {
    __typename?: "VideoExportJobGQL";
    id: number;
    videoId: number;
    mode: VideoExportModeEnum;
    status: VideoExportStatusEnum;
    videoName?: string | null;
    videoThumbnailUri?: string | null;
    shotIds?: Array<number> | null;
    runId?: number | null;
    downloadUrl?: string | null;
    fileSizeBytes?: number | null;
    expiresAt?: any | null;
    createdAt?: any | null;
  } | null;
};

export type MyVideoExportsQueryVariables = Exact<{
  limit?: InputMaybe<Scalars["Int"]["input"]>;
  offset?: InputMaybe<Scalars["Int"]["input"]>;
}>;

export type MyVideoExportsQuery = {
  __typename?: "Query";
  myVideoExports: Array<{
    __typename?: "VideoExportJobGQL";
    id: number;
    videoId: number;
    mode: VideoExportModeEnum;
    status: VideoExportStatusEnum;
    videoName?: string | null;
    videoThumbnailUri?: string | null;
    shotIds?: Array<number> | null;
    runId?: number | null;
    downloadUrl?: string | null;
    fileSizeBytes?: number | null;
    expiresAt?: any | null;
    createdAt?: any | null;
  }>;
};

export type CreateUploadStreamMutationVariables = Exact<{
  videoMetadataInput: VideoMetadataInput;
  expectedDurationSeconds?: InputMaybe<Scalars["Float"]["input"]>;
}>;

export type CreateUploadStreamMutation = {
  __typename?: "Mutation";
  createUploadStream: {
    __typename?: "CreateUploadStreamReturn";
    videoId: number;
  };
};

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

export type GetUploadLinkMutation = {
  __typename?: "Mutation";
  getUploadLink: {
    __typename?: "GetUploadLinkReturn";
    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?: "StorageLimitExceededErr";
                reason: string;
                tierName: string;
                retainedStorageUsedBytes: any;
                retainedStorageLimitBytes?: any | null;
                remainingStorageBytes?: any | null;
              }
            | { __typename?: "TooManyInitUploadsErr" }
            | { __typename?: "TooManyProfileImageUploadsErr" };
        }
      | {
          __typename?: "UploadLink";
          uploadUrl: string;
          headers: Array<{
            __typename?: "Header";
            key: string;
            value: string;
          } | null>;
        };
    stream?: {
      __typename?: "UploadStreamGQL";
      id: string;
      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?: "StorageLimitExceededErr";
                reason: string;
                tierName: string;
                retainedStorageUsedBytes: any;
                retainedStorageLimitBytes?: any | null;
                remainingStorageBytes?: any | null;
              }
            | { __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 UploadStreamWithDetailsFragment = {
  __typename?: "VideoGQL";
  id: number;
  name?: string | null;
  startTime?: any | null;
  stream?: {
    __typename?: "UploadStreamGQL";
    id: string;
    isCompleted: boolean;
    lastIntendedSegmentBound?: number | null;
    uploadCompletionCursor: number;
    uploadsCompleted: number;
  } | 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";
        id: string;
        isCompleted: boolean;
        lastIntendedSegmentBound?: number | null;
        uploadCompletionCursor: number;
        uploadsCompleted: number;
      } | null;
    }>;
    pageInfo: {
      __typename?: "PageInfoGQL";
      hasNextPage: boolean;
      endCursor?: string | null;
    };
  };
};

export const PlayerSummaryFieldsFragmentDoc = gql`
  fragment PlayerSummaryFields on PlayerSummaryGQL {
    clusterId
    userId
    username
    profileImageUri
    representativeFullFrameUrl
    totalShots
    totalShotsMade
    makePercentage
    score
    longestRun
    runLengths
    spinTypeBreakdown {
      draw
      center
      follow
    }
    averageDifficulty
    averageTimeBetweenShots
  }
`;
export const UserSocialsFieldsFragmentDoc = gql`
  fragment UserSocialsFields on UserGQL {
    id
    username
    profileImageUri
    isFollowedByCurrentUser
  }
`;
export const VideoCardFieldsFragmentDoc = gql`
  fragment VideoCardFields on VideoGQL {
    id
    owner {
      id
      username
      profileImageUri
    }
    name
    screenshotUri
    totalShots
    makePercentage
    averageTimeBetweenShots
    averageDifficulty
    startTime
    private
    elapsedTime
    stream {
      id
      lastIntendedSegmentBound
      uploadCompletionCursor
      streamSegmentType
      isCompleted
      lastSegmentUploadedAt
      clientUploadStatus
    }
    tableSize
    pocketSize
    tags {
      name
      tagClasses {
        name
      }
    }
    playerSummaries {
      ...PlayerSummaryFields
    }
    currentProcessing {
      id
      status
    }
    reactions {
      videoId
      user {
        ...UserSocialsFields
      }
      reaction
    }
    comments {
      id
      message
      user {
        ...UserSocialsFields
      }
      replies {
        id
        message
        replyToCommentId
        user {
          ...UserSocialsFields
        }
      }
    }
  }
  ${PlayerSummaryFieldsFragmentDoc}
  ${UserSocialsFieldsFragmentDoc}
`;
export const MedalFieldsFragmentDoc = gql`
  fragment MedalFields on MedalGQL {
    count
    nickname
  }
`;
export const NotificationFragmentDoc = gql`
  fragment Notification on NotificationGQL {
    id
    notificationType
    actor {
      id
      username
      profileImageUri
    }
    videoId
    challengeId
    challenge {
      id
      name
    }
    comment {
      id
      message
      user {
        id
        username
        profileImageUri
      }
    }
    reactionType
    isRead
    createdAt
    readAt
  }
`;
export const PoolHallCameraFieldsFragmentDoc = gql`
  fragment PoolHallCameraFields on PoolHallCamera {
    id
    poolHallId
    name
    tableLabel
    streamPath
    status
    tableSize
    pocketSize
    allowsPrivateVideos
    claimTermsText
    claimTermsVersion
    inUse
    lastPublishedAt
    lastUnpublishedAt
    createdAt
    updatedAt
  }
`;
export const PoolHallFieldsFragmentDoc = gql`
  fragment PoolHallFields on PoolHall {
    id
    name
    address
    city
    state
    latitude
    longitude
    timezone
    status
    createdAt
    updatedAt
  }
`;
export const PoolHallCameraWithHallFieldsFragmentDoc = gql`
  fragment PoolHallCameraWithHallFields on PoolHallCamera {
    ...PoolHallCameraFields
    poolHall {
      ...PoolHallFields
    }
  }
  ${PoolHallCameraFieldsFragmentDoc}
  ${PoolHallFieldsFragmentDoc}
`;
export const PoolHallCameraStreamCredentialsFieldsFragmentDoc = gql`
  fragment PoolHallCameraStreamCredentialsFields on PoolHallCameraStreamCredentials {
    streamKey
    rtmpPath
    camera {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;
export const CameraClaimSessionFieldsFragmentDoc = gql`
  fragment CameraClaimSessionFields on CameraClaimSession {
    id
    cameraId
    userId
    challengeCode
    status
    expiresAt
    detectedAt
    failedAt
    failureReason
    agreedTermsVersion
    createdAt
    updatedAt
    camera {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;
export const CameraLeaseFieldsFragmentDoc = gql`
  fragment CameraLeaseFields on CameraLease {
    id
    cameraId
    claimSessionId
    userId
    videoId
    status
    startedAt
    endedAt
    expiresAt
    endReason
    createdAt
    updatedAt
    camera {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;
export const PocketingIntentionFragmentFragmentDoc = gql`
  fragment PocketingIntentionFragment on PocketingIntentionFeaturesGQL {
    make
    targetPocketDistance
    targetPocketAngle
    targetPocketAngleDirection
    marginOfErrorInDegrees
    intendedPocketType
    difficulty
  }
`;
export const SessionCoachCandidateFieldsFragmentDoc = gql`
  fragment SessionCoachCandidateFields on SessionCoachCandidateGQL {
    id
    rank
    family
    kind
    title
    body
    action
    supportingShotIds
    drillId
    limitations
    evidence {
      bucketKey
      bucketLabel
      attemptCount
      madeCount
      missedCount
      makePercentage
      comparisonAttemptCount
      comparisonMadeCount
      comparisonMakePercentage
      patternShotCount
      score
      rankReason
    }
  }
`;
export const SessionCoachGenerationFieldsFragmentDoc = gql`
  fragment SessionCoachGenerationFields on SessionCoachGenerationGQL {
    id
    state
    createdAt
    completedAt
    decision {
      selectedCandidateId
      title
      body
      suggestedAction
      drillId
      drillReason
      practiceAttemptCount
      practiceTarget
    }
    diagnostics {
      analysisVersion
      promptVersion
      providerKey
      modelName
      inputHash
      attemptCount
      maxAttempts
      enqueueCount
      latencyMs
      inputTokens
      cachedInputTokens
      outputTokens
      failureCode
      updatedAt
      startedAt
      lastEnqueuedAt
      abstentionReason
    }
  }
`;
export const PlayerClusterShotFieldsFragmentDoc = gql`
  fragment PlayerClusterShotFields on PlayerClusterShotGQL {
    shotId
    bboxX1
    bboxY1
    bboxX2
    bboxY2
    confidence
    isConfirmed
    cropUrl
    fullFrameUrl
  }
`;
export const PlayerClusterFieldsFragmentDoc = gql`
  fragment PlayerClusterFields on PlayerClusterGQL {
    videoId
    clusterId
    nShots
    userId
    username
    profileImageUri
    confirmed
    score
    shots {
      ...PlayerClusterShotFields
    }
  }
  ${PlayerClusterShotFieldsFragmentDoc}
`;
export const ShotClipRangeFragmentDoc = gql`
  fragment ShotClipRange on ShotGQL {
    id
    videoId
    startFrame
    endFrame
    startTime @client
    endTime @client
  }
`;
export const ShotWithAllFeaturesFragmentDoc = gql`
  fragment ShotWithAllFeatures on ShotGQL {
    id
    videoId
    startFrame
    endFrame
    startTime @client
    endTime @client
    startSegment @client {
      index
      time
    }
    endSegment @client {
      index
      time
    }
    user {
      id
    }
    falsePositiveScore
    createdAt
    updatedAt
    cueObjectFeatures {
      cueObjectDistance
      cueObjectAngle
      cueBallSpeed
      shotDirection
      spinType
    }
    pocketingIntentionFeatures {
      make
      targetPocketDistance
      targetPocketAngle
      targetPocketAngleDirection
      marginOfErrorInDegrees
      intendedPocketType
      difficulty
    }
    pocketingIntentionInfo {
      ballId
      pocketId
      pathMetadataIndex
    }
    serializedShotPaths {
      b64EncodedBuffer
    }
    annotations {
      shotId
      type {
        id
        name
      }
      notes
    }
    video {
      id
      stream {
        id
        streamSegmentType
      }
      playlist {
        videoId
        segmentDurations
      }
    }
  }
`;
export const UserFragmentFragmentDoc = gql`
  fragment UserFragment on UserGQL {
    id
    firebaseUid
    username
    isAdmin
    profileImageUri
    bio
    fargoRating
    activeVideoId
    createdAt
    updatedAt
    videosPrivateByDefault
    agreesToMarketing
  }
`;
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 {
    id
    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 VideoExportJobFieldsFragmentDoc = gql`
  fragment VideoExportJobFields on VideoExportJobGQL {
    id
    videoId
    mode
    status
    videoName
    videoThumbnailUri
    shotIds
    runId
    downloadUrl
    fileSizeBytes
    expiresAt
    createdAt
  }
`;
export const UploadStreamWithDetailsFragmentDoc = gql`
  fragment UploadStreamWithDetails on VideoGQL {
    id
    name
    startTime
    stream {
      id
      isCompleted
      lastIntendedSegmentBound
      uploadCompletionCursor
      uploadsCompleted
    }
  }
`;
export const GetAggregatedShotMetricsDocument = gql`
  query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
    getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
      aggregationIdentifiers {
        featureName
        groupName
      }
      targetMetrics {
        count
        makePercentage
        averageDifficulty
      }
    }
  }
`;

/**
 * __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 GetChallengesDocument = gql`
  query GetChallenges {
    challenges {
      id
      name
      description
      minimumShots
      startDate
      endDate
      createdAt
      updatedAt
      requiredTableSize
      requiredPocketSize
      isPublic
      maxAttempts
      ruleSet {
        id
        name
        description
      }
      createdBy {
        id
        username
        profileImageUri
      }
    }
  }
`;

/**
 * __useGetChallengesQuery__
 *
 * To run a query within a React component, call `useGetChallengesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetChallengesQuery` 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 } = useGetChallengesQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetChallengesQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetChallengesQuery,
    GetChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetChallengesQuery, GetChallengesQueryVariables>(
    GetChallengesDocument,
    options,
  );
}
export function useGetChallengesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetChallengesQuery,
    GetChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetChallengesQuery, GetChallengesQueryVariables>(
    GetChallengesDocument,
    options,
  );
}
export function useGetChallengesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetChallengesQuery,
    GetChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetChallengesQuery,
    GetChallengesQueryVariables
  >(GetChallengesDocument, options);
}
export type GetChallengesQueryHookResult = ReturnType<
  typeof useGetChallengesQuery
>;
export type GetChallengesLazyQueryHookResult = ReturnType<
  typeof useGetChallengesLazyQuery
>;
export type GetChallengesSuspenseQueryHookResult = ReturnType<
  typeof useGetChallengesSuspenseQuery
>;
export type GetChallengesQueryResult = Apollo.QueryResult<
  GetChallengesQuery,
  GetChallengesQueryVariables
>;
export const GetMyDismissedChallengesDocument = gql`
  query GetMyDismissedChallenges {
    myDismissedChallenges {
      id
      name
      description
      minimumShots
      startDate
      endDate
      createdAt
      updatedAt
      requiredTableSize
      requiredPocketSize
      isPublic
      maxAttempts
      ruleSet {
        id
        name
        description
      }
      createdBy {
        id
        username
        profileImageUri
      }
    }
  }
`;

/**
 * __useGetMyDismissedChallengesQuery__
 *
 * To run a query within a React component, call `useGetMyDismissedChallengesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMyDismissedChallengesQuery` 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 } = useGetMyDismissedChallengesQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetMyDismissedChallengesQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >(GetMyDismissedChallengesDocument, options);
}
export function useGetMyDismissedChallengesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >(GetMyDismissedChallengesDocument, options);
}
export function useGetMyDismissedChallengesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMyDismissedChallengesQuery,
    GetMyDismissedChallengesQueryVariables
  >(GetMyDismissedChallengesDocument, options);
}
export type GetMyDismissedChallengesQueryHookResult = ReturnType<
  typeof useGetMyDismissedChallengesQuery
>;
export type GetMyDismissedChallengesLazyQueryHookResult = ReturnType<
  typeof useGetMyDismissedChallengesLazyQuery
>;
export type GetMyDismissedChallengesSuspenseQueryHookResult = ReturnType<
  typeof useGetMyDismissedChallengesSuspenseQuery
>;
export type GetMyDismissedChallengesQueryResult = Apollo.QueryResult<
  GetMyDismissedChallengesQuery,
  GetMyDismissedChallengesQueryVariables
>;
export const GetChallengeDocument = gql`
  query GetChallenge($id: ID!) {
    challenge(id: $id) {
      id
      name
      description
      minimumShots
      startDate
      endDate
      createdAt
      updatedAt
      requiredTableSize
      requiredPocketSize
      isPublic
      maxAttempts
      participantCount
      ruleSet {
        id
        name
        description
      }
      createdBy {
        id
        username
        profileImageUri
      }
      invitations {
        id
        status
        createdAt
        invitee {
          id
          username
          profileImageUri
        }
        inviter {
          id
          username
          profileImageUri
        }
      }
    }
  }
`;

/**
 * __useGetChallengeQuery__
 *
 * To run a query within a React component, call `useGetChallengeQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetChallengeQuery` 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 } = useGetChallengeQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useGetChallengeQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetChallengeQuery,
    GetChallengeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetChallengeQuery, GetChallengeQueryVariables>(
    GetChallengeDocument,
    options,
  );
}
export function useGetChallengeLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetChallengeQuery,
    GetChallengeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetChallengeQuery, GetChallengeQueryVariables>(
    GetChallengeDocument,
    options,
  );
}
export function useGetChallengeSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetChallengeQuery,
    GetChallengeQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetChallengeQuery, GetChallengeQueryVariables>(
    GetChallengeDocument,
    options,
  );
}
export type GetChallengeQueryHookResult = ReturnType<
  typeof useGetChallengeQuery
>;
export type GetChallengeLazyQueryHookResult = ReturnType<
  typeof useGetChallengeLazyQuery
>;
export type GetChallengeSuspenseQueryHookResult = ReturnType<
  typeof useGetChallengeSuspenseQuery
>;
export type GetChallengeQueryResult = Apollo.QueryResult<
  GetChallengeQuery,
  GetChallengeQueryVariables
>;
export const GetRuleSetsDocument = gql`
  query GetRuleSets {
    ruleSets {
      id
      name
      description
    }
  }
`;

/**
 * __useGetRuleSetsQuery__
 *
 * To run a query within a React component, call `useGetRuleSetsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRuleSetsQuery` 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 } = useGetRuleSetsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetRuleSetsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetRuleSetsQuery,
    GetRuleSetsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetRuleSetsQuery, GetRuleSetsQueryVariables>(
    GetRuleSetsDocument,
    options,
  );
}
export function useGetRuleSetsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRuleSetsQuery,
    GetRuleSetsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetRuleSetsQuery, GetRuleSetsQueryVariables>(
    GetRuleSetsDocument,
    options,
  );
}
export function useGetRuleSetsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRuleSetsQuery,
    GetRuleSetsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetRuleSetsQuery, GetRuleSetsQueryVariables>(
    GetRuleSetsDocument,
    options,
  );
}
export type GetRuleSetsQueryHookResult = ReturnType<typeof useGetRuleSetsQuery>;
export type GetRuleSetsLazyQueryHookResult = ReturnType<
  typeof useGetRuleSetsLazyQuery
>;
export type GetRuleSetsSuspenseQueryHookResult = ReturnType<
  typeof useGetRuleSetsSuspenseQuery
>;
export type GetRuleSetsQueryResult = Apollo.QueryResult<
  GetRuleSetsQuery,
  GetRuleSetsQueryVariables
>;
export const GetChallengeLeaderboardDocument = gql`
  query GetChallengeLeaderboard($challengeId: ID!, $limit: Int) {
    challengeLeaderboard(challengeId: $challengeId, limit: $limit) {
      id
      status
      shotsCount
      makesCount
      makeRate
      qualified
      createdAt
      attemptCount
      user {
        id
        username
        profileImageUri
      }
      video {
        id
        createdAt
      }
    }
  }
`;

/**
 * __useGetChallengeLeaderboardQuery__
 *
 * To run a query within a React component, call `useGetChallengeLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetChallengeLeaderboardQuery` 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 } = useGetChallengeLeaderboardQuery({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetChallengeLeaderboardQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >(GetChallengeLeaderboardDocument, options);
}
export function useGetChallengeLeaderboardLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >(GetChallengeLeaderboardDocument, options);
}
export function useGetChallengeLeaderboardSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetChallengeLeaderboardQuery,
    GetChallengeLeaderboardQueryVariables
  >(GetChallengeLeaderboardDocument, options);
}
export type GetChallengeLeaderboardQueryHookResult = ReturnType<
  typeof useGetChallengeLeaderboardQuery
>;
export type GetChallengeLeaderboardLazyQueryHookResult = ReturnType<
  typeof useGetChallengeLeaderboardLazyQuery
>;
export type GetChallengeLeaderboardSuspenseQueryHookResult = ReturnType<
  typeof useGetChallengeLeaderboardSuspenseQuery
>;
export type GetChallengeLeaderboardQueryResult = Apollo.QueryResult<
  GetChallengeLeaderboardQuery,
  GetChallengeLeaderboardQueryVariables
>;
export const GetMyChallengeInvitationsDocument = gql`
  query GetMyChallengeInvitations {
    myChallengeInvitations {
      id
      status
      createdAt
      challenge {
        id
        name
        description
        startDate
        endDate
        createdBy {
          id
          username
          profileImageUri
        }
      }
      inviter {
        id
        username
        profileImageUri
      }
    }
  }
`;

/**
 * __useGetMyChallengeInvitationsQuery__
 *
 * To run a query within a React component, call `useGetMyChallengeInvitationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMyChallengeInvitationsQuery` 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 } = useGetMyChallengeInvitationsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetMyChallengeInvitationsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >(GetMyChallengeInvitationsDocument, options);
}
export function useGetMyChallengeInvitationsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >(GetMyChallengeInvitationsDocument, options);
}
export function useGetMyChallengeInvitationsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMyChallengeInvitationsQuery,
    GetMyChallengeInvitationsQueryVariables
  >(GetMyChallengeInvitationsDocument, options);
}
export type GetMyChallengeInvitationsQueryHookResult = ReturnType<
  typeof useGetMyChallengeInvitationsQuery
>;
export type GetMyChallengeInvitationsLazyQueryHookResult = ReturnType<
  typeof useGetMyChallengeInvitationsLazyQuery
>;
export type GetMyChallengeInvitationsSuspenseQueryHookResult = ReturnType<
  typeof useGetMyChallengeInvitationsSuspenseQuery
>;
export type GetMyChallengeInvitationsQueryResult = Apollo.QueryResult<
  GetMyChallengeInvitationsQuery,
  GetMyChallengeInvitationsQueryVariables
>;
export const GetMyChallengeEntriesDocument = gql`
  query GetMyChallengeEntries {
    myChallengeEntries {
      id
      status
      shotsCount
      makesCount
      makeRate
      qualified
      createdAt
      challenge {
        id
        name
      }
      video {
        id
      }
    }
  }
`;

/**
 * __useGetMyChallengeEntriesQuery__
 *
 * To run a query within a React component, call `useGetMyChallengeEntriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMyChallengeEntriesQuery` 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 } = useGetMyChallengeEntriesQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetMyChallengeEntriesQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >(GetMyChallengeEntriesDocument, options);
}
export function useGetMyChallengeEntriesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >(GetMyChallengeEntriesDocument, options);
}
export function useGetMyChallengeEntriesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMyChallengeEntriesQuery,
    GetMyChallengeEntriesQueryVariables
  >(GetMyChallengeEntriesDocument, options);
}
export type GetMyChallengeEntriesQueryHookResult = ReturnType<
  typeof useGetMyChallengeEntriesQuery
>;
export type GetMyChallengeEntriesLazyQueryHookResult = ReturnType<
  typeof useGetMyChallengeEntriesLazyQuery
>;
export type GetMyChallengeEntriesSuspenseQueryHookResult = ReturnType<
  typeof useGetMyChallengeEntriesSuspenseQuery
>;
export type GetMyChallengeEntriesQueryResult = Apollo.QueryResult<
  GetMyChallengeEntriesQuery,
  GetMyChallengeEntriesQueryVariables
>;
export const CreateRuleSetDocument = gql`
  mutation CreateRuleSet($name: String!, $description: String) {
    createRuleSet(name: $name, description: $description) {
      id
      name
      description
    }
  }
`;
export type CreateRuleSetMutationFn = Apollo.MutationFunction<
  CreateRuleSetMutation,
  CreateRuleSetMutationVariables
>;

/**
 * __useCreateRuleSetMutation__
 *
 * To run a mutation, you first call `useCreateRuleSetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateRuleSetMutation` 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 [createRuleSetMutation, { data, loading, error }] = useCreateRuleSetMutation({
 *   variables: {
 *      name: // value for 'name'
 *      description: // value for 'description'
 *   },
 * });
 */
export function useCreateRuleSetMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreateRuleSetMutation,
    CreateRuleSetMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreateRuleSetMutation,
    CreateRuleSetMutationVariables
  >(CreateRuleSetDocument, options);
}
export type CreateRuleSetMutationHookResult = ReturnType<
  typeof useCreateRuleSetMutation
>;
export type CreateRuleSetMutationResult =
  Apollo.MutationResult<CreateRuleSetMutation>;
export type CreateRuleSetMutationOptions = Apollo.BaseMutationOptions<
  CreateRuleSetMutation,
  CreateRuleSetMutationVariables
>;
export const CreateChallengeDocument = gql`
  mutation CreateChallenge(
    $name: String!
    $ruleSetId: ID!
    $minimumShots: Int!
    $startDate: DateTime!
    $endDate: DateTime!
    $description: String
    $requiredTableSize: Float
    $requiredPocketSize: Float
    $isPublic: Boolean! = false
    $maxAttempts: Int
  ) {
    createChallenge(
      name: $name
      ruleSetId: $ruleSetId
      minimumShots: $minimumShots
      startDate: $startDate
      endDate: $endDate
      description: $description
      requiredTableSize: $requiredTableSize
      requiredPocketSize: $requiredPocketSize
      isPublic: $isPublic
      maxAttempts: $maxAttempts
    ) {
      id
      name
      description
      requiredTableSize
      requiredPocketSize
      isPublic
      maxAttempts
    }
  }
`;
export type CreateChallengeMutationFn = Apollo.MutationFunction<
  CreateChallengeMutation,
  CreateChallengeMutationVariables
>;

/**
 * __useCreateChallengeMutation__
 *
 * To run a mutation, you first call `useCreateChallengeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateChallengeMutation` 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 [createChallengeMutation, { data, loading, error }] = useCreateChallengeMutation({
 *   variables: {
 *      name: // value for 'name'
 *      ruleSetId: // value for 'ruleSetId'
 *      minimumShots: // value for 'minimumShots'
 *      startDate: // value for 'startDate'
 *      endDate: // value for 'endDate'
 *      description: // value for 'description'
 *      requiredTableSize: // value for 'requiredTableSize'
 *      requiredPocketSize: // value for 'requiredPocketSize'
 *      isPublic: // value for 'isPublic'
 *      maxAttempts: // value for 'maxAttempts'
 *   },
 * });
 */
export function useCreateChallengeMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreateChallengeMutation,
    CreateChallengeMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreateChallengeMutation,
    CreateChallengeMutationVariables
  >(CreateChallengeDocument, options);
}
export type CreateChallengeMutationHookResult = ReturnType<
  typeof useCreateChallengeMutation
>;
export type CreateChallengeMutationResult =
  Apollo.MutationResult<CreateChallengeMutation>;
export type CreateChallengeMutationOptions = Apollo.BaseMutationOptions<
  CreateChallengeMutation,
  CreateChallengeMutationVariables
>;
export const InviteUsersToChallengeDocument = gql`
  mutation InviteUsersToChallenge($challengeId: ID!, $userIds: [ID!]!) {
    inviteUsersToChallenge(challengeId: $challengeId, userIds: $userIds) {
      id
      status
      inviter {
        id
        username
      }
    }
  }
`;
export type InviteUsersToChallengeMutationFn = Apollo.MutationFunction<
  InviteUsersToChallengeMutation,
  InviteUsersToChallengeMutationVariables
>;

/**
 * __useInviteUsersToChallengeMutation__
 *
 * To run a mutation, you first call `useInviteUsersToChallengeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useInviteUsersToChallengeMutation` 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 [inviteUsersToChallengeMutation, { data, loading, error }] = useInviteUsersToChallengeMutation({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *      userIds: // value for 'userIds'
 *   },
 * });
 */
export function useInviteUsersToChallengeMutation(
  baseOptions?: Apollo.MutationHookOptions<
    InviteUsersToChallengeMutation,
    InviteUsersToChallengeMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    InviteUsersToChallengeMutation,
    InviteUsersToChallengeMutationVariables
  >(InviteUsersToChallengeDocument, options);
}
export type InviteUsersToChallengeMutationHookResult = ReturnType<
  typeof useInviteUsersToChallengeMutation
>;
export type InviteUsersToChallengeMutationResult =
  Apollo.MutationResult<InviteUsersToChallengeMutation>;
export type InviteUsersToChallengeMutationOptions = Apollo.BaseMutationOptions<
  InviteUsersToChallengeMutation,
  InviteUsersToChallengeMutationVariables
>;
export const RespondToChallengeInvitationDocument = gql`
  mutation RespondToChallengeInvitation($invitationId: ID!, $accept: Boolean!) {
    respondToChallengeInvitation(invitationId: $invitationId, accept: $accept) {
      id
      status
      challenge {
        id
      }
    }
  }
`;
export type RespondToChallengeInvitationMutationFn = Apollo.MutationFunction<
  RespondToChallengeInvitationMutation,
  RespondToChallengeInvitationMutationVariables
>;

/**
 * __useRespondToChallengeInvitationMutation__
 *
 * To run a mutation, you first call `useRespondToChallengeInvitationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRespondToChallengeInvitationMutation` 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 [respondToChallengeInvitationMutation, { data, loading, error }] = useRespondToChallengeInvitationMutation({
 *   variables: {
 *      invitationId: // value for 'invitationId'
 *      accept: // value for 'accept'
 *   },
 * });
 */
export function useRespondToChallengeInvitationMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RespondToChallengeInvitationMutation,
    RespondToChallengeInvitationMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    RespondToChallengeInvitationMutation,
    RespondToChallengeInvitationMutationVariables
  >(RespondToChallengeInvitationDocument, options);
}
export type RespondToChallengeInvitationMutationHookResult = ReturnType<
  typeof useRespondToChallengeInvitationMutation
>;
export type RespondToChallengeInvitationMutationResult =
  Apollo.MutationResult<RespondToChallengeInvitationMutation>;
export type RespondToChallengeInvitationMutationOptions =
  Apollo.BaseMutationOptions<
    RespondToChallengeInvitationMutation,
    RespondToChallengeInvitationMutationVariables
  >;
export const StartChallengeDocument = gql`
  mutation StartChallenge($challengeId: ID!) {
    startChallenge(challengeId: $challengeId) {
      id
      status
      createdAt
      challenge {
        id
        name
      }
    }
  }
`;
export type StartChallengeMutationFn = Apollo.MutationFunction<
  StartChallengeMutation,
  StartChallengeMutationVariables
>;

/**
 * __useStartChallengeMutation__
 *
 * To run a mutation, you first call `useStartChallengeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStartChallengeMutation` 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 [startChallengeMutation, { data, loading, error }] = useStartChallengeMutation({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *   },
 * });
 */
export function useStartChallengeMutation(
  baseOptions?: Apollo.MutationHookOptions<
    StartChallengeMutation,
    StartChallengeMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    StartChallengeMutation,
    StartChallengeMutationVariables
  >(StartChallengeDocument, options);
}
export type StartChallengeMutationHookResult = ReturnType<
  typeof useStartChallengeMutation
>;
export type StartChallengeMutationResult =
  Apollo.MutationResult<StartChallengeMutation>;
export type StartChallengeMutationOptions = Apollo.BaseMutationOptions<
  StartChallengeMutation,
  StartChallengeMutationVariables
>;
export const SubmitChallengeEntryDocument = gql`
  mutation SubmitChallengeEntry($entryId: ID!, $videoId: ID!) {
    submitChallengeEntry(entryId: $entryId, videoId: $videoId) {
      id
      status
      qualified
      makeRate
      shotsCount
      makesCount
      video {
        id
      }
    }
  }
`;
export type SubmitChallengeEntryMutationFn = Apollo.MutationFunction<
  SubmitChallengeEntryMutation,
  SubmitChallengeEntryMutationVariables
>;

/**
 * __useSubmitChallengeEntryMutation__
 *
 * To run a mutation, you first call `useSubmitChallengeEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSubmitChallengeEntryMutation` 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 [submitChallengeEntryMutation, { data, loading, error }] = useSubmitChallengeEntryMutation({
 *   variables: {
 *      entryId: // value for 'entryId'
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useSubmitChallengeEntryMutation(
  baseOptions?: Apollo.MutationHookOptions<
    SubmitChallengeEntryMutation,
    SubmitChallengeEntryMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    SubmitChallengeEntryMutation,
    SubmitChallengeEntryMutationVariables
  >(SubmitChallengeEntryDocument, options);
}
export type SubmitChallengeEntryMutationHookResult = ReturnType<
  typeof useSubmitChallengeEntryMutation
>;
export type SubmitChallengeEntryMutationResult =
  Apollo.MutationResult<SubmitChallengeEntryMutation>;
export type SubmitChallengeEntryMutationOptions = Apollo.BaseMutationOptions<
  SubmitChallengeEntryMutation,
  SubmitChallengeEntryMutationVariables
>;
export const RecalculateChallengeEntryDocument = gql`
  mutation RecalculateChallengeEntry($entryId: ID!) {
    recalculateChallengeEntry(entryId: $entryId) {
      id
      status
      qualified
      makeRate
      shotsCount
      makesCount
    }
  }
`;
export type RecalculateChallengeEntryMutationFn = Apollo.MutationFunction<
  RecalculateChallengeEntryMutation,
  RecalculateChallengeEntryMutationVariables
>;

/**
 * __useRecalculateChallengeEntryMutation__
 *
 * To run a mutation, you first call `useRecalculateChallengeEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRecalculateChallengeEntryMutation` 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 [recalculateChallengeEntryMutation, { data, loading, error }] = useRecalculateChallengeEntryMutation({
 *   variables: {
 *      entryId: // value for 'entryId'
 *   },
 * });
 */
export function useRecalculateChallengeEntryMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RecalculateChallengeEntryMutation,
    RecalculateChallengeEntryMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    RecalculateChallengeEntryMutation,
    RecalculateChallengeEntryMutationVariables
  >(RecalculateChallengeEntryDocument, options);
}
export type RecalculateChallengeEntryMutationHookResult = ReturnType<
  typeof useRecalculateChallengeEntryMutation
>;
export type RecalculateChallengeEntryMutationResult =
  Apollo.MutationResult<RecalculateChallengeEntryMutation>;
export type RecalculateChallengeEntryMutationOptions =
  Apollo.BaseMutationOptions<
    RecalculateChallengeEntryMutation,
    RecalculateChallengeEntryMutationVariables
  >;
export const IsChallengeDismissedDocument = gql`
  query IsChallengeDismissed($challengeId: ID!) {
    isChallengeDismissed(challengeId: $challengeId)
  }
`;

/**
 * __useIsChallengeDismissedQuery__
 *
 * To run a query within a React component, call `useIsChallengeDismissedQuery` and pass it any options that fit your needs.
 * When your component renders, `useIsChallengeDismissedQuery` 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 } = useIsChallengeDismissedQuery({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *   },
 * });
 */
export function useIsChallengeDismissedQuery(
  baseOptions: Apollo.QueryHookOptions<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >(IsChallengeDismissedDocument, options);
}
export function useIsChallengeDismissedLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >(IsChallengeDismissedDocument, options);
}
export function useIsChallengeDismissedSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    IsChallengeDismissedQuery,
    IsChallengeDismissedQueryVariables
  >(IsChallengeDismissedDocument, options);
}
export type IsChallengeDismissedQueryHookResult = ReturnType<
  typeof useIsChallengeDismissedQuery
>;
export type IsChallengeDismissedLazyQueryHookResult = ReturnType<
  typeof useIsChallengeDismissedLazyQuery
>;
export type IsChallengeDismissedSuspenseQueryHookResult = ReturnType<
  typeof useIsChallengeDismissedSuspenseQuery
>;
export type IsChallengeDismissedQueryResult = Apollo.QueryResult<
  IsChallengeDismissedQuery,
  IsChallengeDismissedQueryVariables
>;
export const DismissChallengeDocument = gql`
  mutation DismissChallenge($challengeId: ID!) {
    dismissChallenge(challengeId: $challengeId)
  }
`;
export type DismissChallengeMutationFn = Apollo.MutationFunction<
  DismissChallengeMutation,
  DismissChallengeMutationVariables
>;

/**
 * __useDismissChallengeMutation__
 *
 * To run a mutation, you first call `useDismissChallengeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDismissChallengeMutation` 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 [dismissChallengeMutation, { data, loading, error }] = useDismissChallengeMutation({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *   },
 * });
 */
export function useDismissChallengeMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DismissChallengeMutation,
    DismissChallengeMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    DismissChallengeMutation,
    DismissChallengeMutationVariables
  >(DismissChallengeDocument, options);
}
export type DismissChallengeMutationHookResult = ReturnType<
  typeof useDismissChallengeMutation
>;
export type DismissChallengeMutationResult =
  Apollo.MutationResult<DismissChallengeMutation>;
export type DismissChallengeMutationOptions = Apollo.BaseMutationOptions<
  DismissChallengeMutation,
  DismissChallengeMutationVariables
>;
export const UndismissChallengeDocument = gql`
  mutation UndismissChallenge($challengeId: ID!) {
    undismissChallenge(challengeId: $challengeId)
  }
`;
export type UndismissChallengeMutationFn = Apollo.MutationFunction<
  UndismissChallengeMutation,
  UndismissChallengeMutationVariables
>;

/**
 * __useUndismissChallengeMutation__
 *
 * To run a mutation, you first call `useUndismissChallengeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUndismissChallengeMutation` 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 [undismissChallengeMutation, { data, loading, error }] = useUndismissChallengeMutation({
 *   variables: {
 *      challengeId: // value for 'challengeId'
 *   },
 * });
 */
export function useUndismissChallengeMutation(
  baseOptions?: Apollo.MutationHookOptions<
    UndismissChallengeMutation,
    UndismissChallengeMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    UndismissChallengeMutation,
    UndismissChallengeMutationVariables
  >(UndismissChallengeDocument, options);
}
export type UndismissChallengeMutationHookResult = ReturnType<
  typeof useUndismissChallengeMutation
>;
export type UndismissChallengeMutationResult =
  Apollo.MutationResult<UndismissChallengeMutation>;
export type UndismissChallengeMutationOptions = Apollo.BaseMutationOptions<
  UndismissChallengeMutation,
  UndismissChallengeMutationVariables
>;
export const CommentOnVideoDocument = gql`
  mutation CommentOnVideo(
    $videoId: Int!
    $message: String!
    $parentCommentId: Int
  ) {
    commentOnVideo(
      videoId: $videoId
      message: $message
      parentCommentId: $parentCommentId
    )
  }
`;
export type CommentOnVideoMutationFn = Apollo.MutationFunction<
  CommentOnVideoMutation,
  CommentOnVideoMutationVariables
>;

/**
 * __useCommentOnVideoMutation__
 *
 * To run a mutation, you first call `useCommentOnVideoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCommentOnVideoMutation` 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 [commentOnVideoMutation, { data, loading, error }] = useCommentOnVideoMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      message: // value for 'message'
 *      parentCommentId: // value for 'parentCommentId'
 *   },
 * });
 */
export function useCommentOnVideoMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CommentOnVideoMutation,
    CommentOnVideoMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CommentOnVideoMutation,
    CommentOnVideoMutationVariables
  >(CommentOnVideoDocument, options);
}
export type CommentOnVideoMutationHookResult = ReturnType<
  typeof useCommentOnVideoMutation
>;
export type CommentOnVideoMutationResult =
  Apollo.MutationResult<CommentOnVideoMutation>;
export type CommentOnVideoMutationOptions = Apollo.BaseMutationOptions<
  CommentOnVideoMutation,
  CommentOnVideoMutationVariables
>;
export const EditCommentDocument = gql`
  mutation EditComment($videoId: Int!, $commentId: Int!, $newMessage: String!) {
    editComment(
      videoId: $videoId
      commentId: $commentId
      newMessage: $newMessage
    )
  }
`;
export type EditCommentMutationFn = Apollo.MutationFunction<
  EditCommentMutation,
  EditCommentMutationVariables
>;

/**
 * __useEditCommentMutation__
 *
 * To run a mutation, you first call `useEditCommentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditCommentMutation` 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 [editCommentMutation, { data, loading, error }] = useEditCommentMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      commentId: // value for 'commentId'
 *      newMessage: // value for 'newMessage'
 *   },
 * });
 */
export function useEditCommentMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EditCommentMutation,
    EditCommentMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<EditCommentMutation, EditCommentMutationVariables>(
    EditCommentDocument,
    options,
  );
}
export type EditCommentMutationHookResult = ReturnType<
  typeof useEditCommentMutation
>;
export type EditCommentMutationResult =
  Apollo.MutationResult<EditCommentMutation>;
export type EditCommentMutationOptions = Apollo.BaseMutationOptions<
  EditCommentMutation,
  EditCommentMutationVariables
>;
export const DeleteCommentDocument = gql`
  mutation DeleteComment($videoId: Int!, $commentId: Int!) {
    deleteComment(videoId: $videoId, commentId: $commentId)
  }
`;
export type DeleteCommentMutationFn = Apollo.MutationFunction<
  DeleteCommentMutation,
  DeleteCommentMutationVariables
>;

/**
 * __useDeleteCommentMutation__
 *
 * To run a mutation, you first call `useDeleteCommentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteCommentMutation` 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 [deleteCommentMutation, { data, loading, error }] = useDeleteCommentMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      commentId: // value for 'commentId'
 *   },
 * });
 */
export function useDeleteCommentMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DeleteCommentMutation,
    DeleteCommentMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    DeleteCommentMutation,
    DeleteCommentMutationVariables
  >(DeleteCommentDocument, options);
}
export type DeleteCommentMutationHookResult = ReturnType<
  typeof useDeleteCommentMutation
>;
export type DeleteCommentMutationResult =
  Apollo.MutationResult<DeleteCommentMutation>;
export type DeleteCommentMutationOptions = Apollo.BaseMutationOptions<
  DeleteCommentMutation,
  DeleteCommentMutationVariables
>;
export const GetDeployedConfigDocument = gql`
  query getDeployedConfig {
    getDeployedConfig {
      allowNewUsers
      devMode
      environment
      firebase
      minimumAllowedAppVersion
      subscriptionGatingEnabled
      quotaEnforcementEnabled
      storageLimitEnforcementEnabled
      capabilityEnforcementEnabled
      bannerMessages {
        color
        dismissible
        id
        kind
        message
        priority
      }
      defaultAndroidRecordingFormat
      bucketUrl
    }
  }
`;

/**
 * __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 BlockContentDocument = gql`
  mutation blockContent($videoId: Int!) {
    blockContent(videoId: $videoId)
  }
`;
export type BlockContentMutationFn = Apollo.MutationFunction<
  BlockContentMutation,
  BlockContentMutationVariables
>;

/**
 * __useBlockContentMutation__
 *
 * To run a mutation, you first call `useBlockContentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBlockContentMutation` 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 [blockContentMutation, { data, loading, error }] = useBlockContentMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useBlockContentMutation(
  baseOptions?: Apollo.MutationHookOptions<
    BlockContentMutation,
    BlockContentMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    BlockContentMutation,
    BlockContentMutationVariables
  >(BlockContentDocument, options);
}
export type BlockContentMutationHookResult = ReturnType<
  typeof useBlockContentMutation
>;
export type BlockContentMutationResult =
  Apollo.MutationResult<BlockContentMutation>;
export type BlockContentMutationOptions = Apollo.BaseMutationOptions<
  BlockContentMutation,
  BlockContentMutationVariables
>;
export const BlockUserDocument = gql`
  mutation blockUser($userId: Int!) {
    blockUser(userId: $userId)
  }
`;
export type BlockUserMutationFn = Apollo.MutationFunction<
  BlockUserMutation,
  BlockUserMutationVariables
>;

/**
 * __useBlockUserMutation__
 *
 * To run a mutation, you first call `useBlockUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBlockUserMutation` 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 [blockUserMutation, { data, loading, error }] = useBlockUserMutation({
 *   variables: {
 *      userId: // value for 'userId'
 *   },
 * });
 */
export function useBlockUserMutation(
  baseOptions?: Apollo.MutationHookOptions<
    BlockUserMutation,
    BlockUserMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<BlockUserMutation, BlockUserMutationVariables>(
    BlockUserDocument,
    options,
  );
}
export type BlockUserMutationHookResult = ReturnType<
  typeof useBlockUserMutation
>;
export type BlockUserMutationResult = Apollo.MutationResult<BlockUserMutation>;
export type BlockUserMutationOptions = Apollo.BaseMutationOptions<
  BlockUserMutation,
  BlockUserMutationVariables
>;
export const ReportContentDocument = gql`
  mutation reportContent(
    $videoId: Int!
    $reason: ReportReasonEnum!
    $customReason: String = null
  ) {
    reportContent(
      videoId: $videoId
      reason: $reason
      customReason: $customReason
    )
  }
`;
export type ReportContentMutationFn = Apollo.MutationFunction<
  ReportContentMutation,
  ReportContentMutationVariables
>;

/**
 * __useReportContentMutation__
 *
 * To run a mutation, you first call `useReportContentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReportContentMutation` 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 [reportContentMutation, { data, loading, error }] = useReportContentMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      reason: // value for 'reason'
 *      customReason: // value for 'customReason'
 *   },
 * });
 */
export function useReportContentMutation(
  baseOptions?: Apollo.MutationHookOptions<
    ReportContentMutation,
    ReportContentMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    ReportContentMutation,
    ReportContentMutationVariables
  >(ReportContentDocument, options);
}
export type ReportContentMutationHookResult = ReturnType<
  typeof useReportContentMutation
>;
export type ReportContentMutationResult =
  Apollo.MutationResult<ReportContentMutation>;
export type ReportContentMutationOptions = Apollo.BaseMutationOptions<
  ReportContentMutation,
  ReportContentMutationVariables
>;
export const GetFeedDocument = gql`
  query GetFeed(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
  ) {
    getUserVideos(limit: $limit, after: $after, filters: $filters) {
      videos {
        ...VideoCardFields
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
  ${VideoCardFieldsFragmentDoc}
`;

/**
 * __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 GetVideoFeedSessionCountDocument = gql`
  query GetVideoFeedSessionCount(
    $limit: Int! = 100
    $filters: VideoFilterInput = null
    $includePrivate: IncludePrivateEnum = MINE
    $feedInput: VideoFeedInputGQL = null
  ) {
    getFeedVideos(
      limit: $limit
      filters: $filters
      includePrivate: $includePrivate
      feedInput: $feedInput
    ) {
      videos {
        id
        totalShots
      }
    }
  }
`;

/**
 * __useGetVideoFeedSessionCountQuery__
 *
 * To run a query within a React component, call `useGetVideoFeedSessionCountQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoFeedSessionCountQuery` 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 } = useGetVideoFeedSessionCountQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      filters: // value for 'filters'
 *      includePrivate: // value for 'includePrivate'
 *      feedInput: // value for 'feedInput'
 *   },
 * });
 */
export function useGetVideoFeedSessionCountQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >(GetVideoFeedSessionCountDocument, options);
}
export function useGetVideoFeedSessionCountLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >(GetVideoFeedSessionCountDocument, options);
}
export function useGetVideoFeedSessionCountSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoFeedSessionCountQuery,
    GetVideoFeedSessionCountQueryVariables
  >(GetVideoFeedSessionCountDocument, options);
}
export type GetVideoFeedSessionCountQueryHookResult = ReturnType<
  typeof useGetVideoFeedSessionCountQuery
>;
export type GetVideoFeedSessionCountLazyQueryHookResult = ReturnType<
  typeof useGetVideoFeedSessionCountLazyQuery
>;
export type GetVideoFeedSessionCountSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoFeedSessionCountSuspenseQuery
>;
export type GetVideoFeedSessionCountQueryResult = Apollo.QueryResult<
  GetVideoFeedSessionCountQuery,
  GetVideoFeedSessionCountQueryVariables
>;
export const GetLastSessionDateDocument = gql`
  query GetLastSessionDate(
    $filters: VideoFilterInput = null
    $includePrivate: IncludePrivateEnum = MINE
    $feedInput: VideoFeedInputGQL = null
  ) {
    getFeedVideos(
      limit: 1
      filters: $filters
      includePrivate: $includePrivate
      feedInput: $feedInput
    ) {
      videos {
        id
        startTime
      }
    }
  }
`;

/**
 * __useGetLastSessionDateQuery__
 *
 * To run a query within a React component, call `useGetLastSessionDateQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetLastSessionDateQuery` 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 } = useGetLastSessionDateQuery({
 *   variables: {
 *      filters: // value for 'filters'
 *      includePrivate: // value for 'includePrivate'
 *      feedInput: // value for 'feedInput'
 *   },
 * });
 */
export function useGetLastSessionDateQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >(GetLastSessionDateDocument, options);
}
export function useGetLastSessionDateLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >(GetLastSessionDateDocument, options);
}
export function useGetLastSessionDateSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetLastSessionDateQuery,
    GetLastSessionDateQueryVariables
  >(GetLastSessionDateDocument, options);
}
export type GetLastSessionDateQueryHookResult = ReturnType<
  typeof useGetLastSessionDateQuery
>;
export type GetLastSessionDateLazyQueryHookResult = ReturnType<
  typeof useGetLastSessionDateLazyQuery
>;
export type GetLastSessionDateSuspenseQueryHookResult = ReturnType<
  typeof useGetLastSessionDateSuspenseQuery
>;
export type GetLastSessionDateQueryResult = Apollo.QueryResult<
  GetLastSessionDateQuery,
  GetLastSessionDateQueryVariables
>;
export const GetVideoFeedDocument = gql`
  query GetVideoFeed(
    $limit: Int! = 5
    $after: String = null
    $filters: VideoFilterInput = null
    $includeCallersVideos: Boolean = null
    $includePrivate: IncludePrivateEnum = MINE
    $feedInput: VideoFeedInputGQL = null
  ) {
    getFeedVideos(
      limit: $limit
      after: $after
      filters: $filters
      includeCallersVideos: $includeCallersVideos
      includePrivate: $includePrivate
      feedInput: $feedInput
    ) {
      videos {
        ...VideoCardFields
      }
      pageInfo {
        hasNextPage
        endCursor
      }
      hasFollowing
      followingCount
    }
  }
  ${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'
 *      includeCallersVideos: // value for 'includeCallersVideos'
 *      includePrivate: // value for 'includePrivate'
 *      feedInput: // value for 'feedInput'
 *   },
 * });
 */
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 GetMakesLeaderboardDocument = gql`
  query GetMakesLeaderboard(
    $interval: TimeInterval
    $when: DateTime
    $gameType: String
    $tableSizeMin: Float
    $tableSizeMax: Float
    $pocketSizeMin: Float
    $pocketSizeMax: Float
  ) {
    getMakesLeaderboard(
      interval: $interval
      when: $when
      gameType: $gameType
      tableSizeMin: $tableSizeMin
      tableSizeMax: $tableSizeMax
      pocketSizeMin: $pocketSizeMin
      pocketSizeMax: $pocketSizeMax
    ) {
      entries {
        user {
          id
          username
          profileImageUri
        }
        value
        proportionMade
        total
      }
    }
  }
`;

/**
 * __useGetMakesLeaderboardQuery__
 *
 * To run a query within a React component, call `useGetMakesLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMakesLeaderboardQuery` 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 } = useGetMakesLeaderboardQuery({
 *   variables: {
 *      interval: // value for 'interval'
 *      when: // value for 'when'
 *      gameType: // value for 'gameType'
 *      tableSizeMin: // value for 'tableSizeMin'
 *      tableSizeMax: // value for 'tableSizeMax'
 *      pocketSizeMin: // value for 'pocketSizeMin'
 *      pocketSizeMax: // value for 'pocketSizeMax'
 *   },
 * });
 */
export function useGetMakesLeaderboardQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >(GetMakesLeaderboardDocument, options);
}
export function useGetMakesLeaderboardLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >(GetMakesLeaderboardDocument, options);
}
export function useGetMakesLeaderboardSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMakesLeaderboardQuery,
    GetMakesLeaderboardQueryVariables
  >(GetMakesLeaderboardDocument, options);
}
export type GetMakesLeaderboardQueryHookResult = ReturnType<
  typeof useGetMakesLeaderboardQuery
>;
export type GetMakesLeaderboardLazyQueryHookResult = ReturnType<
  typeof useGetMakesLeaderboardLazyQuery
>;
export type GetMakesLeaderboardSuspenseQueryHookResult = ReturnType<
  typeof useGetMakesLeaderboardSuspenseQuery
>;
export type GetMakesLeaderboardQueryResult = Apollo.QueryResult<
  GetMakesLeaderboardQuery,
  GetMakesLeaderboardQueryVariables
>;
export const GetRunsLeaderboardDocument = gql`
  query GetRunsLeaderboard(
    $interval: TimeInterval
    $when: DateTime
    $gameType: String
    $tableSizeMin: Float
    $tableSizeMax: Float
    $pocketSizeMin: Float
    $pocketSizeMax: Float
  ) {
    getLongestRunsLeaderboard(
      interval: $interval
      when: $when
      gameType: $gameType
      tableSizeMin: $tableSizeMin
      tableSizeMax: $tableSizeMax
      pocketSizeMin: $pocketSizeMin
      pocketSizeMax: $pocketSizeMax
    ) {
      entries {
        id
        runLength
        video {
          name
          createdAt
        }
        user {
          id
          username
          profileImageUri
        }
      }
    }
  }
`;

/**
 * __useGetRunsLeaderboardQuery__
 *
 * To run a query within a React component, call `useGetRunsLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRunsLeaderboardQuery` 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 } = useGetRunsLeaderboardQuery({
 *   variables: {
 *      interval: // value for 'interval'
 *      when: // value for 'when'
 *      gameType: // value for 'gameType'
 *      tableSizeMin: // value for 'tableSizeMin'
 *      tableSizeMax: // value for 'tableSizeMax'
 *      pocketSizeMin: // value for 'pocketSizeMin'
 *      pocketSizeMax: // value for 'pocketSizeMax'
 *   },
 * });
 */
export function useGetRunsLeaderboardQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >(GetRunsLeaderboardDocument, options);
}
export function useGetRunsLeaderboardLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >(GetRunsLeaderboardDocument, options);
}
export function useGetRunsLeaderboardSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetRunsLeaderboardQuery,
    GetRunsLeaderboardQueryVariables
  >(GetRunsLeaderboardDocument, options);
}
export type GetRunsLeaderboardQueryHookResult = ReturnType<
  typeof useGetRunsLeaderboardQuery
>;
export type GetRunsLeaderboardLazyQueryHookResult = ReturnType<
  typeof useGetRunsLeaderboardLazyQuery
>;
export type GetRunsLeaderboardSuspenseQueryHookResult = ReturnType<
  typeof useGetRunsLeaderboardSuspenseQuery
>;
export type GetRunsLeaderboardQueryResult = Apollo.QueryResult<
  GetRunsLeaderboardQuery,
  GetRunsLeaderboardQueryVariables
>;
export const GetDrillRunLeaderboardDocument = gql`
  query GetDrillRunLeaderboard(
    $drillTag: String!
    $interval: TimeInterval
    $limit: Int = 50
    $tableSizeMin: Float
    $tableSizeMax: Float
    $pocketSizeMin: Float
    $pocketSizeMax: Float
  ) {
    getDrillRunLeaderboard(
      drillTag: $drillTag
      interval: $interval
      limit: $limit
      tableSizeMin: $tableSizeMin
      tableSizeMax: $tableSizeMax
      pocketSizeMin: $pocketSizeMin
      pocketSizeMax: $pocketSizeMax
    ) {
      entries {
        id
        runLength
        videoId
        video {
          tableSize
          pocketSize
          createdAt
        }
        user {
          id
          username
          profileImageUri
        }
      }
      youRun {
        id
        runLength
        videoId
      }
      youRank
      totalPlayers
    }
  }
`;

/**
 * __useGetDrillRunLeaderboardQuery__
 *
 * To run a query within a React component, call `useGetDrillRunLeaderboardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetDrillRunLeaderboardQuery` 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 } = useGetDrillRunLeaderboardQuery({
 *   variables: {
 *      drillTag: // value for 'drillTag'
 *      interval: // value for 'interval'
 *      limit: // value for 'limit'
 *      tableSizeMin: // value for 'tableSizeMin'
 *      tableSizeMax: // value for 'tableSizeMax'
 *      pocketSizeMin: // value for 'pocketSizeMin'
 *      pocketSizeMax: // value for 'pocketSizeMax'
 *   },
 * });
 */
export function useGetDrillRunLeaderboardQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >(GetDrillRunLeaderboardDocument, options);
}
export function useGetDrillRunLeaderboardLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >(GetDrillRunLeaderboardDocument, options);
}
export function useGetDrillRunLeaderboardSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetDrillRunLeaderboardQuery,
    GetDrillRunLeaderboardQueryVariables
  >(GetDrillRunLeaderboardDocument, options);
}
export type GetDrillRunLeaderboardQueryHookResult = ReturnType<
  typeof useGetDrillRunLeaderboardQuery
>;
export type GetDrillRunLeaderboardLazyQueryHookResult = ReturnType<
  typeof useGetDrillRunLeaderboardLazyQuery
>;
export type GetDrillRunLeaderboardSuspenseQueryHookResult = ReturnType<
  typeof useGetDrillRunLeaderboardSuspenseQuery
>;
export type GetDrillRunLeaderboardQueryResult = Apollo.QueryResult<
  GetDrillRunLeaderboardQuery,
  GetDrillRunLeaderboardQueryVariables
>;
export const GetMyDrillRunsDocument = gql`
  query GetMyDrillRuns($drillTag: String!, $limit: Int = 50) {
    getMyDrillRuns(drillTag: $drillTag, limit: $limit) {
      id
      runLength
      videoId
      video {
        createdAt
      }
    }
  }
`;

/**
 * __useGetMyDrillRunsQuery__
 *
 * To run a query within a React component, call `useGetMyDrillRunsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMyDrillRunsQuery` 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 } = useGetMyDrillRunsQuery({
 *   variables: {
 *      drillTag: // value for 'drillTag'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetMyDrillRunsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetMyDrillRunsQuery,
    GetMyDrillRunsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetMyDrillRunsQuery, GetMyDrillRunsQueryVariables>(
    GetMyDrillRunsDocument,
    options,
  );
}
export function useGetMyDrillRunsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMyDrillRunsQuery,
    GetMyDrillRunsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetMyDrillRunsQuery, GetMyDrillRunsQueryVariables>(
    GetMyDrillRunsDocument,
    options,
  );
}
export function useGetMyDrillRunsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMyDrillRunsQuery,
    GetMyDrillRunsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetMyDrillRunsQuery,
    GetMyDrillRunsQueryVariables
  >(GetMyDrillRunsDocument, options);
}
export type GetMyDrillRunsQueryHookResult = ReturnType<
  typeof useGetMyDrillRunsQuery
>;
export type GetMyDrillRunsLazyQueryHookResult = ReturnType<
  typeof useGetMyDrillRunsLazyQuery
>;
export type GetMyDrillRunsSuspenseQueryHookResult = ReturnType<
  typeof useGetMyDrillRunsSuspenseQuery
>;
export type GetMyDrillRunsQueryResult = Apollo.QueryResult<
  GetMyDrillRunsQuery,
  GetMyDrillRunsQueryVariables
>;
export const GetRecordedStreamsDocument = gql`
  query GetRecordedStreams($limit: Int! = 25) {
    getFeedVideos(
      limit: $limit
      filters: { isStreamCompleted: true, excludeVideosWithNoShots: true }
      includePrivate: MINE
      feedInput: { allUsers: true }
    ) {
      videos {
        id
        name
        createdAt
        screenshotUri
        framesPerSecond
        totalShots
        owner {
          id
          username
          profileImageUri
        }
      }
    }
  }
`;

/**
 * __useGetRecordedStreamsQuery__
 *
 * To run a query within a React component, call `useGetRecordedStreamsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRecordedStreamsQuery` 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 } = useGetRecordedStreamsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetRecordedStreamsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >(GetRecordedStreamsDocument, options);
}
export function useGetRecordedStreamsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >(GetRecordedStreamsDocument, options);
}
export function useGetRecordedStreamsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetRecordedStreamsQuery,
    GetRecordedStreamsQueryVariables
  >(GetRecordedStreamsDocument, options);
}
export type GetRecordedStreamsQueryHookResult = ReturnType<
  typeof useGetRecordedStreamsQuery
>;
export type GetRecordedStreamsLazyQueryHookResult = ReturnType<
  typeof useGetRecordedStreamsLazyQuery
>;
export type GetRecordedStreamsSuspenseQueryHookResult = ReturnType<
  typeof useGetRecordedStreamsSuspenseQuery
>;
export type GetRecordedStreamsQueryResult = Apollo.QueryResult<
  GetRecordedStreamsQuery,
  GetRecordedStreamsQueryVariables
>;
export const GetLiveStreamsDocument = gql`
  query GetLiveStreams($limit: Int! = 25) {
    getFeedVideos(
      limit: $limit
      filters: { isStreamCompleted: false, requireCursorCompletion: false }
      includePrivate: MINE
      feedInput: { allUsers: true }
    ) {
      videos {
        id
        name
        startTime
        createdAt
        screenshotUri
        elapsedTime
        owner {
          id
          username
          profileImageUri
        }
        stream {
          id
          isCompleted
          lastSegmentUploadedAt
        }
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
`;

/**
 * __useGetLiveStreamsQuery__
 *
 * To run a query within a React component, call `useGetLiveStreamsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetLiveStreamsQuery` 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 } = useGetLiveStreamsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetLiveStreamsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetLiveStreamsQuery,
    GetLiveStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetLiveStreamsQuery, GetLiveStreamsQueryVariables>(
    GetLiveStreamsDocument,
    options,
  );
}
export function useGetLiveStreamsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetLiveStreamsQuery,
    GetLiveStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetLiveStreamsQuery, GetLiveStreamsQueryVariables>(
    GetLiveStreamsDocument,
    options,
  );
}
export function useGetLiveStreamsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetLiveStreamsQuery,
    GetLiveStreamsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetLiveStreamsQuery,
    GetLiveStreamsQueryVariables
  >(GetLiveStreamsDocument, options);
}
export type GetLiveStreamsQueryHookResult = ReturnType<
  typeof useGetLiveStreamsQuery
>;
export type GetLiveStreamsLazyQueryHookResult = ReturnType<
  typeof useGetLiveStreamsLazyQuery
>;
export type GetLiveStreamsSuspenseQueryHookResult = ReturnType<
  typeof useGetLiveStreamsSuspenseQuery
>;
export type GetLiveStreamsQueryResult = Apollo.QueryResult<
  GetLiveStreamsQuery,
  GetLiveStreamsQueryVariables
>;
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 GetMedalsDocument = gql`
  query getMedals($scope: MedalScope!, $userId: Int) {
    getMedals(scope: $scope, userId: $userId) {
      distanceOver78 {
        ...MedalFields
      }
      distanceOver90 {
        ...MedalFields
      }
      runLength3 {
        ...MedalFields
      }
      runLength5 {
        ...MedalFields
      }
      runLength8 {
        ...MedalFields
      }
      runLength10 {
        ...MedalFields
      }
      runLength15 {
        ...MedalFields
      }
      runLength20 {
        ...MedalFields
      }
      runLength25 {
        ...MedalFields
      }
      runLength30 {
        ...MedalFields
      }
      runLength40 {
        ...MedalFields
      }
      runLength50 {
        ...MedalFields
      }
      totalMakes100 {
        ...MedalFields
      }
      totalMakes500 {
        ...MedalFields
      }
      totalMakes1000 {
        ...MedalFields
      }
      totalMakes5000 {
        ...MedalFields
      }
      totalMakes10000 {
        ...MedalFields
      }
      dailyMakes50 {
        ...MedalFields
      }
      dailyMakes100 {
        ...MedalFields
      }
      dailyMakes150 {
        ...MedalFields
      }
      dailyMakes200 {
        ...MedalFields
      }
      dailyMakes250 {
        ...MedalFields
      }
    }
  }
  ${MedalFieldsFragmentDoc}
`;

/**
 * __useGetMedalsQuery__
 *
 * To run a query within a React component, call `useGetMedalsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMedalsQuery` 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 } = useGetMedalsQuery({
 *   variables: {
 *      scope: // value for 'scope'
 *      userId: // value for 'userId'
 *   },
 * });
 */
export function useGetMedalsQuery(
  baseOptions: Apollo.QueryHookOptions<GetMedalsQuery, GetMedalsQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetMedalsQuery, GetMedalsQueryVariables>(
    GetMedalsDocument,
    options,
  );
}
export function useGetMedalsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetMedalsQuery,
    GetMedalsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetMedalsQuery, GetMedalsQueryVariables>(
    GetMedalsDocument,
    options,
  );
}
export function useGetMedalsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetMedalsQuery,
    GetMedalsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetMedalsQuery, GetMedalsQueryVariables>(
    GetMedalsDocument,
    options,
  );
}
export type GetMedalsQueryHookResult = ReturnType<typeof useGetMedalsQuery>;
export type GetMedalsLazyQueryHookResult = ReturnType<
  typeof useGetMedalsLazyQuery
>;
export type GetMedalsSuspenseQueryHookResult = ReturnType<
  typeof useGetMedalsSuspenseQuery
>;
export type GetMedalsQueryResult = Apollo.QueryResult<
  GetMedalsQuery,
  GetMedalsQueryVariables
>;
export const GetNotificationsDocument = gql`
  query GetNotifications(
    $limit: Int! = 20
    $offset: Int! = 0
    $filters: NotificationFilters = null
  ) {
    notifications(limit: $limit, offset: $offset, filters: $filters) {
      notifications {
        ...Notification
      }
      totalCount
      unreadCount
      hasMore
    }
  }
  ${NotificationFragmentDoc}
`;

/**
 * __useGetNotificationsQuery__
 *
 * To run a query within a React component, call `useGetNotificationsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetNotificationsQuery` 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 } = useGetNotificationsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *      filters: // value for 'filters'
 *   },
 * });
 */
export function useGetNotificationsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetNotificationsQuery,
    GetNotificationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetNotificationsQuery, GetNotificationsQueryVariables>(
    GetNotificationsDocument,
    options,
  );
}
export function useGetNotificationsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetNotificationsQuery,
    GetNotificationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetNotificationsQuery,
    GetNotificationsQueryVariables
  >(GetNotificationsDocument, options);
}
export function useGetNotificationsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetNotificationsQuery,
    GetNotificationsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetNotificationsQuery,
    GetNotificationsQueryVariables
  >(GetNotificationsDocument, options);
}
export type GetNotificationsQueryHookResult = ReturnType<
  typeof useGetNotificationsQuery
>;
export type GetNotificationsLazyQueryHookResult = ReturnType<
  typeof useGetNotificationsLazyQuery
>;
export type GetNotificationsSuspenseQueryHookResult = ReturnType<
  typeof useGetNotificationsSuspenseQuery
>;
export type GetNotificationsQueryResult = Apollo.QueryResult<
  GetNotificationsQuery,
  GetNotificationsQueryVariables
>;
export const GetUnreadNotificationCountDocument = gql`
  query GetUnreadNotificationCount {
    unreadNotificationCount
  }
`;

/**
 * __useGetUnreadNotificationCountQuery__
 *
 * To run a query within a React component, call `useGetUnreadNotificationCountQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUnreadNotificationCountQuery` 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 } = useGetUnreadNotificationCountQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetUnreadNotificationCountQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >(GetUnreadNotificationCountDocument, options);
}
export function useGetUnreadNotificationCountLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >(GetUnreadNotificationCountDocument, options);
}
export function useGetUnreadNotificationCountSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUnreadNotificationCountQuery,
    GetUnreadNotificationCountQueryVariables
  >(GetUnreadNotificationCountDocument, options);
}
export type GetUnreadNotificationCountQueryHookResult = ReturnType<
  typeof useGetUnreadNotificationCountQuery
>;
export type GetUnreadNotificationCountLazyQueryHookResult = ReturnType<
  typeof useGetUnreadNotificationCountLazyQuery
>;
export type GetUnreadNotificationCountSuspenseQueryHookResult = ReturnType<
  typeof useGetUnreadNotificationCountSuspenseQuery
>;
export type GetUnreadNotificationCountQueryResult = Apollo.QueryResult<
  GetUnreadNotificationCountQuery,
  GetUnreadNotificationCountQueryVariables
>;
export const MarkNotificationAsReadDocument = gql`
  mutation MarkNotificationAsRead($notificationId: Int!) {
    markNotificationAsRead(notificationId: $notificationId)
  }
`;
export type MarkNotificationAsReadMutationFn = Apollo.MutationFunction<
  MarkNotificationAsReadMutation,
  MarkNotificationAsReadMutationVariables
>;

/**
 * __useMarkNotificationAsReadMutation__
 *
 * To run a mutation, you first call `useMarkNotificationAsReadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMarkNotificationAsReadMutation` 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 [markNotificationAsReadMutation, { data, loading, error }] = useMarkNotificationAsReadMutation({
 *   variables: {
 *      notificationId: // value for 'notificationId'
 *   },
 * });
 */
export function useMarkNotificationAsReadMutation(
  baseOptions?: Apollo.MutationHookOptions<
    MarkNotificationAsReadMutation,
    MarkNotificationAsReadMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    MarkNotificationAsReadMutation,
    MarkNotificationAsReadMutationVariables
  >(MarkNotificationAsReadDocument, options);
}
export type MarkNotificationAsReadMutationHookResult = ReturnType<
  typeof useMarkNotificationAsReadMutation
>;
export type MarkNotificationAsReadMutationResult =
  Apollo.MutationResult<MarkNotificationAsReadMutation>;
export type MarkNotificationAsReadMutationOptions = Apollo.BaseMutationOptions<
  MarkNotificationAsReadMutation,
  MarkNotificationAsReadMutationVariables
>;
export const MarkNotificationsAsReadDocument = gql`
  mutation MarkNotificationsAsRead($notificationIds: [Int!]!) {
    markNotificationsAsRead(notificationIds: $notificationIds)
  }
`;
export type MarkNotificationsAsReadMutationFn = Apollo.MutationFunction<
  MarkNotificationsAsReadMutation,
  MarkNotificationsAsReadMutationVariables
>;

/**
 * __useMarkNotificationsAsReadMutation__
 *
 * To run a mutation, you first call `useMarkNotificationsAsReadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMarkNotificationsAsReadMutation` 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 [markNotificationsAsReadMutation, { data, loading, error }] = useMarkNotificationsAsReadMutation({
 *   variables: {
 *      notificationIds: // value for 'notificationIds'
 *   },
 * });
 */
export function useMarkNotificationsAsReadMutation(
  baseOptions?: Apollo.MutationHookOptions<
    MarkNotificationsAsReadMutation,
    MarkNotificationsAsReadMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    MarkNotificationsAsReadMutation,
    MarkNotificationsAsReadMutationVariables
  >(MarkNotificationsAsReadDocument, options);
}
export type MarkNotificationsAsReadMutationHookResult = ReturnType<
  typeof useMarkNotificationsAsReadMutation
>;
export type MarkNotificationsAsReadMutationResult =
  Apollo.MutationResult<MarkNotificationsAsReadMutation>;
export type MarkNotificationsAsReadMutationOptions = Apollo.BaseMutationOptions<
  MarkNotificationsAsReadMutation,
  MarkNotificationsAsReadMutationVariables
>;
export const MarkAllNotificationsAsReadDocument = gql`
  mutation MarkAllNotificationsAsRead {
    markAllNotificationsAsRead
  }
`;
export type MarkAllNotificationsAsReadMutationFn = Apollo.MutationFunction<
  MarkAllNotificationsAsReadMutation,
  MarkAllNotificationsAsReadMutationVariables
>;

/**
 * __useMarkAllNotificationsAsReadMutation__
 *
 * To run a mutation, you first call `useMarkAllNotificationsAsReadMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMarkAllNotificationsAsReadMutation` 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 [markAllNotificationsAsReadMutation, { data, loading, error }] = useMarkAllNotificationsAsReadMutation({
 *   variables: {
 *   },
 * });
 */
export function useMarkAllNotificationsAsReadMutation(
  baseOptions?: Apollo.MutationHookOptions<
    MarkAllNotificationsAsReadMutation,
    MarkAllNotificationsAsReadMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    MarkAllNotificationsAsReadMutation,
    MarkAllNotificationsAsReadMutationVariables
  >(MarkAllNotificationsAsReadDocument, options);
}
export type MarkAllNotificationsAsReadMutationHookResult = ReturnType<
  typeof useMarkAllNotificationsAsReadMutation
>;
export type MarkAllNotificationsAsReadMutationResult =
  Apollo.MutationResult<MarkAllNotificationsAsReadMutation>;
export type MarkAllNotificationsAsReadMutationOptions =
  Apollo.BaseMutationOptions<
    MarkAllNotificationsAsReadMutation,
    MarkAllNotificationsAsReadMutationVariables
  >;
export const DeleteNotificationDocument = gql`
  mutation DeleteNotification($notificationId: Int!) {
    deleteNotification(notificationId: $notificationId)
  }
`;
export type DeleteNotificationMutationFn = Apollo.MutationFunction<
  DeleteNotificationMutation,
  DeleteNotificationMutationVariables
>;

/**
 * __useDeleteNotificationMutation__
 *
 * To run a mutation, you first call `useDeleteNotificationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteNotificationMutation` 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 [deleteNotificationMutation, { data, loading, error }] = useDeleteNotificationMutation({
 *   variables: {
 *      notificationId: // value for 'notificationId'
 *   },
 * });
 */
export function useDeleteNotificationMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DeleteNotificationMutation,
    DeleteNotificationMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    DeleteNotificationMutation,
    DeleteNotificationMutationVariables
  >(DeleteNotificationDocument, options);
}
export type DeleteNotificationMutationHookResult = ReturnType<
  typeof useDeleteNotificationMutation
>;
export type DeleteNotificationMutationResult =
  Apollo.MutationResult<DeleteNotificationMutation>;
export type DeleteNotificationMutationOptions = Apollo.BaseMutationOptions<
  DeleteNotificationMutation,
  DeleteNotificationMutationVariables
>;
export const EnsureStripeCustomerExistsDocument = gql`
  mutation EnsureStripeCustomerExists {
    ensureStripeCustomerExists {
      id
      firebaseUid
      username
      stripeCustomerId
      profileImageUri
      isAdmin
      fargoRating
      videosPrivateByDefault
      createdAt
      updatedAt
    }
  }
`;
export type EnsureStripeCustomerExistsMutationFn = Apollo.MutationFunction<
  EnsureStripeCustomerExistsMutation,
  EnsureStripeCustomerExistsMutationVariables
>;

/**
 * __useEnsureStripeCustomerExistsMutation__
 *
 * To run a mutation, you first call `useEnsureStripeCustomerExistsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEnsureStripeCustomerExistsMutation` 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 [ensureStripeCustomerExistsMutation, { data, loading, error }] = useEnsureStripeCustomerExistsMutation({
 *   variables: {
 *   },
 * });
 */
export function useEnsureStripeCustomerExistsMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EnsureStripeCustomerExistsMutation,
    EnsureStripeCustomerExistsMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    EnsureStripeCustomerExistsMutation,
    EnsureStripeCustomerExistsMutationVariables
  >(EnsureStripeCustomerExistsDocument, options);
}
export type EnsureStripeCustomerExistsMutationHookResult = ReturnType<
  typeof useEnsureStripeCustomerExistsMutation
>;
export type EnsureStripeCustomerExistsMutationResult =
  Apollo.MutationResult<EnsureStripeCustomerExistsMutation>;
export type EnsureStripeCustomerExistsMutationOptions =
  Apollo.BaseMutationOptions<
    EnsureStripeCustomerExistsMutation,
    EnsureStripeCustomerExistsMutationVariables
  >;
export const CreateSubscriptionDocument = gql`
  mutation CreateSubscription($priceId: String!) {
    createSubscription(priceId: $priceId) {
      checkoutUrl
      sessionId
    }
  }
`;
export type CreateSubscriptionMutationFn = Apollo.MutationFunction<
  CreateSubscriptionMutation,
  CreateSubscriptionMutationVariables
>;

/**
 * __useCreateSubscriptionMutation__
 *
 * To run a mutation, you first call `useCreateSubscriptionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateSubscriptionMutation` 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 [createSubscriptionMutation, { data, loading, error }] = useCreateSubscriptionMutation({
 *   variables: {
 *      priceId: // value for 'priceId'
 *   },
 * });
 */
export function useCreateSubscriptionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreateSubscriptionMutation,
    CreateSubscriptionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreateSubscriptionMutation,
    CreateSubscriptionMutationVariables
  >(CreateSubscriptionDocument, options);
}
export type CreateSubscriptionMutationHookResult = ReturnType<
  typeof useCreateSubscriptionMutation
>;
export type CreateSubscriptionMutationResult =
  Apollo.MutationResult<CreateSubscriptionMutation>;
export type CreateSubscriptionMutationOptions = Apollo.BaseMutationOptions<
  CreateSubscriptionMutation,
  CreateSubscriptionMutationVariables
>;
export const CreateCustomerPortalSessionDocument = gql`
  mutation CreateCustomerPortalSession {
    createCustomerPortalSession {
      portalUrl
    }
  }
`;
export type CreateCustomerPortalSessionMutationFn = Apollo.MutationFunction<
  CreateCustomerPortalSessionMutation,
  CreateCustomerPortalSessionMutationVariables
>;

/**
 * __useCreateCustomerPortalSessionMutation__
 *
 * To run a mutation, you first call `useCreateCustomerPortalSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCustomerPortalSessionMutation` 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 [createCustomerPortalSessionMutation, { data, loading, error }] = useCreateCustomerPortalSessionMutation({
 *   variables: {
 *   },
 * });
 */
export function useCreateCustomerPortalSessionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreateCustomerPortalSessionMutation,
    CreateCustomerPortalSessionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreateCustomerPortalSessionMutation,
    CreateCustomerPortalSessionMutationVariables
  >(CreateCustomerPortalSessionDocument, options);
}
export type CreateCustomerPortalSessionMutationHookResult = ReturnType<
  typeof useCreateCustomerPortalSessionMutation
>;
export type CreateCustomerPortalSessionMutationResult =
  Apollo.MutationResult<CreateCustomerPortalSessionMutation>;
export type CreateCustomerPortalSessionMutationOptions =
  Apollo.BaseMutationOptions<
    CreateCustomerPortalSessionMutation,
    CreateCustomerPortalSessionMutationVariables
  >;
export const GetAvailableSubscriptionOptionsDocument = gql`
  query GetAvailableSubscriptionOptions {
    getAvailableSubscriptionOptions {
      trialPeriodDays
      products {
        id
        name
        description
        active
        prices {
          id
          currency
          unitAmount
          recurringInterval
          recurringIntervalCount
          type
          active
        }
      }
      appleIap {
        enabled
        proMonthlyProductId
        productIds
      }
      tierOptions {
        tierName
        tierDisplayName
        billingInterval
        platform
        isConfigured
        isAvailable
        stripeProductId
        stripePriceId
        appleProductId
        currency
        unitAmount
        recurringIntervalCount
      }
    }
  }
`;

/**
 * __useGetAvailableSubscriptionOptionsQuery__
 *
 * To run a query within a React component, call `useGetAvailableSubscriptionOptionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAvailableSubscriptionOptionsQuery` 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 } = useGetAvailableSubscriptionOptionsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetAvailableSubscriptionOptionsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >(GetAvailableSubscriptionOptionsDocument, options);
}
export function useGetAvailableSubscriptionOptionsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >(GetAvailableSubscriptionOptionsDocument, options);
}
export function useGetAvailableSubscriptionOptionsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetAvailableSubscriptionOptionsQuery,
    GetAvailableSubscriptionOptionsQueryVariables
  >(GetAvailableSubscriptionOptionsDocument, options);
}
export type GetAvailableSubscriptionOptionsQueryHookResult = ReturnType<
  typeof useGetAvailableSubscriptionOptionsQuery
>;
export type GetAvailableSubscriptionOptionsLazyQueryHookResult = ReturnType<
  typeof useGetAvailableSubscriptionOptionsLazyQuery
>;
export type GetAvailableSubscriptionOptionsSuspenseQueryHookResult = ReturnType<
  typeof useGetAvailableSubscriptionOptionsSuspenseQuery
>;
export type GetAvailableSubscriptionOptionsQueryResult = Apollo.QueryResult<
  GetAvailableSubscriptionOptionsQuery,
  GetAvailableSubscriptionOptionsQueryVariables
>;
export const GetSubscriptionStatusDocument = gql`
  query GetSubscriptionStatus {
    getUserSubscriptionStatus {
      hasActiveSubscription
      entitlementSource
      entitlementStartsAt
      entitlementEndsAt
      subscriptionStatus
      currentPeriodStart
      currentPeriodEnd
      validUntil
      stripePriceId
      stripeSubscriptionId
    }
  }
`;

/**
 * __useGetSubscriptionStatusQuery__
 *
 * To run a query within a React component, call `useGetSubscriptionStatusQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSubscriptionStatusQuery` 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 } = useGetSubscriptionStatusQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetSubscriptionStatusQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >(GetSubscriptionStatusDocument, options);
}
export function useGetSubscriptionStatusLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >(GetSubscriptionStatusDocument, options);
}
export function useGetSubscriptionStatusSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetSubscriptionStatusQuery,
    GetSubscriptionStatusQueryVariables
  >(GetSubscriptionStatusDocument, options);
}
export type GetSubscriptionStatusQueryHookResult = ReturnType<
  typeof useGetSubscriptionStatusQuery
>;
export type GetSubscriptionStatusLazyQueryHookResult = ReturnType<
  typeof useGetSubscriptionStatusLazyQuery
>;
export type GetSubscriptionStatusSuspenseQueryHookResult = ReturnType<
  typeof useGetSubscriptionStatusSuspenseQuery
>;
export type GetSubscriptionStatusQueryResult = Apollo.QueryResult<
  GetSubscriptionStatusQuery,
  GetSubscriptionStatusQueryVariables
>;
export const GetResolvedTierDocument = gql`
  query GetResolvedTier {
    getResolvedTier {
      tierName
      tierDisplayName
      hasActiveSubscription
      entitlementSource
      entitlementStatus
      entitlementStartsAt
      entitlementEndsAt
      capabilities
    }
  }
`;

/**
 * __useGetResolvedTierQuery__
 *
 * To run a query within a React component, call `useGetResolvedTierQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetResolvedTierQuery` 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 } = useGetResolvedTierQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetResolvedTierQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetResolvedTierQuery,
    GetResolvedTierQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetResolvedTierQuery, GetResolvedTierQueryVariables>(
    GetResolvedTierDocument,
    options,
  );
}
export function useGetResolvedTierLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetResolvedTierQuery,
    GetResolvedTierQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetResolvedTierQuery,
    GetResolvedTierQueryVariables
  >(GetResolvedTierDocument, options);
}
export function useGetResolvedTierSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetResolvedTierQuery,
    GetResolvedTierQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetResolvedTierQuery,
    GetResolvedTierQueryVariables
  >(GetResolvedTierDocument, options);
}
export type GetResolvedTierQueryHookResult = ReturnType<
  typeof useGetResolvedTierQuery
>;
export type GetResolvedTierLazyQueryHookResult = ReturnType<
  typeof useGetResolvedTierLazyQuery
>;
export type GetResolvedTierSuspenseQueryHookResult = ReturnType<
  typeof useGetResolvedTierSuspenseQuery
>;
export type GetResolvedTierQueryResult = Apollo.QueryResult<
  GetResolvedTierQuery,
  GetResolvedTierQueryVariables
>;
export const GetStorageStatusDocument = gql`
  query GetStorageStatus {
    getStorageStatus {
      userId
      tierName
      retainedStorageUsedBytes
      retainedStorageLimitBytes
      isUnlimited
      policyConfigured
      remainingStorageBytes
      storageUsageRatio
      isNearLimit
      isOverLimit
      usageCalculated
      usageSource
      lastCalculatedAt
    }
  }
`;

/**
 * __useGetStorageStatusQuery__
 *
 * To run a query within a React component, call `useGetStorageStatusQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetStorageStatusQuery` 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 } = useGetStorageStatusQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetStorageStatusQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetStorageStatusQuery,
    GetStorageStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetStorageStatusQuery, GetStorageStatusQueryVariables>(
    GetStorageStatusDocument,
    options,
  );
}
export function useGetStorageStatusLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetStorageStatusQuery,
    GetStorageStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetStorageStatusQuery,
    GetStorageStatusQueryVariables
  >(GetStorageStatusDocument, options);
}
export function useGetStorageStatusSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetStorageStatusQuery,
    GetStorageStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetStorageStatusQuery,
    GetStorageStatusQueryVariables
  >(GetStorageStatusDocument, options);
}
export type GetStorageStatusQueryHookResult = ReturnType<
  typeof useGetStorageStatusQuery
>;
export type GetStorageStatusLazyQueryHookResult = ReturnType<
  typeof useGetStorageStatusLazyQuery
>;
export type GetStorageStatusSuspenseQueryHookResult = ReturnType<
  typeof useGetStorageStatusSuspenseQuery
>;
export type GetStorageStatusQueryResult = Apollo.QueryResult<
  GetStorageStatusQuery,
  GetStorageStatusQueryVariables
>;
export const GetAppleAppAccountTokenDocument = gql`
  query GetAppleAppAccountToken {
    getAppleAppAccountToken
  }
`;

/**
 * __useGetAppleAppAccountTokenQuery__
 *
 * To run a query within a React component, call `useGetAppleAppAccountTokenQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAppleAppAccountTokenQuery` 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 } = useGetAppleAppAccountTokenQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetAppleAppAccountTokenQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >(GetAppleAppAccountTokenDocument, options);
}
export function useGetAppleAppAccountTokenLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >(GetAppleAppAccountTokenDocument, options);
}
export function useGetAppleAppAccountTokenSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetAppleAppAccountTokenQuery,
    GetAppleAppAccountTokenQueryVariables
  >(GetAppleAppAccountTokenDocument, options);
}
export type GetAppleAppAccountTokenQueryHookResult = ReturnType<
  typeof useGetAppleAppAccountTokenQuery
>;
export type GetAppleAppAccountTokenLazyQueryHookResult = ReturnType<
  typeof useGetAppleAppAccountTokenLazyQuery
>;
export type GetAppleAppAccountTokenSuspenseQueryHookResult = ReturnType<
  typeof useGetAppleAppAccountTokenSuspenseQuery
>;
export type GetAppleAppAccountTokenQueryResult = Apollo.QueryResult<
  GetAppleAppAccountTokenQuery,
  GetAppleAppAccountTokenQueryVariables
>;
export const SyncAppleSubscriptionDocument = gql`
  mutation SyncAppleSubscription($signedTransactionInfo: String!) {
    syncAppleSubscription(
      input: { signedTransactionInfo: $signedTransactionInfo }
    ) {
      ok
      errorCode
      errorMessage
      hasActiveSubscription
      entitlementSource
      entitlementStartsAt
      entitlementEndsAt
      appleStatus
      originalTransactionId
      latestTransactionId
      productId
      expiresAt
    }
  }
`;
export type SyncAppleSubscriptionMutationFn = Apollo.MutationFunction<
  SyncAppleSubscriptionMutation,
  SyncAppleSubscriptionMutationVariables
>;

/**
 * __useSyncAppleSubscriptionMutation__
 *
 * To run a mutation, you first call `useSyncAppleSubscriptionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSyncAppleSubscriptionMutation` 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 [syncAppleSubscriptionMutation, { data, loading, error }] = useSyncAppleSubscriptionMutation({
 *   variables: {
 *      signedTransactionInfo: // value for 'signedTransactionInfo'
 *   },
 * });
 */
export function useSyncAppleSubscriptionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    SyncAppleSubscriptionMutation,
    SyncAppleSubscriptionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    SyncAppleSubscriptionMutation,
    SyncAppleSubscriptionMutationVariables
  >(SyncAppleSubscriptionDocument, options);
}
export type SyncAppleSubscriptionMutationHookResult = ReturnType<
  typeof useSyncAppleSubscriptionMutation
>;
export type SyncAppleSubscriptionMutationResult =
  Apollo.MutationResult<SyncAppleSubscriptionMutation>;
export type SyncAppleSubscriptionMutationOptions = Apollo.BaseMutationOptions<
  SyncAppleSubscriptionMutation,
  SyncAppleSubscriptionMutationVariables
>;
export const CancelSubscriptionDocument = gql`
  mutation CancelSubscription {
    cancelSubscription {
      hasActiveSubscription
      entitlementSource
      entitlementStartsAt
      entitlementEndsAt
      subscriptionStatus
      currentPeriodStart
      currentPeriodEnd
      validUntil
      stripePriceId
      stripeSubscriptionId
    }
  }
`;
export type CancelSubscriptionMutationFn = Apollo.MutationFunction<
  CancelSubscriptionMutation,
  CancelSubscriptionMutationVariables
>;

/**
 * __useCancelSubscriptionMutation__
 *
 * To run a mutation, you first call `useCancelSubscriptionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCancelSubscriptionMutation` 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 [cancelSubscriptionMutation, { data, loading, error }] = useCancelSubscriptionMutation({
 *   variables: {
 *   },
 * });
 */
export function useCancelSubscriptionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CancelSubscriptionMutation,
    CancelSubscriptionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CancelSubscriptionMutation,
    CancelSubscriptionMutationVariables
  >(CancelSubscriptionDocument, options);
}
export type CancelSubscriptionMutationHookResult = ReturnType<
  typeof useCancelSubscriptionMutation
>;
export type CancelSubscriptionMutationResult =
  Apollo.MutationResult<CancelSubscriptionMutation>;
export type CancelSubscriptionMutationOptions = Apollo.BaseMutationOptions<
  CancelSubscriptionMutation,
  CancelSubscriptionMutationVariables
>;
export const SubmitCancellationFeedbackDocument = gql`
  mutation SubmitCancellationFeedback(
    $reasons: [CancellationReasonEnum!]
    $feedback: String
    $metadata: CancellationFeedbackMetadataInput
  ) {
    submitCancellationFeedback(
      reasons: $reasons
      feedback: $feedback
      metadata: $metadata
    )
  }
`;
export type SubmitCancellationFeedbackMutationFn = Apollo.MutationFunction<
  SubmitCancellationFeedbackMutation,
  SubmitCancellationFeedbackMutationVariables
>;

/**
 * __useSubmitCancellationFeedbackMutation__
 *
 * To run a mutation, you first call `useSubmitCancellationFeedbackMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSubmitCancellationFeedbackMutation` 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 [submitCancellationFeedbackMutation, { data, loading, error }] = useSubmitCancellationFeedbackMutation({
 *   variables: {
 *      reasons: // value for 'reasons'
 *      feedback: // value for 'feedback'
 *      metadata: // value for 'metadata'
 *   },
 * });
 */
export function useSubmitCancellationFeedbackMutation(
  baseOptions?: Apollo.MutationHookOptions<
    SubmitCancellationFeedbackMutation,
    SubmitCancellationFeedbackMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    SubmitCancellationFeedbackMutation,
    SubmitCancellationFeedbackMutationVariables
  >(SubmitCancellationFeedbackDocument, options);
}
export type SubmitCancellationFeedbackMutationHookResult = ReturnType<
  typeof useSubmitCancellationFeedbackMutation
>;
export type SubmitCancellationFeedbackMutationResult =
  Apollo.MutationResult<SubmitCancellationFeedbackMutation>;
export type SubmitCancellationFeedbackMutationOptions =
  Apollo.BaseMutationOptions<
    SubmitCancellationFeedbackMutation,
    SubmitCancellationFeedbackMutationVariables
  >;
export const GetPoolHallsDocument = gql`
  query GetPoolHalls {
    poolHalls {
      ...PoolHallFields
    }
  }
  ${PoolHallFieldsFragmentDoc}
`;

/**
 * __useGetPoolHallsQuery__
 *
 * To run a query within a React component, call `useGetPoolHallsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPoolHallsQuery` 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 } = useGetPoolHallsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetPoolHallsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetPoolHallsQuery,
    GetPoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetPoolHallsQuery, GetPoolHallsQueryVariables>(
    GetPoolHallsDocument,
    options,
  );
}
export function useGetPoolHallsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetPoolHallsQuery,
    GetPoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetPoolHallsQuery, GetPoolHallsQueryVariables>(
    GetPoolHallsDocument,
    options,
  );
}
export function useGetPoolHallsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetPoolHallsQuery,
    GetPoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetPoolHallsQuery, GetPoolHallsQueryVariables>(
    GetPoolHallsDocument,
    options,
  );
}
export type GetPoolHallsQueryHookResult = ReturnType<
  typeof useGetPoolHallsQuery
>;
export type GetPoolHallsLazyQueryHookResult = ReturnType<
  typeof useGetPoolHallsLazyQuery
>;
export type GetPoolHallsSuspenseQueryHookResult = ReturnType<
  typeof useGetPoolHallsSuspenseQuery
>;
export type GetPoolHallsQueryResult = Apollo.QueryResult<
  GetPoolHallsQuery,
  GetPoolHallsQueryVariables
>;
export const GetClaimablePoolHallsDocument = gql`
  query GetClaimablePoolHalls {
    claimablePoolHalls {
      ...PoolHallFields
    }
  }
  ${PoolHallFieldsFragmentDoc}
`;

/**
 * __useGetClaimablePoolHallsQuery__
 *
 * To run a query within a React component, call `useGetClaimablePoolHallsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetClaimablePoolHallsQuery` 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 } = useGetClaimablePoolHallsQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetClaimablePoolHallsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >(GetClaimablePoolHallsDocument, options);
}
export function useGetClaimablePoolHallsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >(GetClaimablePoolHallsDocument, options);
}
export function useGetClaimablePoolHallsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetClaimablePoolHallsQuery,
    GetClaimablePoolHallsQueryVariables
  >(GetClaimablePoolHallsDocument, options);
}
export type GetClaimablePoolHallsQueryHookResult = ReturnType<
  typeof useGetClaimablePoolHallsQuery
>;
export type GetClaimablePoolHallsLazyQueryHookResult = ReturnType<
  typeof useGetClaimablePoolHallsLazyQuery
>;
export type GetClaimablePoolHallsSuspenseQueryHookResult = ReturnType<
  typeof useGetClaimablePoolHallsSuspenseQuery
>;
export type GetClaimablePoolHallsQueryResult = Apollo.QueryResult<
  GetClaimablePoolHallsQuery,
  GetClaimablePoolHallsQueryVariables
>;
export const GetPoolHallCamerasDocument = gql`
  query GetPoolHallCameras($poolHallId: ID!) {
    poolHallCameras(poolHallId: $poolHallId) {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;

/**
 * __useGetPoolHallCamerasQuery__
 *
 * To run a query within a React component, call `useGetPoolHallCamerasQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPoolHallCamerasQuery` 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 } = useGetPoolHallCamerasQuery({
 *   variables: {
 *      poolHallId: // value for 'poolHallId'
 *   },
 * });
 */
export function useGetPoolHallCamerasQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >(GetPoolHallCamerasDocument, options);
}
export function useGetPoolHallCamerasLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >(GetPoolHallCamerasDocument, options);
}
export function useGetPoolHallCamerasSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetPoolHallCamerasQuery,
    GetPoolHallCamerasQueryVariables
  >(GetPoolHallCamerasDocument, options);
}
export type GetPoolHallCamerasQueryHookResult = ReturnType<
  typeof useGetPoolHallCamerasQuery
>;
export type GetPoolHallCamerasLazyQueryHookResult = ReturnType<
  typeof useGetPoolHallCamerasLazyQuery
>;
export type GetPoolHallCamerasSuspenseQueryHookResult = ReturnType<
  typeof useGetPoolHallCamerasSuspenseQuery
>;
export type GetPoolHallCamerasQueryResult = Apollo.QueryResult<
  GetPoolHallCamerasQuery,
  GetPoolHallCamerasQueryVariables
>;
export const GetClaimableCamerasDocument = gql`
  query GetClaimableCameras($poolHallId: ID!) {
    claimableCameras(poolHallId: $poolHallId) {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;

/**
 * __useGetClaimableCamerasQuery__
 *
 * To run a query within a React component, call `useGetClaimableCamerasQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetClaimableCamerasQuery` 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 } = useGetClaimableCamerasQuery({
 *   variables: {
 *      poolHallId: // value for 'poolHallId'
 *   },
 * });
 */
export function useGetClaimableCamerasQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >(GetClaimableCamerasDocument, options);
}
export function useGetClaimableCamerasLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >(GetClaimableCamerasDocument, options);
}
export function useGetClaimableCamerasSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetClaimableCamerasQuery,
    GetClaimableCamerasQueryVariables
  >(GetClaimableCamerasDocument, options);
}
export type GetClaimableCamerasQueryHookResult = ReturnType<
  typeof useGetClaimableCamerasQuery
>;
export type GetClaimableCamerasLazyQueryHookResult = ReturnType<
  typeof useGetClaimableCamerasLazyQuery
>;
export type GetClaimableCamerasSuspenseQueryHookResult = ReturnType<
  typeof useGetClaimableCamerasSuspenseQuery
>;
export type GetClaimableCamerasQueryResult = Apollo.QueryResult<
  GetClaimableCamerasQuery,
  GetClaimableCamerasQueryVariables
>;
export const GetCameraClaimSessionDocument = gql`
  query GetCameraClaimSession($id: ID!) {
    cameraClaimSession(id: $id) {
      ...CameraClaimSessionFields
    }
  }
  ${CameraClaimSessionFieldsFragmentDoc}
`;

/**
 * __useGetCameraClaimSessionQuery__
 *
 * To run a query within a React component, call `useGetCameraClaimSessionQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetCameraClaimSessionQuery` 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 } = useGetCameraClaimSessionQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export function useGetCameraClaimSessionQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >(GetCameraClaimSessionDocument, options);
}
export function useGetCameraClaimSessionLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >(GetCameraClaimSessionDocument, options);
}
export function useGetCameraClaimSessionSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetCameraClaimSessionQuery,
    GetCameraClaimSessionQueryVariables
  >(GetCameraClaimSessionDocument, options);
}
export type GetCameraClaimSessionQueryHookResult = ReturnType<
  typeof useGetCameraClaimSessionQuery
>;
export type GetCameraClaimSessionLazyQueryHookResult = ReturnType<
  typeof useGetCameraClaimSessionLazyQuery
>;
export type GetCameraClaimSessionSuspenseQueryHookResult = ReturnType<
  typeof useGetCameraClaimSessionSuspenseQuery
>;
export type GetCameraClaimSessionQueryResult = Apollo.QueryResult<
  GetCameraClaimSessionQuery,
  GetCameraClaimSessionQueryVariables
>;
export const GetActiveCameraLeaseDocument = gql`
  query GetActiveCameraLease {
    activeCameraLease {
      ...CameraLeaseFields
    }
  }
  ${CameraLeaseFieldsFragmentDoc}
`;

/**
 * __useGetActiveCameraLeaseQuery__
 *
 * To run a query within a React component, call `useGetActiveCameraLeaseQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetActiveCameraLeaseQuery` 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 } = useGetActiveCameraLeaseQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetActiveCameraLeaseQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >(GetActiveCameraLeaseDocument, options);
}
export function useGetActiveCameraLeaseLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >(GetActiveCameraLeaseDocument, options);
}
export function useGetActiveCameraLeaseSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetActiveCameraLeaseQuery,
    GetActiveCameraLeaseQueryVariables
  >(GetActiveCameraLeaseDocument, options);
}
export type GetActiveCameraLeaseQueryHookResult = ReturnType<
  typeof useGetActiveCameraLeaseQuery
>;
export type GetActiveCameraLeaseLazyQueryHookResult = ReturnType<
  typeof useGetActiveCameraLeaseLazyQuery
>;
export type GetActiveCameraLeaseSuspenseQueryHookResult = ReturnType<
  typeof useGetActiveCameraLeaseSuspenseQuery
>;
export type GetActiveCameraLeaseQueryResult = Apollo.QueryResult<
  GetActiveCameraLeaseQuery,
  GetActiveCameraLeaseQueryVariables
>;
export const CreatePoolHallDocument = gql`
  mutation CreatePoolHall($input: CreatePoolHallInput!) {
    createPoolHall(input: $input) {
      ...PoolHallFields
    }
  }
  ${PoolHallFieldsFragmentDoc}
`;
export type CreatePoolHallMutationFn = Apollo.MutationFunction<
  CreatePoolHallMutation,
  CreatePoolHallMutationVariables
>;

/**
 * __useCreatePoolHallMutation__
 *
 * To run a mutation, you first call `useCreatePoolHallMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreatePoolHallMutation` 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 [createPoolHallMutation, { data, loading, error }] = useCreatePoolHallMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreatePoolHallMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreatePoolHallMutation,
    CreatePoolHallMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreatePoolHallMutation,
    CreatePoolHallMutationVariables
  >(CreatePoolHallDocument, options);
}
export type CreatePoolHallMutationHookResult = ReturnType<
  typeof useCreatePoolHallMutation
>;
export type CreatePoolHallMutationResult =
  Apollo.MutationResult<CreatePoolHallMutation>;
export type CreatePoolHallMutationOptions = Apollo.BaseMutationOptions<
  CreatePoolHallMutation,
  CreatePoolHallMutationVariables
>;
export const UpdatePoolHallDocument = gql`
  mutation UpdatePoolHall($input: UpdatePoolHallInput!) {
    updatePoolHall(input: $input) {
      ...PoolHallFields
    }
  }
  ${PoolHallFieldsFragmentDoc}
`;
export type UpdatePoolHallMutationFn = Apollo.MutationFunction<
  UpdatePoolHallMutation,
  UpdatePoolHallMutationVariables
>;

/**
 * __useUpdatePoolHallMutation__
 *
 * To run a mutation, you first call `useUpdatePoolHallMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdatePoolHallMutation` 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 [updatePoolHallMutation, { data, loading, error }] = useUpdatePoolHallMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdatePoolHallMutation(
  baseOptions?: Apollo.MutationHookOptions<
    UpdatePoolHallMutation,
    UpdatePoolHallMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    UpdatePoolHallMutation,
    UpdatePoolHallMutationVariables
  >(UpdatePoolHallDocument, options);
}
export type UpdatePoolHallMutationHookResult = ReturnType<
  typeof useUpdatePoolHallMutation
>;
export type UpdatePoolHallMutationResult =
  Apollo.MutationResult<UpdatePoolHallMutation>;
export type UpdatePoolHallMutationOptions = Apollo.BaseMutationOptions<
  UpdatePoolHallMutation,
  UpdatePoolHallMutationVariables
>;
export const CreatePoolHallCameraDocument = gql`
  mutation CreatePoolHallCamera($input: CreatePoolHallCameraInput!) {
    createPoolHallCamera(input: $input) {
      ...PoolHallCameraStreamCredentialsFields
    }
  }
  ${PoolHallCameraStreamCredentialsFieldsFragmentDoc}
`;
export type CreatePoolHallCameraMutationFn = Apollo.MutationFunction<
  CreatePoolHallCameraMutation,
  CreatePoolHallCameraMutationVariables
>;

/**
 * __useCreatePoolHallCameraMutation__
 *
 * To run a mutation, you first call `useCreatePoolHallCameraMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreatePoolHallCameraMutation` 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 [createPoolHallCameraMutation, { data, loading, error }] = useCreatePoolHallCameraMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useCreatePoolHallCameraMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreatePoolHallCameraMutation,
    CreatePoolHallCameraMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreatePoolHallCameraMutation,
    CreatePoolHallCameraMutationVariables
  >(CreatePoolHallCameraDocument, options);
}
export type CreatePoolHallCameraMutationHookResult = ReturnType<
  typeof useCreatePoolHallCameraMutation
>;
export type CreatePoolHallCameraMutationResult =
  Apollo.MutationResult<CreatePoolHallCameraMutation>;
export type CreatePoolHallCameraMutationOptions = Apollo.BaseMutationOptions<
  CreatePoolHallCameraMutation,
  CreatePoolHallCameraMutationVariables
>;
export const UpdatePoolHallCameraDocument = gql`
  mutation UpdatePoolHallCamera($input: UpdatePoolHallCameraInput!) {
    updatePoolHallCamera(input: $input) {
      ...PoolHallCameraWithHallFields
    }
  }
  ${PoolHallCameraWithHallFieldsFragmentDoc}
`;
export type UpdatePoolHallCameraMutationFn = Apollo.MutationFunction<
  UpdatePoolHallCameraMutation,
  UpdatePoolHallCameraMutationVariables
>;

/**
 * __useUpdatePoolHallCameraMutation__
 *
 * To run a mutation, you first call `useUpdatePoolHallCameraMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdatePoolHallCameraMutation` 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 [updatePoolHallCameraMutation, { data, loading, error }] = useUpdatePoolHallCameraMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useUpdatePoolHallCameraMutation(
  baseOptions?: Apollo.MutationHookOptions<
    UpdatePoolHallCameraMutation,
    UpdatePoolHallCameraMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    UpdatePoolHallCameraMutation,
    UpdatePoolHallCameraMutationVariables
  >(UpdatePoolHallCameraDocument, options);
}
export type UpdatePoolHallCameraMutationHookResult = ReturnType<
  typeof useUpdatePoolHallCameraMutation
>;
export type UpdatePoolHallCameraMutationResult =
  Apollo.MutationResult<UpdatePoolHallCameraMutation>;
export type UpdatePoolHallCameraMutationOptions = Apollo.BaseMutationOptions<
  UpdatePoolHallCameraMutation,
  UpdatePoolHallCameraMutationVariables
>;
export const RotatePoolHallCameraStreamKeyDocument = gql`
  mutation RotatePoolHallCameraStreamKey($cameraId: ID!) {
    rotatePoolHallCameraStreamKey(cameraId: $cameraId) {
      ...PoolHallCameraStreamCredentialsFields
    }
  }
  ${PoolHallCameraStreamCredentialsFieldsFragmentDoc}
`;
export type RotatePoolHallCameraStreamKeyMutationFn = Apollo.MutationFunction<
  RotatePoolHallCameraStreamKeyMutation,
  RotatePoolHallCameraStreamKeyMutationVariables
>;

/**
 * __useRotatePoolHallCameraStreamKeyMutation__
 *
 * To run a mutation, you first call `useRotatePoolHallCameraStreamKeyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRotatePoolHallCameraStreamKeyMutation` 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 [rotatePoolHallCameraStreamKeyMutation, { data, loading, error }] = useRotatePoolHallCameraStreamKeyMutation({
 *   variables: {
 *      cameraId: // value for 'cameraId'
 *   },
 * });
 */
export function useRotatePoolHallCameraStreamKeyMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RotatePoolHallCameraStreamKeyMutation,
    RotatePoolHallCameraStreamKeyMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    RotatePoolHallCameraStreamKeyMutation,
    RotatePoolHallCameraStreamKeyMutationVariables
  >(RotatePoolHallCameraStreamKeyDocument, options);
}
export type RotatePoolHallCameraStreamKeyMutationHookResult = ReturnType<
  typeof useRotatePoolHallCameraStreamKeyMutation
>;
export type RotatePoolHallCameraStreamKeyMutationResult =
  Apollo.MutationResult<RotatePoolHallCameraStreamKeyMutation>;
export type RotatePoolHallCameraStreamKeyMutationOptions =
  Apollo.BaseMutationOptions<
    RotatePoolHallCameraStreamKeyMutation,
    RotatePoolHallCameraStreamKeyMutationVariables
  >;
export const CreateCameraClaimSessionDocument = gql`
  mutation CreateCameraClaimSession(
    $cameraId: ID!
    $durationMinutes: Int
    $videoName: String
    $videoPrivate: Boolean
    $agreedTermsVersion: Int
    $tags: [VideoTagInput!]
  ) {
    createCameraClaimSession(
      cameraId: $cameraId
      durationMinutes: $durationMinutes
      videoName: $videoName
      videoPrivate: $videoPrivate
      agreedTermsVersion: $agreedTermsVersion
      tags: $tags
    ) {
      ...CameraClaimSessionFields
    }
  }
  ${CameraClaimSessionFieldsFragmentDoc}
`;
export type CreateCameraClaimSessionMutationFn = Apollo.MutationFunction<
  CreateCameraClaimSessionMutation,
  CreateCameraClaimSessionMutationVariables
>;

/**
 * __useCreateCameraClaimSessionMutation__
 *
 * To run a mutation, you first call `useCreateCameraClaimSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCameraClaimSessionMutation` 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 [createCameraClaimSessionMutation, { data, loading, error }] = useCreateCameraClaimSessionMutation({
 *   variables: {
 *      cameraId: // value for 'cameraId'
 *      durationMinutes: // value for 'durationMinutes'
 *      videoName: // value for 'videoName'
 *      videoPrivate: // value for 'videoPrivate'
 *      agreedTermsVersion: // value for 'agreedTermsVersion'
 *      tags: // value for 'tags'
 *   },
 * });
 */
export function useCreateCameraClaimSessionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CreateCameraClaimSessionMutation,
    CreateCameraClaimSessionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CreateCameraClaimSessionMutation,
    CreateCameraClaimSessionMutationVariables
  >(CreateCameraClaimSessionDocument, options);
}
export type CreateCameraClaimSessionMutationHookResult = ReturnType<
  typeof useCreateCameraClaimSessionMutation
>;
export type CreateCameraClaimSessionMutationResult =
  Apollo.MutationResult<CreateCameraClaimSessionMutation>;
export type CreateCameraClaimSessionMutationOptions =
  Apollo.BaseMutationOptions<
    CreateCameraClaimSessionMutation,
    CreateCameraClaimSessionMutationVariables
  >;
export const CancelCameraClaimSessionDocument = gql`
  mutation CancelCameraClaimSession($claimSessionId: ID!) {
    cancelCameraClaimSession(claimSessionId: $claimSessionId) {
      ...CameraClaimSessionFields
    }
  }
  ${CameraClaimSessionFieldsFragmentDoc}
`;
export type CancelCameraClaimSessionMutationFn = Apollo.MutationFunction<
  CancelCameraClaimSessionMutation,
  CancelCameraClaimSessionMutationVariables
>;

/**
 * __useCancelCameraClaimSessionMutation__
 *
 * To run a mutation, you first call `useCancelCameraClaimSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCancelCameraClaimSessionMutation` 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 [cancelCameraClaimSessionMutation, { data, loading, error }] = useCancelCameraClaimSessionMutation({
 *   variables: {
 *      claimSessionId: // value for 'claimSessionId'
 *   },
 * });
 */
export function useCancelCameraClaimSessionMutation(
  baseOptions?: Apollo.MutationHookOptions<
    CancelCameraClaimSessionMutation,
    CancelCameraClaimSessionMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    CancelCameraClaimSessionMutation,
    CancelCameraClaimSessionMutationVariables
  >(CancelCameraClaimSessionDocument, options);
}
export type CancelCameraClaimSessionMutationHookResult = ReturnType<
  typeof useCancelCameraClaimSessionMutation
>;
export type CancelCameraClaimSessionMutationResult =
  Apollo.MutationResult<CancelCameraClaimSessionMutation>;
export type CancelCameraClaimSessionMutationOptions =
  Apollo.BaseMutationOptions<
    CancelCameraClaimSessionMutation,
    CancelCameraClaimSessionMutationVariables
  >;
export const EndCameraLeaseDocument = gql`
  mutation EndCameraLease($leaseId: ID!) {
    endCameraLease(leaseId: $leaseId) {
      ...CameraLeaseFields
    }
  }
  ${CameraLeaseFieldsFragmentDoc}
`;
export type EndCameraLeaseMutationFn = Apollo.MutationFunction<
  EndCameraLeaseMutation,
  EndCameraLeaseMutationVariables
>;

/**
 * __useEndCameraLeaseMutation__
 *
 * To run a mutation, you first call `useEndCameraLeaseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEndCameraLeaseMutation` 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 [endCameraLeaseMutation, { data, loading, error }] = useEndCameraLeaseMutation({
 *   variables: {
 *      leaseId: // value for 'leaseId'
 *   },
 * });
 */
export function useEndCameraLeaseMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EndCameraLeaseMutation,
    EndCameraLeaseMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    EndCameraLeaseMutation,
    EndCameraLeaseMutationVariables
  >(EndCameraLeaseDocument, options);
}
export type EndCameraLeaseMutationHookResult = ReturnType<
  typeof useEndCameraLeaseMutation
>;
export type EndCameraLeaseMutationResult =
  Apollo.MutationResult<EndCameraLeaseMutation>;
export type EndCameraLeaseMutationOptions = Apollo.BaseMutationOptions<
  EndCameraLeaseMutation,
  EndCameraLeaseMutationVariables
>;
export const ExtendCameraLeaseDocument = gql`
  mutation ExtendCameraLease($leaseId: ID!, $additionalMinutes: Int! = 60) {
    extendCameraLease(
      leaseId: $leaseId
      additionalMinutes: $additionalMinutes
    ) {
      ...CameraLeaseFields
    }
  }
  ${CameraLeaseFieldsFragmentDoc}
`;
export type ExtendCameraLeaseMutationFn = Apollo.MutationFunction<
  ExtendCameraLeaseMutation,
  ExtendCameraLeaseMutationVariables
>;

/**
 * __useExtendCameraLeaseMutation__
 *
 * To run a mutation, you first call `useExtendCameraLeaseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useExtendCameraLeaseMutation` 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 [extendCameraLeaseMutation, { data, loading, error }] = useExtendCameraLeaseMutation({
 *   variables: {
 *      leaseId: // value for 'leaseId'
 *      additionalMinutes: // value for 'additionalMinutes'
 *   },
 * });
 */
export function useExtendCameraLeaseMutation(
  baseOptions?: Apollo.MutationHookOptions<
    ExtendCameraLeaseMutation,
    ExtendCameraLeaseMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    ExtendCameraLeaseMutation,
    ExtendCameraLeaseMutationVariables
  >(ExtendCameraLeaseDocument, options);
}
export type ExtendCameraLeaseMutationHookResult = ReturnType<
  typeof useExtendCameraLeaseMutation
>;
export type ExtendCameraLeaseMutationResult =
  Apollo.MutationResult<ExtendCameraLeaseMutation>;
export type ExtendCameraLeaseMutationOptions = Apollo.BaseMutationOptions<
  ExtendCameraLeaseMutation,
  ExtendCameraLeaseMutationVariables
>;
export const ReactToVideoDocument = gql`
  mutation ReactToVideo($videoId: Int!, $reaction: ReactionEnum) {
    reactToVideo(videoId: $videoId, reaction: $reaction)
  }
`;
export type ReactToVideoMutationFn = Apollo.MutationFunction<
  ReactToVideoMutation,
  ReactToVideoMutationVariables
>;

/**
 * __useReactToVideoMutation__
 *
 * To run a mutation, you first call `useReactToVideoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReactToVideoMutation` 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 [reactToVideoMutation, { data, loading, error }] = useReactToVideoMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      reaction: // value for 'reaction'
 *   },
 * });
 */
export function useReactToVideoMutation(
  baseOptions?: Apollo.MutationHookOptions<
    ReactToVideoMutation,
    ReactToVideoMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    ReactToVideoMutation,
    ReactToVideoMutationVariables
  >(ReactToVideoDocument, options);
}
export type ReactToVideoMutationHookResult = ReturnType<
  typeof useReactToVideoMutation
>;
export type ReactToVideoMutationResult =
  Apollo.MutationResult<ReactToVideoMutation>;
export type ReactToVideoMutationOptions = Apollo.BaseMutationOptions<
  ReactToVideoMutation,
  ReactToVideoMutationVariables
>;
export const GetShotLabVideosDocument = gql`
  query GetShotLabVideos($userId: Int!, $limit: Int! = 25) {
    getFeedVideos(
      limit: $limit
      includeCallersVideos: false
      includePrivate: MINE
      feedInput: { userId: $userId }
    ) {
      videos {
        id
        name
        createdAt
        screenshotUri
        framesPerSecond
        totalShots
        owner {
          id
          username
          profileImageUri
        }
        stream {
          id
          isCompleted
          lastSegmentUploadedAt
        }
      }
    }
  }
`;

/**
 * __useGetShotLabVideosQuery__
 *
 * To run a query within a React component, call `useGetShotLabVideosQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotLabVideosQuery` 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 } = useGetShotLabVideosQuery({
 *   variables: {
 *      userId: // value for 'userId'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetShotLabVideosQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotLabVideosQuery,
    GetShotLabVideosQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetShotLabVideosQuery, GetShotLabVideosQueryVariables>(
    GetShotLabVideosDocument,
    options,
  );
}
export function useGetShotLabVideosLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotLabVideosQuery,
    GetShotLabVideosQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotLabVideosQuery,
    GetShotLabVideosQueryVariables
  >(GetShotLabVideosDocument, options);
}
export function useGetShotLabVideosSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotLabVideosQuery,
    GetShotLabVideosQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotLabVideosQuery,
    GetShotLabVideosQueryVariables
  >(GetShotLabVideosDocument, options);
}
export type GetShotLabVideosQueryHookResult = ReturnType<
  typeof useGetShotLabVideosQuery
>;
export type GetShotLabVideosLazyQueryHookResult = ReturnType<
  typeof useGetShotLabVideosLazyQuery
>;
export type GetShotLabVideosSuspenseQueryHookResult = ReturnType<
  typeof useGetShotLabVideosSuspenseQuery
>;
export type GetShotLabVideosQueryResult = Apollo.QueryResult<
  GetShotLabVideosQuery,
  GetShotLabVideosQueryVariables
>;
export const GetRecordedStreamShotsDocument = gql`
  query GetRecordedStreamShots($videoId: Int!, $limit: Int! = 200) {
    getOrderedShots(
      filterInput: { videoId: [$videoId] }
      shotsOrdering: { orderings: [{ startFrame: { descending: false } }] }
      limit: $limit
    ) {
      shots {
        id
        videoId
        startFrame
        endFrame
        serializedShotPaths {
          b64EncodedBuffer
        }
        pocketingIntentionFeatures {
          make
        }
        pocketingIntentionInfo {
          pocketId
        }
      }
    }
  }
`;

/**
 * __useGetRecordedStreamShotsQuery__
 *
 * To run a query within a React component, call `useGetRecordedStreamShotsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRecordedStreamShotsQuery` 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 } = useGetRecordedStreamShotsQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetRecordedStreamShotsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >(GetRecordedStreamShotsDocument, options);
}
export function useGetRecordedStreamShotsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >(GetRecordedStreamShotsDocument, options);
}
export function useGetRecordedStreamShotsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetRecordedStreamShotsQuery,
    GetRecordedStreamShotsQueryVariables
  >(GetRecordedStreamShotsDocument, options);
}
export type GetRecordedStreamShotsQueryHookResult = ReturnType<
  typeof useGetRecordedStreamShotsQuery
>;
export type GetRecordedStreamShotsLazyQueryHookResult = ReturnType<
  typeof useGetRecordedStreamShotsLazyQuery
>;
export type GetRecordedStreamShotsSuspenseQueryHookResult = ReturnType<
  typeof useGetRecordedStreamShotsSuspenseQuery
>;
export type GetRecordedStreamShotsQueryResult = Apollo.QueryResult<
  GetRecordedStreamShotsQuery,
  GetRecordedStreamShotsQueryVariables
>;
export const GetRunsForHighlightsDocument = gql`
  query GetRunsForHighlights(
    $filterInput: RunFilterInput!
    $runIds: [Int!] = null
    $runsOrdering: GetRunsOrdering
    $limit: Int! = 500
    $countRespectsLimit: Boolean! = false
  ) {
    getRuns(
      filterInput: $filterInput
      runIds: $runIds
      runsOrdering: $runsOrdering
      limit: $limit
      countRespectsLimit: $countRespectsLimit
    ) {
      count
      runs {
        id
        runLength
        userId
        videoId
        shots {
          videoId
          id
        }
      }
      runIds
    }
  }
`;

/**
 * __useGetRunsForHighlightsQuery__
 *
 * To run a query within a React component, call `useGetRunsForHighlightsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRunsForHighlightsQuery` 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 } = useGetRunsForHighlightsQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      runIds: // value for 'runIds'
 *      runsOrdering: // value for 'runsOrdering'
 *      limit: // value for 'limit'
 *      countRespectsLimit: // value for 'countRespectsLimit'
 *   },
 * });
 */
export function useGetRunsForHighlightsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >(GetRunsForHighlightsDocument, options);
}
export function useGetRunsForHighlightsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >(GetRunsForHighlightsDocument, options);
}
export function useGetRunsForHighlightsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetRunsForHighlightsQuery,
    GetRunsForHighlightsQueryVariables
  >(GetRunsForHighlightsDocument, options);
}
export type GetRunsForHighlightsQueryHookResult = ReturnType<
  typeof useGetRunsForHighlightsQuery
>;
export type GetRunsForHighlightsLazyQueryHookResult = ReturnType<
  typeof useGetRunsForHighlightsLazyQuery
>;
export type GetRunsForHighlightsSuspenseQueryHookResult = ReturnType<
  typeof useGetRunsForHighlightsSuspenseQuery
>;
export type GetRunsForHighlightsQueryResult = Apollo.QueryResult<
  GetRunsForHighlightsQuery,
  GetRunsForHighlightsQueryVariables
>;
export const GetRunsWithTimestampsDocument = gql`
  query GetRunsWithTimestamps(
    $filterInput: RunFilterInput!
    $runIds: [Int!] = null
    $runsOrdering: GetRunsOrdering
  ) {
    getRuns(
      filterInput: $filterInput
      runIds: $runIds
      runsOrdering: $runsOrdering
    ) {
      count
      runs {
        id
        runLength
        userId
        videoId
        shots {
          videoId
          id
          createdAt
          pocketingIntentionFeatures {
            ...PocketingIntentionFragment
          }
        }
      }
      runIds
    }
  }
  ${PocketingIntentionFragmentFragmentDoc}
`;

/**
 * __useGetRunsWithTimestampsQuery__
 *
 * To run a query within a React component, call `useGetRunsWithTimestampsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRunsWithTimestampsQuery` 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 } = useGetRunsWithTimestampsQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      runIds: // value for 'runIds'
 *      runsOrdering: // value for 'runsOrdering'
 *   },
 * });
 */
export function useGetRunsWithTimestampsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >(GetRunsWithTimestampsDocument, options);
}
export function useGetRunsWithTimestampsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >(GetRunsWithTimestampsDocument, options);
}
export function useGetRunsWithTimestampsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetRunsWithTimestampsQuery,
    GetRunsWithTimestampsQueryVariables
  >(GetRunsWithTimestampsDocument, options);
}
export type GetRunsWithTimestampsQueryHookResult = ReturnType<
  typeof useGetRunsWithTimestampsQuery
>;
export type GetRunsWithTimestampsLazyQueryHookResult = ReturnType<
  typeof useGetRunsWithTimestampsLazyQuery
>;
export type GetRunsWithTimestampsSuspenseQueryHookResult = ReturnType<
  typeof useGetRunsWithTimestampsSuspenseQuery
>;
export type GetRunsWithTimestampsQueryResult = Apollo.QueryResult<
  GetRunsWithTimestampsQuery,
  GetRunsWithTimestampsQueryVariables
>;
export const GetSessionCoachDocument = gql`
  query GetSessionCoach($videoId: Int!) {
    getSessionCoach(videoId: $videoId) {
      videoId
      processingId
      analysisVersion
      state
      generatedAt
      processingStatus
      ineligibilityReason
      summary
      shotCount
      madeCount
      missedCount
      unknownOutcomeCount
      analyzedShotCount
      makePercentage
      primaryCandidate {
        ...SessionCoachCandidateFields
      }
      candidates {
        ...SessionCoachCandidateFields
      }
      agentGeneration {
        ...SessionCoachGenerationFields
      }
    }
  }
  ${SessionCoachCandidateFieldsFragmentDoc}
  ${SessionCoachGenerationFieldsFragmentDoc}
`;

/**
 * __useGetSessionCoachQuery__
 *
 * To run a query within a React component, call `useGetSessionCoachQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSessionCoachQuery` 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 } = useGetSessionCoachQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetSessionCoachQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetSessionCoachQuery,
    GetSessionCoachQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetSessionCoachQuery, GetSessionCoachQueryVariables>(
    GetSessionCoachDocument,
    options,
  );
}
export function useGetSessionCoachLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetSessionCoachQuery,
    GetSessionCoachQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetSessionCoachQuery,
    GetSessionCoachQueryVariables
  >(GetSessionCoachDocument, options);
}
export function useGetSessionCoachSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetSessionCoachQuery,
    GetSessionCoachQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetSessionCoachQuery,
    GetSessionCoachQueryVariables
  >(GetSessionCoachDocument, options);
}
export type GetSessionCoachQueryHookResult = ReturnType<
  typeof useGetSessionCoachQuery
>;
export type GetSessionCoachLazyQueryHookResult = ReturnType<
  typeof useGetSessionCoachLazyQuery
>;
export type GetSessionCoachSuspenseQueryHookResult = ReturnType<
  typeof useGetSessionCoachSuspenseQuery
>;
export type GetSessionCoachQueryResult = Apollo.QueryResult<
  GetSessionCoachQuery,
  GetSessionCoachQueryVariables
>;
export const RequestSessionCoachGenerationDocument = gql`
  mutation RequestSessionCoachGeneration($videoId: Int!) {
    requestSessionCoachGeneration(videoId: $videoId) {
      state
      agentGeneration {
        ...SessionCoachGenerationFields
      }
    }
  }
  ${SessionCoachGenerationFieldsFragmentDoc}
`;
export type RequestSessionCoachGenerationMutationFn = Apollo.MutationFunction<
  RequestSessionCoachGenerationMutation,
  RequestSessionCoachGenerationMutationVariables
>;

/**
 * __useRequestSessionCoachGenerationMutation__
 *
 * To run a mutation, you first call `useRequestSessionCoachGenerationMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRequestSessionCoachGenerationMutation` 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 [requestSessionCoachGenerationMutation, { data, loading, error }] = useRequestSessionCoachGenerationMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useRequestSessionCoachGenerationMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RequestSessionCoachGenerationMutation,
    RequestSessionCoachGenerationMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    RequestSessionCoachGenerationMutation,
    RequestSessionCoachGenerationMutationVariables
  >(RequestSessionCoachGenerationDocument, options);
}
export type RequestSessionCoachGenerationMutationHookResult = ReturnType<
  typeof useRequestSessionCoachGenerationMutation
>;
export type RequestSessionCoachGenerationMutationResult =
  Apollo.MutationResult<RequestSessionCoachGenerationMutation>;
export type RequestSessionCoachGenerationMutationOptions =
  Apollo.BaseMutationOptions<
    RequestSessionCoachGenerationMutation,
    RequestSessionCoachGenerationMutationVariables
  >;
export const VideoPlayerClustersDocument = gql`
  query VideoPlayerClusters($videoId: Int!) {
    videoPlayerClusters(videoId: $videoId) {
      ...PlayerClusterFields
    }
  }
  ${PlayerClusterFieldsFragmentDoc}
`;

/**
 * __useVideoPlayerClustersQuery__
 *
 * To run a query within a React component, call `useVideoPlayerClustersQuery` and pass it any options that fit your needs.
 * When your component renders, `useVideoPlayerClustersQuery` 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 } = useVideoPlayerClustersQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useVideoPlayerClustersQuery(
  baseOptions: Apollo.QueryHookOptions<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >(VideoPlayerClustersDocument, options);
}
export function useVideoPlayerClustersLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >(VideoPlayerClustersDocument, options);
}
export function useVideoPlayerClustersSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    VideoPlayerClustersQuery,
    VideoPlayerClustersQueryVariables
  >(VideoPlayerClustersDocument, options);
}
export type VideoPlayerClustersQueryHookResult = ReturnType<
  typeof useVideoPlayerClustersQuery
>;
export type VideoPlayerClustersLazyQueryHookResult = ReturnType<
  typeof useVideoPlayerClustersLazyQuery
>;
export type VideoPlayerClustersSuspenseQueryHookResult = ReturnType<
  typeof useVideoPlayerClustersSuspenseQuery
>;
export type VideoPlayerClustersQueryResult = Apollo.QueryResult<
  VideoPlayerClustersQuery,
  VideoPlayerClustersQueryVariables
>;
export const FinalizePlayerAssignmentsDocument = gql`
  mutation FinalizePlayerAssignments($input: FinalizePlayerAssignmentsInput!) {
    finalizePlayerAssignments(input: $input) {
      ...PlayerClusterFields
    }
  }
  ${PlayerClusterFieldsFragmentDoc}
`;
export type FinalizePlayerAssignmentsMutationFn = Apollo.MutationFunction<
  FinalizePlayerAssignmentsMutation,
  FinalizePlayerAssignmentsMutationVariables
>;

/**
 * __useFinalizePlayerAssignmentsMutation__
 *
 * To run a mutation, you first call `useFinalizePlayerAssignmentsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useFinalizePlayerAssignmentsMutation` 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 [finalizePlayerAssignmentsMutation, { data, loading, error }] = useFinalizePlayerAssignmentsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useFinalizePlayerAssignmentsMutation(
  baseOptions?: Apollo.MutationHookOptions<
    FinalizePlayerAssignmentsMutation,
    FinalizePlayerAssignmentsMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    FinalizePlayerAssignmentsMutation,
    FinalizePlayerAssignmentsMutationVariables
  >(FinalizePlayerAssignmentsDocument, options);
}
export type FinalizePlayerAssignmentsMutationHookResult = ReturnType<
  typeof useFinalizePlayerAssignmentsMutation
>;
export type FinalizePlayerAssignmentsMutationResult =
  Apollo.MutationResult<FinalizePlayerAssignmentsMutation>;
export type FinalizePlayerAssignmentsMutationOptions =
  Apollo.BaseMutationOptions<
    FinalizePlayerAssignmentsMutation,
    FinalizePlayerAssignmentsMutationVariables
  >;
export const GetTableStateDocument = gql`
  query GetTableState(
    $b64Image: String!
    $tableSize: Float
    $useHomography: HomographyInputGQL
  ) {
    getTableState(
      b64Image: $b64Image
      tableSize: $tableSize
      useHomography: $useHomography
    ) {
      identifierToPosition
      identifierToColor {
        hex
      }
    }
  }
`;

/**
 * __useGetTableStateQuery__
 *
 * To run a query within a React component, call `useGetTableStateQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTableStateQuery` 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 } = useGetTableStateQuery({
 *   variables: {
 *      b64Image: // value for 'b64Image'
 *      tableSize: // value for 'tableSize'
 *      useHomography: // value for 'useHomography'
 *   },
 * });
 */
export function useGetTableStateQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetTableStateQuery,
    GetTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetTableStateQuery, GetTableStateQueryVariables>(
    GetTableStateDocument,
    options,
  );
}
export function useGetTableStateLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetTableStateQuery,
    GetTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetTableStateQuery, GetTableStateQueryVariables>(
    GetTableStateDocument,
    options,
  );
}
export function useGetTableStateSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetTableStateQuery,
    GetTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetTableStateQuery,
    GetTableStateQueryVariables
  >(GetTableStateDocument, options);
}
export type GetTableStateQueryHookResult = ReturnType<
  typeof useGetTableStateQuery
>;
export type GetTableStateLazyQueryHookResult = ReturnType<
  typeof useGetTableStateLazyQuery
>;
export type GetTableStateSuspenseQueryHookResult = ReturnType<
  typeof useGetTableStateSuspenseQuery
>;
export type GetTableStateQueryResult = Apollo.QueryResult<
  GetTableStateQuery,
  GetTableStateQueryVariables
>;
export const GetLiveTableStateDocument = gql`
  query GetLiveTableState($videoId: Int!) {
    getLiveTableState(videoId: $videoId) {
      videoId
      frameIndex
      tableState {
        identifierToPosition
        identifierToColor {
          hex
        }
      }
    }
  }
`;

/**
 * __useGetLiveTableStateQuery__
 *
 * To run a query within a React component, call `useGetLiveTableStateQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetLiveTableStateQuery` 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 } = useGetLiveTableStateQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetLiveTableStateQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >(GetLiveTableStateDocument, options);
}
export function useGetLiveTableStateLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >(GetLiveTableStateDocument, options);
}
export function useGetLiveTableStateSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetLiveTableStateQuery,
    GetLiveTableStateQueryVariables
  >(GetLiveTableStateDocument, options);
}
export type GetLiveTableStateQueryHookResult = ReturnType<
  typeof useGetLiveTableStateQuery
>;
export type GetLiveTableStateLazyQueryHookResult = ReturnType<
  typeof useGetLiveTableStateLazyQuery
>;
export type GetLiveTableStateSuspenseQueryHookResult = ReturnType<
  typeof useGetLiveTableStateSuspenseQuery
>;
export type GetLiveTableStateQueryResult = Apollo.QueryResult<
  GetLiveTableStateQuery,
  GetLiveTableStateQueryVariables
>;
export const GetShotTableStateDocument = gql`
  query GetShotTableState($shotId: Int!) {
    getShotTableState(shotId: $shotId) {
      shotId
      videoId
      frameIndex
      tableState {
        identifierToPosition
        identifierToColor {
          hex
        }
      }
    }
  }
`;

/**
 * __useGetShotTableStateQuery__
 *
 * To run a query within a React component, call `useGetShotTableStateQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotTableStateQuery` 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 } = useGetShotTableStateQuery({
 *   variables: {
 *      shotId: // value for 'shotId'
 *   },
 * });
 */
export function useGetShotTableStateQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >(GetShotTableStateDocument, options);
}
export function useGetShotTableStateLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >(GetShotTableStateDocument, options);
}
export function useGetShotTableStateSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotTableStateQuery,
    GetShotTableStateQueryVariables
  >(GetShotTableStateDocument, options);
}
export type GetShotTableStateQueryHookResult = ReturnType<
  typeof useGetShotTableStateQuery
>;
export type GetShotTableStateLazyQueryHookResult = ReturnType<
  typeof useGetShotTableStateLazyQuery
>;
export type GetShotTableStateSuspenseQueryHookResult = ReturnType<
  typeof useGetShotTableStateSuspenseQuery
>;
export type GetShotTableStateQueryResult = Apollo.QueryResult<
  GetShotTableStateQuery,
  GetShotTableStateQueryVariables
>;
export const SimulateShotDocument = gql`
  query SimulateShot($simulationInput: SimulateShotInputGQL!) {
    simulateShot(simulationInput: $simulationInput) {
      trajectories {
        ballId
        points {
          time
          position
        }
      }
      events {
        eventType
        time
        ballIds
        position
      }
      finalState {
        ballId
        position
      }
      pottedBallIds
    }
  }
`;

/**
 * __useSimulateShotQuery__
 *
 * To run a query within a React component, call `useSimulateShotQuery` and pass it any options that fit your needs.
 * When your component renders, `useSimulateShotQuery` 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 } = useSimulateShotQuery({
 *   variables: {
 *      simulationInput: // value for 'simulationInput'
 *   },
 * });
 */
export function useSimulateShotQuery(
  baseOptions: Apollo.QueryHookOptions<
    SimulateShotQuery,
    SimulateShotQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<SimulateShotQuery, SimulateShotQueryVariables>(
    SimulateShotDocument,
    options,
  );
}
export function useSimulateShotLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    SimulateShotQuery,
    SimulateShotQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<SimulateShotQuery, SimulateShotQueryVariables>(
    SimulateShotDocument,
    options,
  );
}
export function useSimulateShotSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    SimulateShotQuery,
    SimulateShotQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<SimulateShotQuery, SimulateShotQueryVariables>(
    SimulateShotDocument,
    options,
  );
}
export type SimulateShotQueryHookResult = ReturnType<
  typeof useSimulateShotQuery
>;
export type SimulateShotLazyQueryHookResult = ReturnType<
  typeof useSimulateShotLazyQuery
>;
export type SimulateShotSuspenseQueryHookResult = ReturnType<
  typeof useSimulateShotSuspenseQuery
>;
export type SimulateShotQueryResult = Apollo.QueryResult<
  SimulateShotQuery,
  SimulateShotQueryVariables
>;
export const ComputePotAimDocument = gql`
  query ComputePotAim(
    $simulationInput: SimulateShotInputGQL!
    $targetBallId: Int!
    $pocket: PocketIdentifier!
  ) {
    computePotAim(
      simulationInput: $simulationInput
      targetBallId: $targetBallId
      pocket: $pocket
    ) {
      phi
      geometricPhi
      cutAngle
      requiredPrecision
      feasible
      potted
      converged
      occludingBallIds
    }
  }
`;

/**
 * __useComputePotAimQuery__
 *
 * To run a query within a React component, call `useComputePotAimQuery` and pass it any options that fit your needs.
 * When your component renders, `useComputePotAimQuery` 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 } = useComputePotAimQuery({
 *   variables: {
 *      simulationInput: // value for 'simulationInput'
 *      targetBallId: // value for 'targetBallId'
 *      pocket: // value for 'pocket'
 *   },
 * });
 */
export function useComputePotAimQuery(
  baseOptions: Apollo.QueryHookOptions<
    ComputePotAimQuery,
    ComputePotAimQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<ComputePotAimQuery, ComputePotAimQueryVariables>(
    ComputePotAimDocument,
    options,
  );
}
export function useComputePotAimLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    ComputePotAimQuery,
    ComputePotAimQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<ComputePotAimQuery, ComputePotAimQueryVariables>(
    ComputePotAimDocument,
    options,
  );
}
export function useComputePotAimSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    ComputePotAimQuery,
    ComputePotAimQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    ComputePotAimQuery,
    ComputePotAimQueryVariables
  >(ComputePotAimDocument, options);
}
export type ComputePotAimQueryHookResult = ReturnType<
  typeof useComputePotAimQuery
>;
export type ComputePotAimLazyQueryHookResult = ReturnType<
  typeof useComputePotAimLazyQuery
>;
export type ComputePotAimSuspenseQueryHookResult = ReturnType<
  typeof useComputePotAimSuspenseQuery
>;
export type ComputePotAimQueryResult = Apollo.QueryResult<
  ComputePotAimQuery,
  ComputePotAimQueryVariables
>;
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 GetShotClipRangesDocument = gql`
  query GetShotClipRanges(
    $filterInput: FilterInput!
    $shotsOrdering: GetShotsOrdering
    $limit: Int
  ) {
    getOrderedShots(
      filterInput: $filterInput
      shotsOrdering: $shotsOrdering
      limit: $limit
    ) {
      count
      shots {
        ...ShotClipRange
      }
    }
  }
  ${ShotClipRangeFragmentDoc}
`;

/**
 * __useGetShotClipRangesQuery__
 *
 * To run a query within a React component, call `useGetShotClipRangesQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetShotClipRangesQuery` 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 } = useGetShotClipRangesQuery({
 *   variables: {
 *      filterInput: // value for 'filterInput'
 *      shotsOrdering: // value for 'shotsOrdering'
 *      limit: // value for 'limit'
 *   },
 * });
 */
export function useGetShotClipRangesQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >(GetShotClipRangesDocument, options);
}
export function useGetShotClipRangesLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >(GetShotClipRangesDocument, options);
}
export function useGetShotClipRangesSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetShotClipRangesQuery,
    GetShotClipRangesQueryVariables
  >(GetShotClipRangesDocument, options);
}
export type GetShotClipRangesQueryHookResult = ReturnType<
  typeof useGetShotClipRangesQuery
>;
export type GetShotClipRangesLazyQueryHookResult = ReturnType<
  typeof useGetShotClipRangesLazyQuery
>;
export type GetShotClipRangesSuspenseQueryHookResult = ReturnType<
  typeof useGetShotClipRangesSuspenseQuery
>;
export type GetShotClipRangesQueryResult = Apollo.QueryResult<
  GetShotClipRangesQuery,
  GetShotClipRangesQueryVariables
>;
export const EditShotDocument = gql`
  mutation EditShot($shotId: Int!, $fieldsToEdit: EditableShotFieldInputGQL!) {
    editShot(shotId: $shotId, fieldsToEdit: $fieldsToEdit) {
      error {
        shotId
        msg
      }
      shot {
        ...ShotWithAllFeatures
      }
    }
  }
  ${ShotWithAllFeaturesFragmentDoc}
`;
export type EditShotMutationFn = Apollo.MutationFunction<
  EditShotMutation,
  EditShotMutationVariables
>;

/**
 * __useEditShotMutation__
 *
 * To run a mutation, you first call `useEditShotMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useEditShotMutation` 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 [editShotMutation, { data, loading, error }] = useEditShotMutation({
 *   variables: {
 *      shotId: // value for 'shotId'
 *      fieldsToEdit: // value for 'fieldsToEdit'
 *   },
 * });
 */
export function useEditShotMutation(
  baseOptions?: Apollo.MutationHookOptions<
    EditShotMutation,
    EditShotMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<EditShotMutation, EditShotMutationVariables>(
    EditShotDocument,
    options,
  );
}
export type EditShotMutationHookResult = ReturnType<typeof useEditShotMutation>;
export type EditShotMutationResult = Apollo.MutationResult<EditShotMutation>;
export type EditShotMutationOptions = Apollo.BaseMutationOptions<
  EditShotMutation,
  EditShotMutationVariables
>;
export const RetireTagsDocument = gql`
  mutation RetireTags($tagIds: [Int!]!) {
    retireTags(tagIds: $tagIds)
  }
`;
export type RetireTagsMutationFn = Apollo.MutationFunction<
  RetireTagsMutation,
  RetireTagsMutationVariables
>;

/**
 * __useRetireTagsMutation__
 *
 * To run a mutation, you first call `useRetireTagsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRetireTagsMutation` 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 [retireTagsMutation, { data, loading, error }] = useRetireTagsMutation({
 *   variables: {
 *      tagIds: // value for 'tagIds'
 *   },
 * });
 */
export function useRetireTagsMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RetireTagsMutation,
    RetireTagsMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<RetireTagsMutation, RetireTagsMutationVariables>(
    RetireTagsDocument,
    options,
  );
}
export type RetireTagsMutationHookResult = ReturnType<
  typeof useRetireTagsMutation
>;
export type RetireTagsMutationResult =
  Apollo.MutationResult<RetireTagsMutation>;
export type RetireTagsMutationOptions = Apollo.BaseMutationOptions<
  RetireTagsMutation,
  RetireTagsMutationVariables
>;
export const DeleteTagsDocument = gql`
  mutation DeleteTags($videoId: Int!, $tagsToDelete: [VideoTagInput!]!) {
    deleteTags(videoId: $videoId, tagsToDelete: $tagsToDelete)
  }
`;
export type DeleteTagsMutationFn = Apollo.MutationFunction<
  DeleteTagsMutation,
  DeleteTagsMutationVariables
>;

/**
 * __useDeleteTagsMutation__
 *
 * To run a mutation, you first call `useDeleteTagsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteTagsMutation` 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 [deleteTagsMutation, { data, loading, error }] = useDeleteTagsMutation({
 *   variables: {
 *      videoId: // value for 'videoId'
 *      tagsToDelete: // value for 'tagsToDelete'
 *   },
 * });
 */
export function useDeleteTagsMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DeleteTagsMutation,
    DeleteTagsMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<DeleteTagsMutation, DeleteTagsMutationVariables>(
    DeleteTagsDocument,
    options,
  );
}
export type DeleteTagsMutationHookResult = ReturnType<
  typeof useDeleteTagsMutation
>;
export type DeleteTagsMutationResult =
  Apollo.MutationResult<DeleteTagsMutation>;
export type DeleteTagsMutationOptions = Apollo.BaseMutationOptions<
  DeleteTagsMutation,
  DeleteTagsMutationVariables
>;
export const GetUsageStatsDocument = gql`
  query getUsageStats($days: Int! = 30) {
    getUsageStats(days: $days) {
      funnel {
        freemiumEpoch
        eraSignups
        eraPaying
        activationCohort
        activationActivated
        payingUsers
        pastDueUsers
        newPaidToday
        newPaid7d
        newPaid30d
        retentionPrevActive
        retentionReturned
      }
      cohorts {
        weekStart
        signups
        activated7d
        paid7d
        activatedNotPaid7d
        paidTotal
      }
      totalUsers
      totalVideos
      totalShots
      totalRuns
      windows {
        label
        newUsers
        activeUsers
        sessions
        shots
      }
      daily {
        day
        newUsers
        activeUsers
        sessions
        shots
      }
      processingLast24h {
        status
        count
      }
    }
  }
`;

/**
 * __useGetUsageStatsQuery__
 *
 * To run a query within a React component, call `useGetUsageStatsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUsageStatsQuery` 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 } = useGetUsageStatsQuery({
 *   variables: {
 *      days: // value for 'days'
 *   },
 * });
 */
export function useGetUsageStatsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUsageStatsQuery,
    GetUsageStatsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUsageStatsQuery, GetUsageStatsQueryVariables>(
    GetUsageStatsDocument,
    options,
  );
}
export function useGetUsageStatsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUsageStatsQuery,
    GetUsageStatsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetUsageStatsQuery, GetUsageStatsQueryVariables>(
    GetUsageStatsDocument,
    options,
  );
}
export function useGetUsageStatsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUsageStatsQuery,
    GetUsageStatsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUsageStatsQuery,
    GetUsageStatsQueryVariables
  >(GetUsageStatsDocument, options);
}
export type GetUsageStatsQueryHookResult = ReturnType<
  typeof useGetUsageStatsQuery
>;
export type GetUsageStatsLazyQueryHookResult = ReturnType<
  typeof useGetUsageStatsLazyQuery
>;
export type GetUsageStatsSuspenseQueryHookResult = ReturnType<
  typeof useGetUsageStatsSuspenseQuery
>;
export type GetUsageStatsQueryResult = Apollo.QueryResult<
  GetUsageStatsQuery,
  GetUsageStatsQueryVariables
>;
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) {
      ...UserFragment
    }
  }
  ${UserFragmentFragmentDoc}
`;
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 {
      ...UserFragment
    }
  }
  ${UserFragmentFragmentDoc}
`;

/**
 * __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 GetUserDocument = gql`
  query GetUser($userId: Int!) {
    getUser(userId: $userId) {
      ...UserFragment
      following {
        id
      }
      followers {
        id
      }
    }
  }
  ${UserFragmentFragmentDoc}
`;

/**
 * __useGetUserQuery__
 *
 * To run a query within a React component, call `useGetUserQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUserQuery` 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 } = useGetUserQuery({
 *   variables: {
 *      userId: // value for 'userId'
 *   },
 * });
 */
export function useGetUserQuery(
  baseOptions: Apollo.QueryHookOptions<GetUserQuery, GetUserQueryVariables>,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUserQuery, GetUserQueryVariables>(
    GetUserDocument,
    options,
  );
}
export function useGetUserLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUserQuery,
    GetUserQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetUserQuery, GetUserQueryVariables>(
    GetUserDocument,
    options,
  );
}
export function useGetUserSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUserQuery,
    GetUserQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetUserQuery, GetUserQueryVariables>(
    GetUserDocument,
    options,
  );
}
export type GetUserQueryHookResult = ReturnType<typeof useGetUserQuery>;
export type GetUserLazyQueryHookResult = ReturnType<typeof useGetUserLazyQuery>;
export type GetUserSuspenseQueryHookResult = ReturnType<
  typeof useGetUserSuspenseQuery
>;
export type GetUserQueryResult = Apollo.QueryResult<
  GetUserQuery,
  GetUserQueryVariables
>;
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 GetUploadQuotaStatusDocument = gql`
  query GetUploadQuotaStatus {
    getQuotaStatus {
      tierName
      periodStart
      periodEnd
      durationUsedSeconds
      durationLimitSeconds
      maxVideoDurationSeconds
      durationRemainingSeconds
      canUpload
      importQuotaBuckets {
        quotaKey
        appliesToUploadKind
        periodStart
        periodEnd
        durationUsedSeconds
        durationLimitSeconds
        durationRemainingSeconds
        canUpload
      }
      recordingQuotaBuckets {
        quotaKey
        appliesToUploadKind
        periodStart
        periodEnd
        durationUsedSeconds
        durationLimitSeconds
        durationRemainingSeconds
        canUpload
      }
    }
  }
`;

/**
 * __useGetUploadQuotaStatusQuery__
 *
 * To run a query within a React component, call `useGetUploadQuotaStatusQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUploadQuotaStatusQuery` 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 } = useGetUploadQuotaStatusQuery({
 *   variables: {
 *   },
 * });
 */
export function useGetUploadQuotaStatusQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >(GetUploadQuotaStatusDocument, options);
}
export function useGetUploadQuotaStatusLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >(GetUploadQuotaStatusDocument, options);
}
export function useGetUploadQuotaStatusSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUploadQuotaStatusQuery,
    GetUploadQuotaStatusQueryVariables
  >(GetUploadQuotaStatusDocument, options);
}
export type GetUploadQuotaStatusQueryHookResult = ReturnType<
  typeof useGetUploadQuotaStatusQuery
>;
export type GetUploadQuotaStatusLazyQueryHookResult = ReturnType<
  typeof useGetUploadQuotaStatusLazyQuery
>;
export type GetUploadQuotaStatusSuspenseQueryHookResult = ReturnType<
  typeof useGetUploadQuotaStatusSuspenseQuery
>;
export type GetUploadQuotaStatusQueryResult = Apollo.QueryResult<
  GetUploadQuotaStatusQuery,
  GetUploadQuotaStatusQueryVariables
>;
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
          profileImageUri
          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
      tagClasses {
        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 GetGameTypeTagMetricsDocument = gql`
  query GetGameTypeTagMetrics($input: GameTypeTagMetricsInput!) {
    getGameTypeTagMetrics(input: $input) {
      tagName
      tagLabel
      tableSize
      shotCount
      madeShots
      makeRate
    }
  }
`;

/**
 * __useGetGameTypeTagMetricsQuery__
 *
 * To run a query within a React component, call `useGetGameTypeTagMetricsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetGameTypeTagMetricsQuery` 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 } = useGetGameTypeTagMetricsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useGetGameTypeTagMetricsQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >(GetGameTypeTagMetricsDocument, options);
}
export function useGetGameTypeTagMetricsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >(GetGameTypeTagMetricsDocument, options);
}
export function useGetGameTypeTagMetricsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetGameTypeTagMetricsQuery,
    GetGameTypeTagMetricsQueryVariables
  >(GetGameTypeTagMetricsDocument, options);
}
export type GetGameTypeTagMetricsQueryHookResult = ReturnType<
  typeof useGetGameTypeTagMetricsQuery
>;
export type GetGameTypeTagMetricsLazyQueryHookResult = ReturnType<
  typeof useGetGameTypeTagMetricsLazyQuery
>;
export type GetGameTypeTagMetricsSuspenseQueryHookResult = ReturnType<
  typeof useGetGameTypeTagMetricsSuspenseQuery
>;
export type GetGameTypeTagMetricsQueryResult = Apollo.QueryResult<
  GetGameTypeTagMetricsQuery,
  GetGameTypeTagMetricsQueryVariables
>;
export const FollowUserDocument = gql`
  mutation followUser($followedUserId: Int!) {
    followUser(followedUserId: $followedUserId) {
      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) {
      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
        profileImageUri
        isFollowedByCurrentUser
      }
      followers {
        id
        username
        profileImageUri
        isFollowedByCurrentUser
      }
    }
  }
`;

/**
 * __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
    $agreesToMarketing: Boolean
    $bio: String
  ) {
    editUser(
      input: {
        username: $username
        fargoRating: $fargoRating
        videosPrivateByDefault: $videosPrivateByDefault
        agreesToMarketing: $agreesToMarketing
        bio: $bio
      }
    ) {
      id
      firebaseUid
      username
      fargoRating
      updatedAt
      videosPrivateByDefault
      agreesToMarketing
      bio
    }
  }
`;
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'
 *      agreesToMarketing: // value for 'agreesToMarketing'
 *      bio: // value for 'bio'
 *   },
 * });
 */
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 DeleteUserDocument = gql`
  mutation deleteUser {
    deleteUser
  }
`;
export type DeleteUserMutationFn = Apollo.MutationFunction<
  DeleteUserMutation,
  DeleteUserMutationVariables
>;

/**
 * __useDeleteUserMutation__
 *
 * To run a mutation, you first call `useDeleteUserMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteUserMutation` 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 [deleteUserMutation, { data, loading, error }] = useDeleteUserMutation({
 *   variables: {
 *   },
 * });
 */
export function useDeleteUserMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DeleteUserMutation,
    DeleteUserMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<DeleteUserMutation, DeleteUserMutationVariables>(
    DeleteUserDocument,
    options,
  );
}
export type DeleteUserMutationHookResult = ReturnType<
  typeof useDeleteUserMutation
>;
export type DeleteUserMutationResult =
  Apollo.MutationResult<DeleteUserMutation>;
export type DeleteUserMutationOptions = Apollo.BaseMutationOptions<
  DeleteUserMutation,
  DeleteUserMutationVariables
>;
export const GetUsersMatchingDocument = gql`
  query GetUsersMatching(
    $matchString: String = null
    $limit: Int = null
    $after: String = null
  ) {
    getUsersMatching(matchString: $matchString, limit: $limit, after: $after) {
      ...UserFragment
    }
  }
  ${UserFragmentFragmentDoc}
`;

/**
 * __useGetUsersMatchingQuery__
 *
 * To run a query within a React component, call `useGetUsersMatchingQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetUsersMatchingQuery` 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 } = useGetUsersMatchingQuery({
 *   variables: {
 *      matchString: // value for 'matchString'
 *      limit: // value for 'limit'
 *      after: // value for 'after'
 *   },
 * });
 */
export function useGetUsersMatchingQuery(
  baseOptions?: Apollo.QueryHookOptions<
    GetUsersMatchingQuery,
    GetUsersMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetUsersMatchingQuery, GetUsersMatchingQueryVariables>(
    GetUsersMatchingDocument,
    options,
  );
}
export function useGetUsersMatchingLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetUsersMatchingQuery,
    GetUsersMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetUsersMatchingQuery,
    GetUsersMatchingQueryVariables
  >(GetUsersMatchingDocument, options);
}
export function useGetUsersMatchingSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetUsersMatchingQuery,
    GetUsersMatchingQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetUsersMatchingQuery,
    GetUsersMatchingQueryVariables
  >(GetUsersMatchingDocument, options);
}
export type GetUsersMatchingQueryHookResult = ReturnType<
  typeof useGetUsersMatchingQuery
>;
export type GetUsersMatchingLazyQueryHookResult = ReturnType<
  typeof useGetUsersMatchingLazyQuery
>;
export type GetUsersMatchingSuspenseQueryHookResult = ReturnType<
  typeof useGetUsersMatchingSuspenseQuery
>;
export type GetUsersMatchingQueryResult = Apollo.QueryResult<
  GetUsersMatchingQuery,
  GetUsersMatchingQueryVariables
>;
export const GetStreamMonitoringDetailsDocument = gql`
  query GetStreamMonitoringDetails($videoId: Int!, $debuggingJson: JSON) {
    getVideo(videoId: $videoId, debuggingJson: $debuggingJson) {
      id
      totalShots
      makePercentage
      elapsedTime
      currentHomography {
        ...HomographyInfo
      }
      stream {
        id
        linksRequested
        lowestUnuploadedSegmentIndex
        uploadsCompleted
        segmentProcessingCursor
        isCompleted
        uploadCompletionCursor
        lastIntendedSegmentBound
        initPlaylistUploadStatus
      }
      currentProcessing {
        id
        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
      pocketSize
      private
      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
      averageDifficulty
      startTime
      totalShots
      totalShotsMade
      createdAt
      updatedAt
      tableSize
      pocketSize
      private
      owner {
        id
        firebaseUid
        username
        profileImageUri
      }
      tags {
        tagClasses {
          name
        }
        name
      }
      playerSummaries {
        ...PlayerSummaryFields
      }
    }
  }
  ${PlayerSummaryFieldsFragmentDoc}
`;

/**
 * __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 GetVideoSocialDetailsByIdDocument = gql`
  query GetVideoSocialDetailsById($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      name
      screenshotUri
      makePercentage
      totalShots
      owner {
        id
        firebaseUid
        username
        profileImageUri
      }
      tags {
        tagClasses {
          name
        }
        name
      }
      reactions {
        videoId
        user {
          ...UserSocialsFields
        }
        reaction
      }
      comments {
        id
        message
        user {
          ...UserSocialsFields
        }
        replies {
          id
          message
          replyToCommentId
          user {
            ...UserSocialsFields
          }
        }
      }
    }
  }
  ${UserSocialsFieldsFragmentDoc}
`;

/**
 * __useGetVideoSocialDetailsByIdQuery__
 *
 * To run a query within a React component, call `useGetVideoSocialDetailsByIdQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoSocialDetailsByIdQuery` 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 } = useGetVideoSocialDetailsByIdQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoSocialDetailsByIdQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >(GetVideoSocialDetailsByIdDocument, options);
}
export function useGetVideoSocialDetailsByIdLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >(GetVideoSocialDetailsByIdDocument, options);
}
export function useGetVideoSocialDetailsByIdSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetVideoSocialDetailsByIdQuery,
    GetVideoSocialDetailsByIdQueryVariables
  >(GetVideoSocialDetailsByIdDocument, options);
}
export type GetVideoSocialDetailsByIdQueryHookResult = ReturnType<
  typeof useGetVideoSocialDetailsByIdQuery
>;
export type GetVideoSocialDetailsByIdLazyQueryHookResult = ReturnType<
  typeof useGetVideoSocialDetailsByIdLazyQuery
>;
export type GetVideoSocialDetailsByIdSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoSocialDetailsByIdSuspenseQuery
>;
export type GetVideoSocialDetailsByIdQueryResult = Apollo.QueryResult<
  GetVideoSocialDetailsByIdQuery,
  GetVideoSocialDetailsByIdQueryVariables
>;
export const GetVideoCardDocument = gql`
  query GetVideoCard($videoId: Int!) {
    getVideo(videoId: $videoId) {
      ...VideoCardFields
    }
  }
  ${VideoCardFieldsFragmentDoc}
`;

/**
 * __useGetVideoCardQuery__
 *
 * To run a query within a React component, call `useGetVideoCardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetVideoCardQuery` 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 } = useGetVideoCardQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetVideoCardQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetVideoCardQuery,
    GetVideoCardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<GetVideoCardQuery, GetVideoCardQueryVariables>(
    GetVideoCardDocument,
    options,
  );
}
export function useGetVideoCardLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetVideoCardQuery,
    GetVideoCardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<GetVideoCardQuery, GetVideoCardQueryVariables>(
    GetVideoCardDocument,
    options,
  );
}
export function useGetVideoCardSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetVideoCardQuery,
    GetVideoCardQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<GetVideoCardQuery, GetVideoCardQueryVariables>(
    GetVideoCardDocument,
    options,
  );
}
export type GetVideoCardQueryHookResult = ReturnType<
  typeof useGetVideoCardQuery
>;
export type GetVideoCardLazyQueryHookResult = ReturnType<
  typeof useGetVideoCardLazyQuery
>;
export type GetVideoCardSuspenseQueryHookResult = ReturnType<
  typeof useGetVideoCardSuspenseQuery
>;
export type GetVideoCardQueryResult = Apollo.QueryResult<
  GetVideoCardQuery,
  GetVideoCardQueryVariables
>;
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 GetAverageDifficultyForVideoDocument = gql`
  query GetAverageDifficultyForVideo($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      averageDifficulty
    }
  }
`;

/**
 * __useGetAverageDifficultyForVideoQuery__
 *
 * To run a query within a React component, call `useGetAverageDifficultyForVideoQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAverageDifficultyForVideoQuery` 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 } = useGetAverageDifficultyForVideoQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetAverageDifficultyForVideoQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >(GetAverageDifficultyForVideoDocument, options);
}
export function useGetAverageDifficultyForVideoLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >(GetAverageDifficultyForVideoDocument, options);
}
export function useGetAverageDifficultyForVideoSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetAverageDifficultyForVideoQuery,
    GetAverageDifficultyForVideoQueryVariables
  >(GetAverageDifficultyForVideoDocument, options);
}
export type GetAverageDifficultyForVideoQueryHookResult = ReturnType<
  typeof useGetAverageDifficultyForVideoQuery
>;
export type GetAverageDifficultyForVideoLazyQueryHookResult = ReturnType<
  typeof useGetAverageDifficultyForVideoLazyQuery
>;
export type GetAverageDifficultyForVideoSuspenseQueryHookResult = ReturnType<
  typeof useGetAverageDifficultyForVideoSuspenseQuery
>;
export type GetAverageDifficultyForVideoQueryResult = Apollo.QueryResult<
  GetAverageDifficultyForVideoQuery,
  GetAverageDifficultyForVideoQueryVariables
>;
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 GetBannerInfoByVideoIdDocument = gql`
  query GetBannerInfoByVideoId($videoId: Int!) {
    getVideo(videoId: $videoId) {
      id
      name
      stream {
        id
        lastIntendedSegmentBound
      }
      owner {
        id
      }
      currentProcessing {
        id
        status
      }
    }
  }
`;

/**
 * __useGetBannerInfoByVideoIdQuery__
 *
 * To run a query within a React component, call `useGetBannerInfoByVideoIdQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetBannerInfoByVideoIdQuery` 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 } = useGetBannerInfoByVideoIdQuery({
 *   variables: {
 *      videoId: // value for 'videoId'
 *   },
 * });
 */
export function useGetBannerInfoByVideoIdQuery(
  baseOptions: Apollo.QueryHookOptions<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >(GetBannerInfoByVideoIdDocument, options);
}
export function useGetBannerInfoByVideoIdLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >(GetBannerInfoByVideoIdDocument, options);
}
export function useGetBannerInfoByVideoIdSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    GetBannerInfoByVideoIdQuery,
    GetBannerInfoByVideoIdQueryVariables
  >(GetBannerInfoByVideoIdDocument, options);
}
export type GetBannerInfoByVideoIdQueryHookResult = ReturnType<
  typeof useGetBannerInfoByVideoIdQuery
>;
export type GetBannerInfoByVideoIdLazyQueryHookResult = ReturnType<
  typeof useGetBannerInfoByVideoIdLazyQuery
>;
export type GetBannerInfoByVideoIdSuspenseQueryHookResult = ReturnType<
  typeof useGetBannerInfoByVideoIdSuspenseQuery
>;
export type GetBannerInfoByVideoIdQueryResult = Apollo.QueryResult<
  GetBannerInfoByVideoIdQuery,
  GetBannerInfoByVideoIdQueryVariables
>;
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 RequestVideoExportDocument = gql`
  mutation RequestVideoExport($input: RequestVideoExportInput!) {
    requestVideoExport(input: $input) {
      ...VideoExportJobFields
    }
  }
  ${VideoExportJobFieldsFragmentDoc}
`;
export type RequestVideoExportMutationFn = Apollo.MutationFunction<
  RequestVideoExportMutation,
  RequestVideoExportMutationVariables
>;

/**
 * __useRequestVideoExportMutation__
 *
 * To run a mutation, you first call `useRequestVideoExportMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRequestVideoExportMutation` 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 [requestVideoExportMutation, { data, loading, error }] = useRequestVideoExportMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export function useRequestVideoExportMutation(
  baseOptions?: Apollo.MutationHookOptions<
    RequestVideoExportMutation,
    RequestVideoExportMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    RequestVideoExportMutation,
    RequestVideoExportMutationVariables
  >(RequestVideoExportDocument, options);
}
export type RequestVideoExportMutationHookResult = ReturnType<
  typeof useRequestVideoExportMutation
>;
export type RequestVideoExportMutationResult =
  Apollo.MutationResult<RequestVideoExportMutation>;
export type RequestVideoExportMutationOptions = Apollo.BaseMutationOptions<
  RequestVideoExportMutation,
  RequestVideoExportMutationVariables
>;
export const DismissVideoExportDocument = gql`
  mutation DismissVideoExport($jobId: Int!) {
    dismissVideoExport(jobId: $jobId)
  }
`;
export type DismissVideoExportMutationFn = Apollo.MutationFunction<
  DismissVideoExportMutation,
  DismissVideoExportMutationVariables
>;

/**
 * __useDismissVideoExportMutation__
 *
 * To run a mutation, you first call `useDismissVideoExportMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDismissVideoExportMutation` 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 [dismissVideoExportMutation, { data, loading, error }] = useDismissVideoExportMutation({
 *   variables: {
 *      jobId: // value for 'jobId'
 *   },
 * });
 */
export function useDismissVideoExportMutation(
  baseOptions?: Apollo.MutationHookOptions<
    DismissVideoExportMutation,
    DismissVideoExportMutationVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useMutation<
    DismissVideoExportMutation,
    DismissVideoExportMutationVariables
  >(DismissVideoExportDocument, options);
}
export type DismissVideoExportMutationHookResult = ReturnType<
  typeof useDismissVideoExportMutation
>;
export type DismissVideoExportMutationResult =
  Apollo.MutationResult<DismissVideoExportMutation>;
export type DismissVideoExportMutationOptions = Apollo.BaseMutationOptions<
  DismissVideoExportMutation,
  DismissVideoExportMutationVariables
>;
export const VideoExportJobDocument = gql`
  query VideoExportJob($jobId: Int!) {
    videoExportJob(jobId: $jobId) {
      ...VideoExportJobFields
    }
  }
  ${VideoExportJobFieldsFragmentDoc}
`;

/**
 * __useVideoExportJobQuery__
 *
 * To run a query within a React component, call `useVideoExportJobQuery` and pass it any options that fit your needs.
 * When your component renders, `useVideoExportJobQuery` 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 } = useVideoExportJobQuery({
 *   variables: {
 *      jobId: // value for 'jobId'
 *   },
 * });
 */
export function useVideoExportJobQuery(
  baseOptions: Apollo.QueryHookOptions<
    VideoExportJobQuery,
    VideoExportJobQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<VideoExportJobQuery, VideoExportJobQueryVariables>(
    VideoExportJobDocument,
    options,
  );
}
export function useVideoExportJobLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    VideoExportJobQuery,
    VideoExportJobQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<VideoExportJobQuery, VideoExportJobQueryVariables>(
    VideoExportJobDocument,
    options,
  );
}
export function useVideoExportJobSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    VideoExportJobQuery,
    VideoExportJobQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    VideoExportJobQuery,
    VideoExportJobQueryVariables
  >(VideoExportJobDocument, options);
}
export type VideoExportJobQueryHookResult = ReturnType<
  typeof useVideoExportJobQuery
>;
export type VideoExportJobLazyQueryHookResult = ReturnType<
  typeof useVideoExportJobLazyQuery
>;
export type VideoExportJobSuspenseQueryHookResult = ReturnType<
  typeof useVideoExportJobSuspenseQuery
>;
export type VideoExportJobQueryResult = Apollo.QueryResult<
  VideoExportJobQuery,
  VideoExportJobQueryVariables
>;
export const MyVideoExportsDocument = gql`
  query MyVideoExports($limit: Int = 30, $offset: Int = 0) {
    myVideoExports(limit: $limit, offset: $offset) {
      ...VideoExportJobFields
    }
  }
  ${VideoExportJobFieldsFragmentDoc}
`;

/**
 * __useMyVideoExportsQuery__
 *
 * To run a query within a React component, call `useMyVideoExportsQuery` and pass it any options that fit your needs.
 * When your component renders, `useMyVideoExportsQuery` 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 } = useMyVideoExportsQuery({
 *   variables: {
 *      limit: // value for 'limit'
 *      offset: // value for 'offset'
 *   },
 * });
 */
export function useMyVideoExportsQuery(
  baseOptions?: Apollo.QueryHookOptions<
    MyVideoExportsQuery,
    MyVideoExportsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useQuery<MyVideoExportsQuery, MyVideoExportsQueryVariables>(
    MyVideoExportsDocument,
    options,
  );
}
export function useMyVideoExportsLazyQuery(
  baseOptions?: Apollo.LazyQueryHookOptions<
    MyVideoExportsQuery,
    MyVideoExportsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useLazyQuery<MyVideoExportsQuery, MyVideoExportsQueryVariables>(
    MyVideoExportsDocument,
    options,
  );
}
export function useMyVideoExportsSuspenseQuery(
  baseOptions?: Apollo.SuspenseQueryHookOptions<
    MyVideoExportsQuery,
    MyVideoExportsQueryVariables
  >,
) {
  const options = { ...defaultOptions, ...baseOptions };
  return Apollo.useSuspenseQuery<
    MyVideoExportsQuery,
    MyVideoExportsQueryVariables
  >(MyVideoExportsDocument, options);
}
export type MyVideoExportsQueryHookResult = ReturnType<
  typeof useMyVideoExportsQuery
>;
export type MyVideoExportsLazyQueryHookResult = ReturnType<
  typeof useMyVideoExportsLazyQuery
>;
export type MyVideoExportsSuspenseQueryHookResult = ReturnType<
  typeof useMyVideoExportsSuspenseQuery
>;
export type MyVideoExportsQueryResult = Apollo.QueryResult<
  MyVideoExportsQuery,
  MyVideoExportsQueryVariables
>;
export const CreateUploadStreamDocument = gql`
  mutation CreateUploadStream(
    $videoMetadataInput: VideoMetadataInput!
    $expectedDurationSeconds: Float = null
  ) {
    createUploadStream(
      videoMetadata: $videoMetadataInput
      expectedDurationSeconds: $expectedDurationSeconds
    ) {
      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'
 *      expectedDurationSeconds: // value for 'expectedDurationSeconds'
 *   },
 * });
 */
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
                }
              }
            }
            ... on StorageLimitExceededErr {
              reason
              tierName
              retainedStorageUsedBytes
              retainedStorageLimitBytes
              remainingStorageBytes
            }
          }
        }
      }
      stream {
        id
        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
            }
            ... on StorageLimitExceededErr {
              reason
              tierName
              retainedStorageUsedBytes
              retainedStorageLimitBytes
              remainingStorageBytes
            }
          }
        }
      }
    }
  }
`;
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 {
        ...UploadStreamWithDetails
      }
      pageInfo {
        hasNextPage
        endCursor
      }
    }
  }
  ${UploadStreamWithDetailsFragmentDoc}
`;

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