From 02592845448edf2e8ceeaa346e8dc178317857a2 Mon Sep 17 00:00:00 2001
From: Volodymyr Smolianinov <voidozzer@gmail.com>
Date: Thu, 31 Oct 2024 15:08:36 +0100
Subject: [PATCH] Add doesUsenameExist query

---
 src/index.tsx           | 7327 ++++++++++-----------------------------
 src/operations/user.gql |    4 +
 2 files changed, 1826 insertions(+), 5505 deletions(-)

diff --git a/src/index.tsx b/src/index.tsx
index 5c9b350..7fa0bc7 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -1,48 +1,35 @@
-import * as Apollo from "@apollo/client";
-import { gql } from "@apollo/client";
+import { gql } from '@apollo/client';
+import * as Apollo 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;
-    };
+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 };
+  ID: { input: string; output: string; }
+  String: { input: string; output: string; }
+  Boolean: { input: boolean; output: boolean; }
+  Int: { input: number; output: number; }
+  Float: { input: number; output: number; }
   /** Date (isoformat) */
-  Date: { input: any; output: any };
+  Date: { input: any; output: any; }
   /** Date with time (isoformat) */
-  DateTime: { input: any; output: any };
+  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 };
+  JSON: { input: any; output: any; }
 };
 
 export type AddShotAnnotationErrors = {
-  __typename?: "AddShotAnnotationErrors";
+  __typename?: 'AddShotAnnotationErrors';
   error: DoesNotOwnShotErrOtherErrorNeedsNote;
 };
 
 export type AddShotAnnotationReturn = {
-  __typename?: "AddShotAnnotationReturn";
+  __typename?: 'AddShotAnnotationReturn';
   value: SuccessfulAddAddShotAnnotationErrors;
 };
 
@@ -52,1847 +39,201 @@ export type AggregateInputGql = {
 };
 
 export type AggregateResultGql = {
-  __typename?: "AggregateResultGQL";
+  __typename?: 'AggregateResultGQL';
   aggregationIdentifiers: Array<AggregationIdentifierGql>;
   targetMetrics: TargetMetricsGql;
 };
 
 export type AggregationIdentifierGql = {
-  __typename?: "AggregationIdentifierGQL";
-  featureName: Scalars["String"]["output"];
-  groupName: Scalars["String"]["output"];
+  __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 };
+  { 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",
+  Day = 'DAY',
+  Month = 'MONTH',
+  Week = 'WEEK',
+  Year = 'YEAR'
 }
 
 export type BankFeaturesGql = {
-  __typename?: "BankFeaturesGQL";
-  bankAngle: Scalars["Float"]["output"];
-  distance: Scalars["Float"]["output"];
+  __typename?: 'BankFeaturesGQL';
+  bankAngle: Scalars['Float']['output'];
+  distance: Scalars['Float']['output'];
   wallsHit: Array<WallTypeEnum>;
 };
 
 export type BoundingBoxGql = {
-  __typename?: "BoundingBoxGQL";
-  height: Scalars["Float"]["output"];
-  left: Scalars["Float"]["output"];
-  top: Scalars["Float"]["output"];
-  width: Scalars["Float"]["output"];
+  __typename?: 'BoundingBoxGQL';
+  height: Scalars['Float']['output'];
+  left: Scalars['Float']['output'];
+  top: Scalars['Float']['output'];
+  width: Scalars['Float']['output'];
 };
 
 export type BucketGql = {
-  __typename?: "BucketGQL";
-  lowerBound: Scalars["Float"]["output"];
-  rangeKey: Scalars["String"]["output"];
+  __typename?: 'BucketGQL';
+  lowerBound: Scalars['Float']['output'];
+  rangeKey: Scalars['String']['output'];
 };
 
 export type BucketInputGql = {
-  lowerBound: Scalars["Float"]["input"];
-  rangeKey: Scalars["String"]["input"];
+  lowerBound: Scalars['Float']['input'];
+  rangeKey: Scalars['String']['input'];
 };
 
 export type BucketSetGql = {
-  __typename?: "BucketSetGQL";
+  __typename?: 'BucketSetGQL';
   buckets: Array<BucketGql>;
-  feature: Scalars["String"]["output"];
-  keyName: Scalars["String"]["output"];
+  feature: Scalars['String']['output'];
+  keyName: Scalars['String']['output'];
 };
 
 export type BucketSetInputGql = {
   buckets: Array<BucketInputGql>;
-  feature: Scalars["String"]["input"];
+  feature: Scalars['String']['input'];
 };
 
 export type CreateBucketSetInput = {
   buckets: Array<BucketInputGql>;
-  feature: Scalars["String"]["input"];
-  keyName: Scalars["String"]["input"];
+  feature: Scalars['String']['input'];
+  keyName: Scalars['String']['input'];
 };
 
 export type CreateUploadStreamReturn = {
-  __typename?: "CreateUploadStreamReturn";
-  videoId: Scalars["Int"]["output"];
+  __typename?: 'CreateUploadStreamReturn';
+  videoId: Scalars['Int']['output'];
 };
 
 export type CreatedAfter =
-  | { createdAt: Scalars["DateTime"]["input"]; videoId?: never }
-  | { createdAt?: never; videoId: Scalars["Int"]["input"] };
+  { 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"]>;
+  __typename?: 'CueObjectFeaturesGQL';
+  cueBallSpeed?: Maybe<Scalars['Float']['output']>;
+  cueObjectAngle?: Maybe<Scalars['Float']['output']>;
+  cueObjectDistance?: Maybe<Scalars['Float']['output']>;
   shotDirection?: Maybe<ShotDirectionEnum>;
   spinType?: Maybe<SpinTypeEnum>;
 };
 
 export type DateRangeFilter = {
-  greaterThan?: InputMaybe<Scalars["Date"]["input"]>;
-  greaterThanEqualTo?: InputMaybe<Scalars["Date"]["input"]>;
-  greaterThanInclusive?: Scalars["Boolean"]["input"];
-  includeOnNone?: Scalars["Boolean"]["input"];
-  lessThan?: InputMaybe<Scalars["Date"]["input"]>;
-  lessThanInclusive?: Scalars["Boolean"]["input"];
+  greaterThan?: InputMaybe<Scalars['Date']['input']>;
+  greaterThanEqualTo?: InputMaybe<Scalars['Date']['input']>;
+  greaterThanInclusive?: Scalars['Boolean']['input'];
+  includeOnNone?: Scalars['Boolean']['input'];
+  lessThan?: InputMaybe<Scalars['Date']['input']>;
+  lessThanInclusive?: Scalars['Boolean']['input'];
 };
 
 export type DatetimeRangeAggregationInput = {
-  endDatetime?: InputMaybe<Scalars["DateTime"]["input"]>;
-  feature?: Scalars["String"]["input"];
+  endDatetime?: InputMaybe<Scalars['DateTime']['input']>;
+  feature?: Scalars['String']['input'];
   interval: TimeInterval;
-  startDatetime?: InputMaybe<Scalars["DateTime"]["input"]>;
+  startDatetime?: InputMaybe<Scalars['DateTime']['input']>;
 };
 
 export type DatetimeShotOrdering = {
-  descending?: Scalars["Boolean"]["input"];
-  startingAt?: InputMaybe<Scalars["DateTime"]["input"]>;
+  descending?: Scalars['Boolean']['input'];
+  startingAt?: InputMaybe<Scalars['DateTime']['input']>;
 };
 
 export type DeployedConfigGql = {
-  __typename?: "DeployedConfigGQL";
-  allowNewUsers: Scalars["Boolean"]["output"];
-  devMode: Scalars["Boolean"]["output"];
-  environment: Scalars["String"]["output"];
-  firebase: Scalars["Boolean"]["output"];
-  minimumAllowedAppVersion: Scalars["String"]["output"];
+  __typename?: 'DeployedConfigGQL';
+  allowNewUsers: Scalars['Boolean']['output'];
+  devMode: Scalars['Boolean']['output'];
+  environment: Scalars['String']['output'];
+  firebase: Scalars['Boolean']['output'];
+  minimumAllowedAppVersion: Scalars['String']['output'];
 };
 
 export type DoesNotOwnShotErr = {
-  __typename?: "DoesNotOwnShotErr";
-  msg?: Maybe<Scalars["String"]["output"]>;
-  shotId: Scalars["Int"]["output"];
+  __typename?: 'DoesNotOwnShotErr';
+  msg?: Maybe<Scalars['String']['output']>;
+  shotId: Scalars['Int']['output'];
 };
 
-export type DoesNotOwnShotErrOtherErrorNeedsNote =
-  | DoesNotOwnShotErr
-  | OtherErrorNeedsNote;
+export type DoesNotOwnShotErrOtherErrorNeedsNote = DoesNotOwnShotErr | OtherErrorNeedsNote;
 
 export type EditUserInputGql = {
-  fargoRating?: InputMaybe<Scalars["Int"]["input"]>;
-  username?: InputMaybe<Scalars["String"]["input"]>;
+  fargoRating?: InputMaybe<Scalars['Int']['input']>;
+  username?: InputMaybe<Scalars['String']['input']>;
 };
 
 export type EnumAggregation = {
-  feature: Scalars["String"]["input"];
+  feature: Scalars['String']['input'];
 };
 
 export type FilterInput =
-  | {
-      andFilters: Array<FilterInput>;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations: Array<ShotAnnotationInput>;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut: Array<Scalars["Boolean"]["input"]>;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle: FloatRangeFilter;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance: FloatRangeFilter;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt: DateRangeFilter;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject: FloatRangeFilter;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed: FloatRangeFilter;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle: FloatRangeFilter;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance: FloatRangeFilter;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject: FloatRangeFilter;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty: FloatRangeFilter;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore: FloatRangeFilter;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating: FloatRangeFilter;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType: Array<PocketEnum>;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect: Array<Scalars["Boolean"]["input"]>;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft: Array<Scalars["Boolean"]["input"]>;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss: Array<Scalars["Boolean"]["input"]>;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight: Array<Scalars["Boolean"]["input"]>;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss: Array<Scalars["Boolean"]["input"]>;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight: Array<Scalars["Boolean"]["input"]>;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle: FloatRangeFilter;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance: FloatRangeFilter;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make: Array<Scalars["Boolean"]["input"]>;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees: FloatRangeFilter;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees: FloatRangeFilter;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter: FilterInput;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters: Array<FilterInput>;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength: FloatRangeFilter;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection: Array<ShotDirectionEnum>;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType: Array<SpinTypeEnum>;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize: FloatRangeFilter;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags: Array<VideoTagInput>;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle: FloatRangeFilter;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection: Array<ShotDirectionEnum>;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance: FloatRangeFilter;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance: FloatRangeFilter;
-      userId?: never;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId: Array<Scalars["Int"]["input"]>;
-      username?: never;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username: Array<Scalars["String"]["input"]>;
-      videoId?: never;
-    }
-  | {
-      andFilters?: never;
-      annotations?: never;
-      backcut?: never;
-      bankAngle?: never;
-      bankDistance?: never;
-      createdAt?: never;
-      cueAngleAfterObject?: never;
-      cueBallSpeed?: never;
-      cueObjectAngle?: never;
-      cueObjectDistance?: never;
-      cueSpeedAfterObject?: never;
-      difficulty?: never;
-      falsePositiveScore?: never;
-      fargoRating?: never;
-      intendedPocketType?: never;
-      isDirect?: never;
-      isLeft?: never;
-      isLeftMiss?: never;
-      isRight?: never;
-      isRightMiss?: never;
-      isStraight?: never;
-      kickAngle?: never;
-      kickDistance?: never;
-      make?: never;
-      marginOfErrorInDegrees?: never;
-      missAngleInDegrees?: never;
-      notFilter?: never;
-      orFilters?: never;
-      runLength?: never;
-      shotDirection?: never;
-      spinType?: never;
-      tableSize?: never;
-      tags?: never;
-      targetPocketAngle?: never;
-      targetPocketAngleDirection?: never;
-      targetPocketDistance?: never;
-      totalDistance?: never;
-      userId?: never;
-      username?: never;
-      videoId: Array<Scalars["Int"]["input"]>;
-    };
+  { andFilters: Array<FilterInput>; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations: Array<ShotAnnotationInput>; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut: Array<Scalars['Boolean']['input']>; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle: FloatRangeFilter; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance: FloatRangeFilter; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt: DateRangeFilter; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject: FloatRangeFilter; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed: FloatRangeFilter; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle: FloatRangeFilter; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance: FloatRangeFilter; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject: FloatRangeFilter; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty: FloatRangeFilter; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore: FloatRangeFilter; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating: FloatRangeFilter; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType: Array<PocketEnum>; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect: Array<Scalars['Boolean']['input']>; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft: Array<Scalars['Boolean']['input']>; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss: Array<Scalars['Boolean']['input']>; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight: Array<Scalars['Boolean']['input']>; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss: Array<Scalars['Boolean']['input']>; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight: Array<Scalars['Boolean']['input']>; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle: FloatRangeFilter; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance: FloatRangeFilter; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make: Array<Scalars['Boolean']['input']>; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees: FloatRangeFilter; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees: FloatRangeFilter; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter: FilterInput; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters: Array<FilterInput>; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength: FloatRangeFilter; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection: Array<ShotDirectionEnum>; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType: Array<SpinTypeEnum>; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize: FloatRangeFilter; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags: Array<VideoTagInput>; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle: FloatRangeFilter; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection: Array<ShotDirectionEnum>; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance: FloatRangeFilter; totalDistance?: never; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance: FloatRangeFilter; userId?: never; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId: Array<Scalars['Int']['input']>; username?: never; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username: Array<Scalars['String']['input']>; videoId?: never; }
+  |  { andFilters?: never; annotations?: never; backcut?: never; bankAngle?: never; bankDistance?: never; createdAt?: never; cueAngleAfterObject?: never; cueBallSpeed?: never; cueObjectAngle?: never; cueObjectDistance?: never; cueSpeedAfterObject?: never; difficulty?: never; falsePositiveScore?: never; fargoRating?: never; intendedPocketType?: never; isDirect?: never; isLeft?: never; isLeftMiss?: never; isRight?: never; isRightMiss?: never; isStraight?: never; kickAngle?: never; kickDistance?: never; make?: never; marginOfErrorInDegrees?: never; missAngleInDegrees?: never; notFilter?: never; orFilters?: never; runLength?: never; shotDirection?: never; spinType?: never; tableSize?: never; tags?: never; targetPocketAngle?: never; targetPocketAngleDirection?: never; targetPocketDistance?: never; totalDistance?: never; userId?: never; username?: never; videoId: Array<Scalars['Int']['input']>; };
 
 export type FloatRangeFilter = {
-  greaterThan?: InputMaybe<Scalars["Float"]["input"]>;
-  greaterThanEqualTo?: InputMaybe<Scalars["Float"]["input"]>;
-  greaterThanInclusive?: Scalars["Boolean"]["input"];
-  includeOnNone?: Scalars["Boolean"]["input"];
-  lessThan?: InputMaybe<Scalars["Float"]["input"]>;
-  lessThanInclusive?: Scalars["Boolean"]["input"];
+  greaterThan?: InputMaybe<Scalars['Float']['input']>;
+  greaterThanEqualTo?: InputMaybe<Scalars['Float']['input']>;
+  greaterThanInclusive?: Scalars['Boolean']['input'];
+  includeOnNone?: Scalars['Boolean']['input'];
+  lessThan?: InputMaybe<Scalars['Float']['input']>;
+  lessThanInclusive?: Scalars['Boolean']['input'];
 };
 
 export type FloatShotOrdering = {
-  descending?: Scalars["Boolean"]["input"];
-  startingAt?: InputMaybe<Scalars["Float"]["input"]>;
+  descending?: Scalars['Boolean']['input'];
+  startingAt?: InputMaybe<Scalars['Float']['input']>;
 };
 
 export type GetProfileUploadLinkErrors = {
-  __typename?: "GetProfileUploadLinkErrors";
+  __typename?: 'GetProfileUploadLinkErrors';
   error: TooManyProfileImageUploadsErr;
 };
 
 export type GetProfileUploadLinkReturn = {
-  __typename?: "GetProfileUploadLinkReturn";
+  __typename?: 'GetProfileUploadLinkReturn';
   value: UploadLinkGetProfileUploadLinkErrors;
 };
 
@@ -1902,222 +243,229 @@ export type GetShotsOrdering = {
 
 export type GetShotsPagination = {
   createdAfter: CreatedAfter;
-  startFrameAfter: Scalars["Int"]["input"];
+  startFrameAfter: Scalars['Int']['input'];
 };
 
 export type GetShotsResult = {
-  __typename?: "GetShotsResult";
-  count?: Maybe<Scalars["Int"]["output"]>;
-  ids: Array<Scalars["Int"]["output"]>;
+  __typename?: 'GetShotsResult';
+  count?: Maybe<Scalars['Int']['output']>;
+  ids: Array<Scalars['Int']['output']>;
   shots: Array<ShotGql>;
 };
 
 export type GetUploadLinkErrors = {
-  __typename?: "GetUploadLinkErrors";
+  __typename?: 'GetUploadLinkErrors';
   error: MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErr;
 };
 
 export type GetUploadLinkReturn = {
-  __typename?: "GetUploadLinkReturn";
+  __typename?: 'GetUploadLinkReturn';
   stream?: Maybe<UploadStreamGql>;
   value: UploadLinkGetUploadLinkErrors;
 };
 
 export type HlsPlaylistGql = {
-  __typename?: "HLSPlaylistGQL";
-  m3u8Text: Scalars["String"]["output"];
-  segmentDurations: Array<Scalars["Float"]["output"]>;
-  segmentStartTimes: Array<Scalars["Float"]["output"]>;
-  videoId: Scalars["Int"]["output"];
+  __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"];
+  __typename?: 'Header';
+  key: Scalars['String']['output'];
+  value: Scalars['String']['output'];
 };
 
 export type HomographyInfoGql = {
-  __typename?: "HomographyInfoGQL";
+  __typename?: 'HomographyInfoGQL';
   crop: BoundingBoxGql;
   destPoints: PocketPointsGql;
-  frameIndex: Scalars["Int"]["output"];
+  frameIndex: Scalars['Int']['output'];
   pockets: Array<BoundingBoxGql>;
   sourcePoints: PocketPointsGql;
 };
 
 export enum InitPlaylistUploadStatusEnum {
-  NotApplicable = "NOT_APPLICABLE",
-  NotUploaded = "NOT_UPLOADED",
-  Uploaded = "UPLOADED",
+  NotApplicable = 'NOT_APPLICABLE',
+  NotUploaded = 'NOT_UPLOADED',
+  Uploaded = 'UPLOADED'
 }
 
 export type InitUploadAlreadyCompletedErr = {
-  __typename?: "InitUploadAlreadyCompletedErr";
+  __typename?: 'InitUploadAlreadyCompletedErr';
   segmentType: StreamSegmentTypeEnum;
 };
 
 export type IntPoint2D = {
-  __typename?: "IntPoint2D";
-  x: Scalars["Int"]["output"];
-  y: Scalars["Int"]["output"];
+  __typename?: 'IntPoint2D';
+  x: Scalars['Int']['output'];
+  y: Scalars['Int']['output'];
 };
 
 export type IntShotOrdering = {
-  descending?: Scalars["Boolean"]["input"];
-  startingAt?: InputMaybe<Scalars["Int"]["input"]>;
+  descending?: Scalars['Boolean']['input'];
+  startingAt?: InputMaybe<Scalars['Int']['input']>;
 };
 
 export type MakePercentageIntervalGql = {
-  __typename?: "MakePercentageIntervalGQL";
-  elapsedTime: Scalars["Float"]["output"];
-  makePercentage: Scalars["Float"]["output"];
+  __typename?: 'MakePercentageIntervalGQL';
+  elapsedTime: Scalars['Float']['output'];
+  makePercentage: Scalars['Float']['output'];
 };
 
 export type MedalGql = {
-  __typename?: "MedalGQL";
-  count: Scalars["Int"]["output"];
+  __typename?: 'MedalGQL';
+  count: Scalars['Int']['output'];
 };
 
 export type MedalScope =
-  | { interval: TimeInterval; videoId?: never }
-  | { interval?: never; videoId: Scalars["Int"]["input"] };
+  { interval: TimeInterval; videoId?: never; }
+  |  { interval?: never; videoId: Scalars['Int']['input']; };
 
 export type MustHaveSetForUploadLinkErr = {
-  __typename?: "MustHaveSetForUploadLinkErr";
-  framesPerSecond?: Maybe<Scalars["Boolean"]["output"]>;
-  resolution?: Maybe<Scalars["Boolean"]["output"]>;
+  __typename?: 'MustHaveSetForUploadLinkErr';
+  framesPerSecond?: Maybe<Scalars['Boolean']['output']>;
+  resolution?: Maybe<Scalars['Boolean']['output']>;
 };
 
-export type MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErr =
-
-    | InitUploadAlreadyCompletedErr
-    | MustHaveSetForUploadLinkErr
-    | NoInitForChunkedUploadErr
-    | ProcessingFailedErr
-    | SegmentAlreadyUploadedErr
-    | TooManyInitUploadsErr
-    | TooManyProfileImageUploadsErr;
+export type MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailedErrNoInitForChunkedUploadErrTooManyProfileImageUploadsErrInitUploadAlreadyCompletedErrTooManyInitUploadsErr = InitUploadAlreadyCompletedErr | MustHaveSetForUploadLinkErr | NoInitForChunkedUploadErr | ProcessingFailedErr | SegmentAlreadyUploadedErr | TooManyInitUploadsErr | TooManyProfileImageUploadsErr;
 
 export type Mutation = {
-  __typename?: "Mutation";
+  __typename?: 'Mutation';
   addAnnotationToShot: AddShotAnnotationReturn;
   createBucketSet: BucketSetGql;
   createUploadStream: CreateUploadStreamReturn;
-  deleteVideo: Scalars["Boolean"]["output"];
+  deleteVideo: Scalars['Boolean']['output'];
   editProfileImageUri: UserGql;
-  editUploadStream: Scalars["Boolean"]["output"];
+  editUploadStream: Scalars['Boolean']['output'];
   editUser: UserGql;
   followUser: UserGql;
   getHlsInitUploadLink: GetUploadLinkReturn;
   getProfileImageUploadLink: GetProfileUploadLinkReturn;
   getUploadLink: GetUploadLinkReturn;
-  setLoggerLevel: Scalars["Boolean"]["output"];
-  setSegmentDuration: Scalars["Boolean"]["output"];
+  setLoggerLevel: Scalars['Boolean']['output'];
+  setSegmentDuration: Scalars['Boolean']['output'];
   unfollowUser: UserGql;
   updateShotAnnotations: UpdateShotAnnotationReturn;
 };
 
+
 export type MutationAddAnnotationToShotArgs = {
-  annotationName: Scalars["String"]["input"];
-  notes?: InputMaybe<Scalars["String"]["input"]>;
-  shotId: Scalars["Int"]["input"];
+  annotationName: Scalars['String']['input'];
+  notes?: InputMaybe<Scalars['String']['input']>;
+  shotId: Scalars['Int']['input'];
 };
 
+
 export type MutationCreateBucketSetArgs = {
   params: CreateBucketSetInput;
 };
 
+
 export type MutationCreateUploadStreamArgs = {
   videoMetadata: VideoMetadataInput;
 };
 
+
 export type MutationDeleteVideoArgs = {
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 };
 
+
 export type MutationEditProfileImageUriArgs = {
-  profileImageUri: Scalars["String"]["input"];
+  profileImageUri: Scalars['String']['input'];
 };
 
+
 export type MutationEditUploadStreamArgs = {
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
   videoMetadata: VideoMetadataInput;
 };
 
+
 export type MutationEditUserArgs = {
   input: EditUserInputGql;
 };
 
+
 export type MutationFollowUserArgs = {
-  followedUserId: Scalars["Int"]["input"];
+  followedUserId: Scalars['Int']['input'];
 };
 
+
 export type MutationGetHlsInitUploadLinkArgs = {
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 };
 
+
 export type MutationGetProfileImageUploadLinkArgs = {
-  fileExt?: InputMaybe<Scalars["String"]["input"]>;
+  fileExt?: InputMaybe<Scalars['String']['input']>;
 };
 
+
 export type MutationGetUploadLinkArgs = {
-  segmentIndex: Scalars["Int"]["input"];
-  videoId: Scalars["Int"]["input"];
+  segmentIndex: Scalars['Int']['input'];
+  videoId: Scalars['Int']['input'];
 };
 
+
 export type MutationSetLoggerLevelArgs = {
-  level: Scalars["String"]["input"];
-  path: Scalars["String"]["input"];
+  level: Scalars['String']['input'];
+  path: Scalars['String']['input'];
 };
 
+
 export type MutationSetSegmentDurationArgs = {
-  duration: Scalars["Float"]["input"];
-  segmentIndex: Scalars["Int"]["input"];
-  videoId: Scalars["Int"]["input"];
+  duration: Scalars['Float']['input'];
+  segmentIndex: Scalars['Int']['input'];
+  videoId: Scalars['Int']['input'];
 };
 
+
 export type MutationUnfollowUserArgs = {
-  followedUserId: Scalars["Int"]["input"];
+  followedUserId: Scalars['Int']['input'];
 };
 
+
 export type MutationUpdateShotAnnotationsArgs = {
   annotations: Array<UpdateAnnotationInputGql>;
-  shotId: Scalars["Int"]["input"];
+  shotId: Scalars['Int']['input'];
 };
 
 export type NoInitForChunkedUploadErr = {
-  __typename?: "NoInitForChunkedUploadErr";
+  __typename?: 'NoInitForChunkedUploadErr';
   segmentType: StreamSegmentTypeEnum;
 };
 
 export type OtherErrorNeedsNote = {
-  __typename?: "OtherErrorNeedsNote";
-  msg?: Maybe<Scalars["String"]["output"]>;
+  __typename?: 'OtherErrorNeedsNote';
+  msg?: Maybe<Scalars['String']['output']>;
 };
 
 export type PageInfoGql = {
-  __typename?: "PageInfoGQL";
-  endCursor?: Maybe<Scalars["String"]["output"]>;
-  hasNextPage: Scalars["Boolean"]["output"];
+  __typename?: 'PageInfoGQL';
+  endCursor?: Maybe<Scalars['String']['output']>;
+  hasNextPage: Scalars['Boolean']['output'];
 };
 
 export enum PocketEnum {
-  Corner = "CORNER",
-  Side = "SIDE",
+  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",
+  BottomLeft = 'BOTTOM_LEFT',
+  BottomRight = 'BOTTOM_RIGHT',
+  BottomSide = 'BOTTOM_SIDE',
+  TopLeft = 'TOP_LEFT',
+  TopRight = 'TOP_RIGHT',
+  TopSide = 'TOP_SIDE'
 }
 
 export type PocketPointsGql = {
-  __typename?: "PocketPointsGQL";
+  __typename?: 'PocketPointsGQL';
   bottomLeft: IntPoint2D;
   bottomRight: IntPoint2D;
   bottomSide: IntPoint2D;
@@ -2127,43 +475,43 @@ export type PocketPointsGql = {
 };
 
 export type PocketingIntentionFeaturesGql = {
-  __typename?: "PocketingIntentionFeaturesGQL";
-  backcut?: Maybe<Scalars["Boolean"]["output"]>;
-  difficulty?: Maybe<Scalars["Float"]["output"]>;
+  __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"]>;
+  make?: Maybe<Scalars['Boolean']['output']>;
+  marginOfErrorInDegrees?: Maybe<Scalars['Float']['output']>;
+  targetPocketAngle?: Maybe<Scalars['Float']['output']>;
   targetPocketAngleDirection?: Maybe<ShotDirectionEnum>;
-  targetPocketDistance?: Maybe<Scalars["Float"]["output"]>;
+  targetPocketDistance?: Maybe<Scalars['Float']['output']>;
 };
 
 export type PocketingIntentionInfoGql = {
-  __typename?: "PocketingIntentionInfoGQL";
-  ballId: Scalars["Int"]["output"];
-  pathMetadataIndex: Scalars["Int"]["output"];
+  __typename?: 'PocketingIntentionInfoGQL';
+  ballId: Scalars['Int']['output'];
+  pathMetadataIndex: Scalars['Int']['output'];
   pocketId: PocketIdentifier;
 };
 
 export type ProcessingFailedErr = {
-  __typename?: "ProcessingFailedErr";
+  __typename?: 'ProcessingFailedErr';
   processing: VideoProcessingGql;
 };
 
 export enum ProcessingStatusEnum {
-  Created = "CREATED",
-  Failed = "FAILED",
-  Queued = "QUEUED",
-  ReextractingFeatures = "REEXTRACTING_FEATURES",
-  Running = "RUNNING",
-  Started = "STARTED",
-  Succeeded = "SUCCEEDED",
-  Suspended = "SUSPENDED",
+  Created = 'CREATED',
+  Failed = 'FAILED',
+  Queued = 'QUEUED',
+  ReextractingFeatures = 'REEXTRACTING_FEATURES',
+  Running = 'RUNNING',
+  Started = 'STARTED',
+  Succeeded = 'SUCCEEDED',
+  Suspended = 'SUSPENDED'
 }
 
 export type Query = {
-  __typename?: "Query";
-  doesUsernameExist: Scalars["Boolean"]["output"];
+  __typename?: 'Query';
+  doesUsernameExist: Scalars['Boolean']['output'];
   getAggregatedShotMetrics: Array<AggregateResultGql>;
   getBucketSet?: Maybe<BucketSetGql>;
   getDeployedConfig: DeployedConfigGql;
@@ -2180,112 +528,131 @@ export type Query = {
   getUserRelationshipsMatching: UserRelationshipsResult;
   getUserTags: Array<TagGql>;
   getUserVideos: VideoHistoryGql;
-  getUsernames: Array<Scalars["String"]["output"]>;
+  getUsernames: Array<Scalars['String']['output']>;
   getVideo: VideoGql;
   getVideoMakePercentageIntervals: Array<MakePercentageIntervalGql>;
   getVideos: Array<VideoGql>;
-  waitFor: Scalars["Float"]["output"];
+  waitFor: Scalars['Float']['output'];
 };
 
+
 export type QueryDoesUsernameExistArgs = {
-  candidateUsername: Scalars["String"]["input"];
+  candidateUsername: Scalars['String']['input'];
 };
 
+
 export type QueryGetAggregatedShotMetricsArgs = {
   aggregateInput: AggregateInputGql;
 };
 
+
 export type QueryGetBucketSetArgs = {
-  keyName: Scalars["String"]["input"];
+  keyName: Scalars['String']['input'];
 };
 
+
 export type QueryGetFeedVideosArgs = {
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  after?: InputMaybe<Scalars['String']['input']>;
   filters?: InputMaybe<VideoFilterInput>;
-  limit?: Scalars["Int"]["input"];
+  limit?: Scalars['Int']['input'];
 };
 
+
 export type QueryGetMedalsArgs = {
   scope: MedalScope;
-  userId?: InputMaybe<Scalars["Int"]["input"]>;
+  userId?: InputMaybe<Scalars['Int']['input']>;
 };
 
+
 export type QueryGetOrderedShotsArgs = {
   filterInput: FilterInput;
-  ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
-  limit?: Scalars["Int"]["input"];
+  ids?: InputMaybe<Array<Scalars['Int']['input']>>;
+  limit?: Scalars['Int']['input'];
   shotsOrdering?: InputMaybe<GetShotsOrdering>;
 };
 
+
 export type QueryGetPlayTimeArgs = {
-  userId: Scalars["Int"]["input"];
+  userId: Scalars['Int']['input'];
 };
 
+
 export type QueryGetShotAnnotationTypesArgs = {
-  errorTypes?: InputMaybe<Scalars["Boolean"]["input"]>;
+  errorTypes?: InputMaybe<Scalars['Boolean']['input']>;
 };
 
+
 export type QueryGetShotsArgs = {
   filterInput: FilterInput;
-  limit?: Scalars["Int"]["input"];
+  limit?: Scalars['Int']['input'];
   shotsPagination?: InputMaybe<GetShotsPagination>;
 };
 
+
 export type QueryGetShotsByIdsArgs = {
-  ids: Array<Scalars["Int"]["input"]>;
+  ids: Array<Scalars['Int']['input']>;
 };
 
+
 export type QueryGetShotsWithMetadataArgs = {
   filterInput: FilterInput;
-  ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
-  limit?: Scalars["Int"]["input"];
+  ids?: InputMaybe<Array<Scalars['Int']['input']>>;
+  limit?: Scalars['Int']['input'];
   shotsPagination?: InputMaybe<GetShotsPagination>;
 };
 
+
 export type QueryGetUserArgs = {
-  userId: Scalars["Int"]["input"];
+  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"];
+  after?: InputMaybe<Scalars['String']['input']>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  matchString?: InputMaybe<Scalars['String']['input']>;
+  userId: Scalars['Int']['input'];
 };
 
+
 export type QueryGetUserVideosArgs = {
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  after?: InputMaybe<Scalars['String']['input']>;
   filters?: InputMaybe<VideoFilterInput>;
-  limit?: Scalars["Int"]["input"];
-  userId?: InputMaybe<Scalars["Int"]["input"]>;
+  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"]>;
+  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"];
+  debuggingJson?: InputMaybe<Scalars['JSON']['input']>;
+  videoId: Scalars['Int']['input'];
 };
 
+
 export type QueryGetVideoMakePercentageIntervalsArgs = {
-  intervalDuration?: Scalars["Int"]["input"];
-  videoId: Scalars["ID"]["input"];
+  intervalDuration?: Scalars['Int']['input'];
+  videoId: Scalars['ID']['input'];
 };
 
+
 export type QueryGetVideosArgs = {
-  videoIds: Array<Scalars["Int"]["input"]>;
+  videoIds: Array<Scalars['Int']['input']>;
 };
 
+
 export type QueryWaitForArgs = {
-  duration: Scalars["Float"]["input"];
+  duration: Scalars['Float']['input'];
 };
 
 export type RequestedMedalsGql = {
-  __typename?: "RequestedMedalsGQL";
+  __typename?: 'RequestedMedalsGQL';
   dayStreak2?: Maybe<MedalGql>;
   dayStreak3?: Maybe<MedalGql>;
   dayStreak4?: Maybe<MedalGql>;
@@ -2323,1673 +690,724 @@ export type RequestedMedalsGql = {
 };
 
 export type SegmentAlreadyUploadedErr = {
-  __typename?: "SegmentAlreadyUploadedErr";
-  segmentId: Scalars["Int"]["output"];
+  __typename?: 'SegmentAlreadyUploadedErr';
+  segmentId: Scalars['Int']['output'];
 };
 
 export type SegmentEndFramesGql = {
-  __typename?: "SegmentEndFramesGQL";
-  id: Scalars["Int"]["output"];
-  segmentEndFrames: Array<Scalars["Int"]["output"]>;
+  __typename?: 'SegmentEndFramesGQL';
+  id: Scalars['Int']['output'];
+  segmentEndFrames: Array<Scalars['Int']['output']>;
 };
 
 export type SegmentStartTimesGql = {
-  __typename?: "SegmentStartTimesGQL";
-  id: Scalars["Int"]["output"];
-  segmentStartTimes: Array<Scalars["Float"]["output"]>;
+  __typename?: 'SegmentStartTimesGQL';
+  id: Scalars['Int']['output'];
+  segmentStartTimes: Array<Scalars['Float']['output']>;
 };
 
 export type SerializedShotPathsGql = {
-  __typename?: "SerializedShotPathsGQL";
-  b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
+  __typename?: 'SerializedShotPathsGQL';
+  b64EncodedBuffer?: Maybe<Scalars['String']['output']>;
 };
 
 export type ShotAnnotationGql = {
-  __typename?: "ShotAnnotationGQL";
-  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
+  __typename?: 'ShotAnnotationGQL';
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
   creator: UserGql;
-  errorDefault: Scalars["Boolean"]["output"];
-  notes: Scalars["String"]["output"];
-  shotId: Scalars["Int"]["output"];
+  errorDefault: Scalars['Boolean']['output'];
+  notes: Scalars['String']['output'];
+  shotId: Scalars['Int']['output'];
   type: ShotAnnotationTypeGql;
-  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
 };
 
 export type ShotAnnotationInput = {
-  name: Scalars["String"]["input"];
+  name: Scalars['String']['input'];
 };
 
 export type ShotAnnotationTypeGql = {
-  __typename?: "ShotAnnotationTypeGQL";
-  id: Scalars["Int"]["output"];
-  name: Scalars["String"]["output"];
+  __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"];
+  __typename?: 'ShotDirectionCountsGQL';
+  left: Scalars['Int']['output'];
+  right: Scalars['Int']['output'];
+  straight: Scalars['Int']['output'];
 };
 
 export enum ShotDirectionEnum {
-  Left = "LEFT",
-  Right = "RIGHT",
-  Straight = "STRAIGHT",
+  Left = 'LEFT',
+  Right = 'RIGHT',
+  Straight = 'STRAIGHT'
 }
 
 export type ShotGql = {
-  __typename?: "ShotGQL";
+  __typename?: 'ShotGQL';
   annotations: Array<ShotAnnotationGql>;
   bankFeatures?: Maybe<BankFeaturesGql>;
-  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
   cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
-  endFrame: Scalars["Int"]["output"];
-  endTime: Scalars["Float"]["output"];
-  falsePositiveScore?: Maybe<Scalars["Float"]["output"]>;
-  id: Scalars["Int"]["output"];
+  endFrame: Scalars['Int']['output'];
+  endTime: Scalars['Float']['output'];
+  falsePositiveScore?: Maybe<Scalars['Float']['output']>;
+  id: Scalars['Int']['output'];
   pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
   pocketingIntentionInfo?: Maybe<PocketingIntentionInfoGql>;
   serializedShotPaths?: Maybe<SerializedShotPathsGql>;
-  startFrame: Scalars["Int"]["output"];
-  startTime: Scalars["Float"]["output"];
-  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  startFrame: Scalars['Int']['output'];
+  startTime: Scalars['Float']['output'];
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
   user?: Maybe<UserGql>;
   video?: Maybe<VideoGql>;
-  videoId: Scalars["Int"]["output"];
+  videoId: Scalars['Int']['output'];
 };
 
 export type ShotsOrderingComponent =
-  | {
-      marginOfError: FloatShotOrdering;
-      runLength?: never;
-      startFrame?: never;
-      videoCreation?: never;
-      videoId?: never;
-    }
-  | {
-      marginOfError?: never;
-      runLength: IntShotOrdering;
-      startFrame?: never;
-      videoCreation?: never;
-      videoId?: never;
-    }
-  | {
-      marginOfError?: never;
-      runLength?: never;
-      startFrame: IntShotOrdering;
-      videoCreation?: never;
-      videoId?: never;
-    }
-  | {
-      marginOfError?: never;
-      runLength?: never;
-      startFrame?: never;
-      videoCreation: DatetimeShotOrdering;
-      videoId?: never;
-    }
-  | {
-      marginOfError?: never;
-      runLength?: never;
-      startFrame?: never;
-      videoCreation?: never;
-      videoId: IntShotOrdering;
-    };
+  { marginOfError: FloatShotOrdering; runLength?: never; startFrame?: never; videoCreation?: never; videoId?: never; }
+  |  { marginOfError?: never; runLength: IntShotOrdering; startFrame?: never; videoCreation?: never; videoId?: never; }
+  |  { marginOfError?: never; runLength?: never; startFrame: IntShotOrdering; videoCreation?: never; videoId?: never; }
+  |  { marginOfError?: never; runLength?: never; startFrame?: never; videoCreation: DatetimeShotOrdering; videoId?: never; }
+  |  { marginOfError?: never; runLength?: never; startFrame?: never; videoCreation?: never; videoId: IntShotOrdering; };
 
 export type SpinTypeCountsGql = {
-  __typename?: "SpinTypeCountsGQL";
-  center: Scalars["Int"]["output"];
-  draw: Scalars["Int"]["output"];
-  follow: Scalars["Int"]["output"];
-  unknown: Scalars["Int"]["output"];
+  __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",
+  Center = 'CENTER',
+  Draw = 'DRAW',
+  Follow = 'FOLLOW',
+  Unknown = 'UNKNOWN'
 }
 
 export type StreamErrorGql = {
-  __typename?: "StreamErrorGQL";
-  message: Scalars["String"]["output"];
+  __typename?: 'StreamErrorGQL';
+  message: Scalars['String']['output'];
 };
 
 export enum StreamSegmentTypeEnum {
-  FragmentedMp4 = "FRAGMENTED_MP4",
-  RbChunkedMp4 = "RB_CHUNKED_MP4",
+  FragmentedMp4 = 'FRAGMENTED_MP4',
+  RbChunkedMp4 = 'RB_CHUNKED_MP4'
 }
 
 export type SuccessfulAdd = {
-  __typename?: "SuccessfulAdd";
-  value: Scalars["Boolean"]["output"];
+  __typename?: 'SuccessfulAdd';
+  value: Scalars['Boolean']['output'];
 };
 
-export type SuccessfulAddAddShotAnnotationErrors =
-  | AddShotAnnotationErrors
-  | SuccessfulAdd;
+export type SuccessfulAddAddShotAnnotationErrors = AddShotAnnotationErrors | SuccessfulAdd;
 
 export type TagGql = {
-  __typename?: "TagGQL";
-  group?: Maybe<Scalars["String"]["output"]>;
-  id: Scalars["Int"]["output"];
-  name: Scalars["String"]["output"];
+  __typename?: 'TagGQL';
+  group?: Maybe<Scalars['String']['output']>;
+  id: Scalars['Int']['output'];
+  name: Scalars['String']['output'];
 };
 
 export type TargetMetricsGql = {
-  __typename?: "TargetMetricsGQL";
-  averageDifficulty?: Maybe<Scalars["Float"]["output"]>;
-  count: Scalars["Int"]["output"];
-  makePercentage?: Maybe<Scalars["Float"]["output"]>;
+  __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"]>;
+  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 };
+  { aligned: AlignedIntervalEnum; timedelta?: never; }
+  |  { aligned?: never; timedelta: TimeDeltaGql; };
 
 export type TooManyInitUploadsErr = {
-  __typename?: "TooManyInitUploadsErr";
-  linksRequested: Scalars["Int"]["output"];
+  __typename?: 'TooManyInitUploadsErr';
+  linksRequested: Scalars['Int']['output'];
 };
 
 export type TooManyProfileImageUploadsErr = {
-  __typename?: "TooManyProfileImageUploadsErr";
-  linksRequested: Scalars["Int"]["output"];
+  __typename?: 'TooManyProfileImageUploadsErr';
+  linksRequested: Scalars['Int']['output'];
 };
 
 export type UpdateAnnotationInputGql = {
-  name: Scalars["String"]["input"];
-  notes?: InputMaybe<Scalars["String"]["input"]>;
+  name: Scalars['String']['input'];
+  notes?: InputMaybe<Scalars['String']['input']>;
 };
 
 export type UpdateShotAnnotationReturn = {
-  __typename?: "UpdateShotAnnotationReturn";
+  __typename?: 'UpdateShotAnnotationReturn';
   error?: Maybe<DoesNotOwnShotErr>;
   shot?: Maybe<ShotGql>;
 };
 
 export type UploadLink = {
-  __typename?: "UploadLink";
+  __typename?: 'UploadLink';
   headers: Array<Maybe<Header>>;
-  uploadUrl: Scalars["String"]["output"];
+  uploadUrl: Scalars['String']['output'];
 };
 
-export type UploadLinkGetProfileUploadLinkErrors =
-  | GetProfileUploadLinkErrors
-  | UploadLink;
+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"];
+  __typename?: 'UploadSegmentGQL';
+  durationInSeconds?: Maybe<Scalars['Float']['output']>;
+  endFrameIndex?: Maybe<Scalars['Int']['output']>;
+  framesPerSecond?: Maybe<Scalars['Float']['output']>;
+  linksRequested: Scalars['Int']['output'];
+  segmentIndex: Scalars['Int']['output'];
+  uploaded: Scalars['Boolean']['output'];
+  valid: Scalars['Boolean']['output'];
 };
 
 export type UploadStreamGql = {
-  __typename?: "UploadStreamGQL";
-  createdAt: Scalars["DateTime"]["output"];
+  __typename?: 'UploadStreamGQL';
+  createdAt: Scalars['DateTime']['output'];
   errors: Array<StreamErrorGql>;
-  id: Scalars["ID"]["output"];
+  id: Scalars['ID']['output'];
   initPlaylistUploadStatus?: Maybe<InitPlaylistUploadStatusEnum>;
-  isCompleted: Scalars["Boolean"]["output"];
-  lastIntendedSegmentBound?: Maybe<Scalars["Int"]["output"]>;
-  linksRequested: Scalars["Int"]["output"];
-  lowestUnuploadedSegmentIndex: Scalars["Int"]["output"];
+  isCompleted: Scalars['Boolean']['output'];
+  lastIntendedSegmentBound?: Maybe<Scalars['Int']['output']>;
+  linksRequested: Scalars['Int']['output'];
+  lowestUnuploadedSegmentIndex: Scalars['Int']['output'];
   resolution: VideoResolutionGql;
-  segmentEndFrames: Array<Scalars["Int"]["output"]>;
-  segmentProcessingCursor: Scalars["Int"]["output"];
+  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"];
+  updatedAt: Scalars['DateTime']['output'];
+  uploadCompletionCursor: Scalars['Int']['output'];
+  uploadsCompleted: Scalars['Int']['output'];
 };
 
 export type UserGql = {
-  __typename?: "UserGQL";
-  activeVideoId?: Maybe<Scalars["Int"]["output"]>;
-  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
-  fargoRating?: Maybe<Scalars["Int"]["output"]>;
-  firebaseUid?: Maybe<Scalars["String"]["output"]>;
+  __typename?: 'UserGQL';
+  activeVideoId?: Maybe<Scalars['Int']['output']>;
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
+  fargoRating?: Maybe<Scalars['Int']['output']>;
+  firebaseUid?: Maybe<Scalars['String']['output']>;
   followers?: Maybe<Array<UserGql>>;
   following?: Maybe<Array<UserGql>>;
-  id: Scalars["Int"]["output"];
-  isAdmin?: Maybe<Scalars["Boolean"]["output"]>;
-  profileImageUri?: Maybe<Scalars["String"]["output"]>;
-  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
-  username: Scalars["String"]["output"];
+  id: Scalars['Int']['output'];
+  isAdmin?: Maybe<Scalars['Boolean']['output']>;
+  profileImageUri?: Maybe<Scalars['String']['output']>;
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
+  username: Scalars['String']['output'];
 };
 
 export type UserPlayTimeGql = {
-  __typename?: "UserPlayTimeGQL";
-  totalSeconds: Scalars["Float"]["output"];
+  __typename?: 'UserPlayTimeGQL';
+  totalSeconds: Scalars['Float']['output'];
 };
 
 export type UserRelationship = {
-  __typename?: "UserRelationship";
+  __typename?: 'UserRelationship';
   toUser: UserGql;
-  toUserFollows: Scalars["Boolean"]["output"];
-  toUserIsFollowedBy: Scalars["Boolean"]["output"];
+  toUserFollows: Scalars['Boolean']['output'];
+  toUserIsFollowedBy: Scalars['Boolean']['output'];
 };
 
 export type UserRelationshipsResult = {
-  __typename?: "UserRelationshipsResult";
+  __typename?: 'UserRelationshipsResult';
   inquiringUser: UserGql;
   relationships: Array<UserRelationship>;
 };
 
 export type VideoFilterInput = {
-  isStreamCompleted?: InputMaybe<Scalars["Boolean"]["input"]>;
-  requireCursorCompletion?: Scalars["Boolean"]["input"];
+  isStreamCompleted?: InputMaybe<Scalars['Boolean']['input']>;
+  requireCursorCompletion?: Scalars['Boolean']['input'];
 };
 
 export type VideoGql = {
-  __typename?: "VideoGQL";
-  averageTimeBetweenShots?: Maybe<Scalars["Float"]["output"]>;
-  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
+  __typename?: 'VideoGQL';
+  averageTimeBetweenShots?: Maybe<Scalars['Float']['output']>;
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
   currentHomography?: Maybe<HomographyInfoGql>;
   currentProcessing?: Maybe<VideoProcessingGql>;
-  elapsedTime?: Maybe<Scalars["Float"]["output"]>;
-  endTime?: Maybe<Scalars["DateTime"]["output"]>;
-  framesPerSecond: Scalars["Float"]["output"];
+  elapsedTime?: Maybe<Scalars['Float']['output']>;
+  endTime?: Maybe<Scalars['DateTime']['output']>;
+  framesPerSecond: Scalars['Float']['output'];
   homographyHistory: Array<HomographyInfoGql>;
-  id: Scalars["Int"]["output"];
-  makePercentage: Scalars["Float"]["output"];
-  medianRun?: Maybe<Scalars["Float"]["output"]>;
-  name?: Maybe<Scalars["String"]["output"]>;
+  id: Scalars['Int']['output'];
+  makePercentage: Scalars['Float']['output'];
+  medianRun?: Maybe<Scalars['Float']['output']>;
+  name?: Maybe<Scalars['String']['output']>;
   owner?: Maybe<UserGql>;
   playlist?: Maybe<HlsPlaylistGql>;
-  screenshotUri?: Maybe<Scalars["String"]["output"]>;
+  screenshotUri?: Maybe<Scalars['String']['output']>;
   shots: Array<ShotGql>;
-  startTime?: Maybe<Scalars["DateTime"]["output"]>;
+  startTime?: Maybe<Scalars['DateTime']['output']>;
   stream?: Maybe<UploadStreamGql>;
-  tableSize: Scalars["Float"]["output"];
+  tableSize: Scalars['Float']['output'];
   tags: Array<VideoTag>;
-  totalShots: Scalars["Int"]["output"];
-  totalShotsMade: Scalars["Int"]["output"];
-  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  totalShots: Scalars['Int']['output'];
+  totalShotsMade: Scalars['Int']['output'];
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
 };
 
 export type VideoHistoryGql = {
-  __typename?: "VideoHistoryGQL";
+  __typename?: 'VideoHistoryGQL';
   pageInfo: PageInfoGql;
   videos: Array<VideoGql>;
 };
 
 export type VideoMetadataInput = {
-  endStream?: Scalars["Boolean"]["input"];
-  endTime?: InputMaybe<Scalars["DateTime"]["input"]>;
-  framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
-  gameType?: InputMaybe<Scalars["String"]["input"]>;
-  lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
+  endStream?: Scalars['Boolean']['input'];
+  endTime?: InputMaybe<Scalars['DateTime']['input']>;
+  framesPerSecond?: InputMaybe<Scalars['Float']['input']>;
+  gameType?: InputMaybe<Scalars['String']['input']>;
+  lastIntendedSegmentBound?: InputMaybe<Scalars['Int']['input']>;
   resolution?: InputMaybe<VideoResolution>;
-  startTime?: InputMaybe<Scalars["DateTime"]["input"]>;
+  startTime?: InputMaybe<Scalars['DateTime']['input']>;
   streamSegmentType?: InputMaybe<StreamSegmentTypeEnum>;
-  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
-  videoName?: InputMaybe<Scalars["String"]["input"]>;
+  tableSize?: InputMaybe<Scalars['Float']['input']>;
+  videoName?: InputMaybe<Scalars['String']['input']>;
 };
 
 export type VideoProcessingErrorGql = {
-  __typename?: "VideoProcessingErrorGQL";
-  endSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
-  message: Scalars["String"]["output"];
-  startSegmentIndex?: Maybe<Scalars["Int"]["output"]>;
+  __typename?: 'VideoProcessingErrorGQL';
+  endSegmentIndex?: Maybe<Scalars['Int']['output']>;
+  message: Scalars['String']['output'];
+  startSegmentIndex?: Maybe<Scalars['Int']['output']>;
 };
 
 export type VideoProcessingGql = {
-  __typename?: "VideoProcessingGQL";
+  __typename?: 'VideoProcessingGQL';
   errors: Array<VideoProcessingErrorGql>;
   status: ProcessingStatusEnum;
   statuses: Array<VideoProcessingStatusGql>;
 };
 
 export type VideoProcessingStatusGql = {
-  __typename?: "VideoProcessingStatusGQL";
-  appVersion: Scalars["String"]["output"];
-  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
-  sequenceId: Scalars["Int"]["output"];
+  __typename?: 'VideoProcessingStatusGQL';
+  appVersion: Scalars['String']['output'];
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
+  sequenceId: Scalars['Int']['output'];
   status: ProcessingStatusEnum;
-  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
 };
 
 export type VideoResolution = {
-  height: Scalars["Int"]["input"];
-  width: Scalars["Int"]["input"];
+  height: Scalars['Int']['input'];
+  width: Scalars['Int']['input'];
 };
 
 export type VideoResolutionGql = {
-  __typename?: "VideoResolutionGQL";
-  height?: Maybe<Scalars["Int"]["output"]>;
-  width?: Maybe<Scalars["Int"]["output"]>;
+  __typename?: 'VideoResolutionGQL';
+  height?: Maybe<Scalars['Int']['output']>;
+  width?: Maybe<Scalars['Int']['output']>;
 };
 
 export type VideoTag = {
-  __typename?: "VideoTag";
-  name: Scalars["String"]["output"];
+  __typename?: 'VideoTag';
+  name: Scalars['String']['output'];
   tagClasses: Array<VideoTagClass>;
 };
 
 export type VideoTagClass = {
-  __typename?: "VideoTagClass";
-  name: Scalars["String"]["output"];
+  __typename?: 'VideoTagClass';
+  name: Scalars['String']['output'];
 };
 
 export type VideoTagClassInput = {
-  name: Scalars["String"]["input"];
+  name: Scalars['String']['input'];
 };
 
 export type VideoTagInput = {
-  name: Scalars["String"]["input"];
+  name: Scalars['String']['input'];
   tagClasses?: Array<VideoTagClassInput>;
 };
 
 export enum WallTypeEnum {
-  Long = "LONG",
-  Short = "SHORT",
+  Long = 'LONG',
+  Short = 'SHORT'
 }
 
 export type GetAggregatedShotMetricsQueryVariables = Exact<{
   aggregateInput: AggregateInputGql;
 }>;
 
-export type GetAggregatedShotMetricsQuery = {
-  __typename?: "Query";
-  getAggregatedShotMetrics: Array<{
-    __typename?: "AggregateResultGQL";
-    aggregationIdentifiers: Array<{
-      __typename?: "AggregationIdentifierGQL";
-      featureName: string;
-      groupName: string;
-    }>;
-    targetMetrics: {
-      __typename?: "TargetMetricsGQL";
-      count: number;
-      makePercentage?: number | null;
-    };
-  }>;
-};
 
-export type GetDeployedConfigQueryVariables = Exact<{ [key: string]: never }>;
+export type GetAggregatedShotMetricsQuery = { __typename?: 'Query', getAggregatedShotMetrics: Array<{ __typename?: 'AggregateResultGQL', aggregationIdentifiers: Array<{ __typename?: 'AggregationIdentifierGQL', featureName: string, groupName: string }>, targetMetrics: { __typename?: 'TargetMetricsGQL', count: number, makePercentage?: number | null } }> };
 
-export type GetDeployedConfigQuery = {
-  __typename?: "Query";
-  getDeployedConfig: {
-    __typename?: "DeployedConfigGQL";
-    allowNewUsers: boolean;
-    devMode: boolean;
-    environment: string;
-    firebase: boolean;
-    minimumAllowedAppVersion: string;
-  };
-};
+export type GetDeployedConfigQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type GetDeployedConfigQuery = { __typename?: 'Query', getDeployedConfig: { __typename?: 'DeployedConfigGQL', allowNewUsers: boolean, devMode: boolean, environment: string, firebase: boolean, minimumAllowedAppVersion: string } };
 
 export type GetFeedQueryVariables = Exact<{
-  limit?: Scalars["Int"]["input"];
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  limit?: Scalars['Int']['input'];
+  after?: InputMaybe<Scalars['String']['input']>;
   filters?: InputMaybe<VideoFilterInput>;
 }>;
 
-export type GetFeedQuery = {
-  __typename?: "Query";
-  getUserVideos: {
-    __typename?: "VideoHistoryGQL";
-    videos: Array<{
-      __typename?: "VideoGQL";
-      id: number;
-      name?: string | null;
-      screenshotUri?: string | null;
-      totalShotsMade: number;
-      totalShots: number;
-      makePercentage: number;
-      createdAt?: any | null;
-      updatedAt?: any | null;
-      startTime?: any | null;
-      endTime?: any | null;
-      elapsedTime?: number | null;
-      tableSize: number;
-      owner?: { __typename?: "UserGQL"; username: string } | null;
-      stream?: {
-        __typename?: "UploadStreamGQL";
-        id: string;
-        isCompleted: boolean;
-      } | null;
-      tags: Array<{
-        __typename?: "VideoTag";
-        name: string;
-        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
-      }>;
-    }>;
-    pageInfo: {
-      __typename?: "PageInfoGQL";
-      hasNextPage: boolean;
-      endCursor?: string | null;
-    };
-  };
-};
+
+export type GetFeedQuery = { __typename?: 'Query', getUserVideos: { __typename?: 'VideoHistoryGQL', videos: Array<{ __typename?: 'VideoGQL', id: number, name?: string | null, screenshotUri?: string | null, totalShotsMade: number, totalShots: number, makePercentage: number, createdAt?: any | null, updatedAt?: any | null, startTime?: any | null, endTime?: any | null, elapsedTime?: number | null, tableSize: number, owner?: { __typename?: 'UserGQL', username: string } | null, stream?: { __typename?: 'UploadStreamGQL', id: string, isCompleted: boolean } | null, tags: Array<{ __typename?: 'VideoTag', name: string, tagClasses: Array<{ __typename?: 'VideoTagClass', name: string }> }> }>, pageInfo: { __typename?: 'PageInfoGQL', hasNextPage: boolean, endCursor?: string | null } } };
 
 export type GetVideoMakePercentageIntervalsQueryVariables = Exact<{
-  videoId: Scalars["ID"]["input"];
-  intervalDuration: Scalars["Int"]["input"];
+  videoId: Scalars['ID']['input'];
+  intervalDuration: Scalars['Int']['input'];
 }>;
 
-export type GetVideoMakePercentageIntervalsQuery = {
-  __typename?: "Query";
-  getVideoMakePercentageIntervals: Array<{
-    __typename?: "MakePercentageIntervalGQL";
-    makePercentage: number;
-    elapsedTime: number;
-  }>;
-};
+
+export type GetVideoMakePercentageIntervalsQuery = { __typename?: 'Query', getVideoMakePercentageIntervals: Array<{ __typename?: 'MakePercentageIntervalGQL', makePercentage: number, elapsedTime: number }> };
 
 export type GetSerializedShotPathsQueryVariables = Exact<{
   filterInput: FilterInput;
 }>;
 
-export type GetSerializedShotPathsQuery = {
-  __typename?: "Query";
-  getShots: Array<{
-    __typename?: "ShotGQL";
-    id: number;
-    videoId: number;
-    startFrame: number;
-    endFrame: number;
-    serializedShotPaths?: {
-      __typename?: "SerializedShotPathsGQL";
-      b64EncodedBuffer?: string | null;
-    } | null;
-  }>;
-};
 
-export type GetShotAnnotationTypesQueryVariables = Exact<{
-  [key: string]: never;
-}>;
+export type GetSerializedShotPathsQuery = { __typename?: 'Query', getShots: Array<{ __typename?: 'ShotGQL', id: number, videoId: number, startFrame: number, endFrame: number, serializedShotPaths?: { __typename?: 'SerializedShotPathsGQL', b64EncodedBuffer?: string | null } | null }> };
 
-export type GetShotAnnotationTypesQuery = {
-  __typename?: "Query";
-  getShotAnnotationTypes: Array<{
-    __typename?: "ShotAnnotationTypeGQL";
-    id: number;
-    name: string;
-  }>;
-};
+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"];
+  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 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"]>;
+  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 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 GetShotsWithMetadataFilterResultQueryVariables = Exact<{
   filterInput: FilterInput;
   shotsOrdering?: InputMaybe<GetShotsOrdering>;
-  limit?: InputMaybe<Scalars["Int"]["input"]>;
-  ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  ids?: InputMaybe<Array<Scalars['Int']['input']> | Scalars['Int']['input']>;
 }>;
 
-export type GetShotsWithMetadataFilterResultQuery = {
-  __typename?: "Query";
-  getOrderedShots: {
-    __typename?: "GetShotsResult";
-    count?: number | null;
-    ids: Array<number>;
-    shots: Array<{
-      __typename?: "ShotGQL";
-      id: number;
-      videoId: number;
-      startFrame: number;
-      endFrame: number;
-      startTime: number;
-      endTime: number;
-      falsePositiveScore?: number | null;
-      createdAt?: any | null;
-      updatedAt?: any | null;
-      user?: { __typename?: "UserGQL"; id: number } | null;
-      cueObjectFeatures?: {
-        __typename?: "CueObjectFeaturesGQL";
-        cueObjectDistance?: number | null;
-        cueObjectAngle?: number | null;
-        cueBallSpeed?: number | null;
-        shotDirection?: ShotDirectionEnum | null;
-        spinType?: SpinTypeEnum | null;
-      } | null;
-      pocketingIntentionFeatures?: {
-        __typename?: "PocketingIntentionFeaturesGQL";
-        make?: boolean | null;
-        targetPocketDistance?: number | null;
-        targetPocketAngle?: number | null;
-        targetPocketAngleDirection?: ShotDirectionEnum | null;
-        marginOfErrorInDegrees?: number | null;
-        intendedPocketType?: PocketEnum | null;
-      } | null;
-      pocketingIntentionInfo?: {
-        __typename?: "PocketingIntentionInfoGQL";
-        ballId: number;
-        pocketId: PocketIdentifier;
-        pathMetadataIndex: number;
-      } | null;
-      serializedShotPaths?: {
-        __typename?: "SerializedShotPathsGQL";
-        b64EncodedBuffer?: string | null;
-      } | null;
-      annotations: Array<{
-        __typename?: "ShotAnnotationGQL";
-        shotId: number;
-        notes: string;
-        type: {
-          __typename?: "ShotAnnotationTypeGQL";
-          id: number;
-          name: string;
-        };
-      }>;
-    }>;
-  };
-};
+
+export type GetShotsWithMetadataFilterResultQuery = { __typename?: 'Query', getOrderedShots: { __typename?: 'GetShotsResult', count?: number | null, ids: Array<number>, shots: Array<{ __typename?: 'ShotGQL', id: number, videoId: number, startFrame: number, endFrame: number, startTime: number, endTime: number, falsePositiveScore?: number | null, createdAt?: any | null, updatedAt?: any | null, user?: { __typename?: 'UserGQL', id: number } | null, cueObjectFeatures?: { __typename?: 'CueObjectFeaturesGQL', cueObjectDistance?: number | null, cueObjectAngle?: number | null, cueBallSpeed?: number | null, shotDirection?: ShotDirectionEnum | null, spinType?: SpinTypeEnum | null } | null, pocketingIntentionFeatures?: { __typename?: 'PocketingIntentionFeaturesGQL', make?: boolean | null, targetPocketDistance?: number | null, targetPocketAngle?: number | null, targetPocketAngleDirection?: ShotDirectionEnum | null, marginOfErrorInDegrees?: number | null, intendedPocketType?: PocketEnum | null } | null, pocketingIntentionInfo?: { __typename?: 'PocketingIntentionInfoGQL', ballId: number, pocketId: PocketIdentifier, pathMetadataIndex: number } | null, serializedShotPaths?: { __typename?: 'SerializedShotPathsGQL', b64EncodedBuffer?: string | null } | null, annotations: Array<{ __typename?: 'ShotAnnotationGQL', shotId: number, notes: string, type: { __typename?: 'ShotAnnotationTypeGQL', id: number, name: string } }> }> } };
 
 export type GetShotsWithMetadataQueryVariables = Exact<{
   filterInput: FilterInput;
   shotsPagination?: InputMaybe<GetShotsPagination>;
-  limit?: InputMaybe<Scalars["Int"]["input"]>;
-  ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  ids?: InputMaybe<Array<Scalars['Int']['input']> | Scalars['Int']['input']>;
 }>;
 
-export type GetShotsWithMetadataQuery = {
-  __typename?: "Query";
-  getShotsWithMetadata: {
-    __typename?: "GetShotsResult";
-    count?: number | null;
-    ids: Array<number>;
-    shots: Array<{
-      __typename?: "ShotGQL";
-      id: number;
-      videoId: number;
-      startFrame: number;
-      endFrame: number;
-      startTime: number;
-      endTime: number;
-      falsePositiveScore?: number | null;
-      createdAt?: any | null;
-      updatedAt?: any | null;
-      user?: { __typename?: "UserGQL"; id: number } | null;
-      cueObjectFeatures?: {
-        __typename?: "CueObjectFeaturesGQL";
-        cueObjectDistance?: number | null;
-        cueObjectAngle?: number | null;
-        cueBallSpeed?: number | null;
-        shotDirection?: ShotDirectionEnum | null;
-        spinType?: SpinTypeEnum | null;
-      } | null;
-      pocketingIntentionFeatures?: {
-        __typename?: "PocketingIntentionFeaturesGQL";
-        make?: boolean | null;
-        targetPocketDistance?: number | null;
-        targetPocketAngle?: number | null;
-        targetPocketAngleDirection?: ShotDirectionEnum | null;
-        marginOfErrorInDegrees?: number | null;
-        intendedPocketType?: PocketEnum | null;
-      } | null;
-      pocketingIntentionInfo?: {
-        __typename?: "PocketingIntentionInfoGQL";
-        ballId: number;
-        pocketId: PocketIdentifier;
-        pathMetadataIndex: number;
-      } | null;
-      serializedShotPaths?: {
-        __typename?: "SerializedShotPathsGQL";
-        b64EncodedBuffer?: string | null;
-      } | null;
-      annotations: Array<{
-        __typename?: "ShotAnnotationGQL";
-        shotId: number;
-        notes: string;
-        type: {
-          __typename?: "ShotAnnotationTypeGQL";
-          id: number;
-          name: string;
-        };
-      }>;
-    }>;
-  };
-};
+
+export type GetShotsWithMetadataQuery = { __typename?: 'Query', getShotsWithMetadata: { __typename?: 'GetShotsResult', count?: number | null, ids: Array<number>, shots: Array<{ __typename?: 'ShotGQL', id: number, videoId: number, startFrame: number, endFrame: number, startTime: number, endTime: number, falsePositiveScore?: number | null, createdAt?: any | null, updatedAt?: any | null, user?: { __typename?: 'UserGQL', id: number } | null, cueObjectFeatures?: { __typename?: 'CueObjectFeaturesGQL', cueObjectDistance?: number | null, cueObjectAngle?: number | null, cueBallSpeed?: number | null, shotDirection?: ShotDirectionEnum | null, spinType?: SpinTypeEnum | null } | null, pocketingIntentionFeatures?: { __typename?: 'PocketingIntentionFeaturesGQL', make?: boolean | null, targetPocketDistance?: number | null, targetPocketAngle?: number | null, targetPocketAngleDirection?: ShotDirectionEnum | null, marginOfErrorInDegrees?: number | null, intendedPocketType?: PocketEnum | null } | null, pocketingIntentionInfo?: { __typename?: 'PocketingIntentionInfoGQL', ballId: number, pocketId: PocketIdentifier, pathMetadataIndex: number } | null, serializedShotPaths?: { __typename?: 'SerializedShotPathsGQL', b64EncodedBuffer?: string | null } | null, annotations: Array<{ __typename?: 'ShotAnnotationGQL', shotId: number, notes: string, type: { __typename?: 'ShotAnnotationTypeGQL', id: number, name: string } }> }> } };
 
 export type GetShotsByIdsQueryVariables = Exact<{
-  ids: Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"];
+  ids: Array<Scalars['Int']['input']> | Scalars['Int']['input'];
 }>;
 
-export type GetShotsByIdsQuery = {
-  __typename?: "Query";
-  getShotsByIds: Array<{
-    __typename?: "ShotGQL";
-    id: number;
-    videoId: number;
-    startFrame: number;
-    endFrame: number;
-    startTime: number;
-    endTime: number;
-    falsePositiveScore?: number | null;
-    createdAt?: any | null;
-    updatedAt?: any | null;
-    user?: { __typename?: "UserGQL"; id: number } | null;
-    cueObjectFeatures?: {
-      __typename?: "CueObjectFeaturesGQL";
-      cueObjectDistance?: number | null;
-      cueObjectAngle?: number | null;
-      cueBallSpeed?: number | null;
-      shotDirection?: ShotDirectionEnum | null;
-      spinType?: SpinTypeEnum | null;
-    } | null;
-    pocketingIntentionFeatures?: {
-      __typename?: "PocketingIntentionFeaturesGQL";
-      make?: boolean | null;
-      targetPocketDistance?: number | null;
-      targetPocketAngle?: number | null;
-      targetPocketAngleDirection?: ShotDirectionEnum | null;
-      marginOfErrorInDegrees?: number | null;
-      intendedPocketType?: PocketEnum | null;
-    } | null;
-    pocketingIntentionInfo?: {
-      __typename?: "PocketingIntentionInfoGQL";
-      ballId: number;
-      pocketId: PocketIdentifier;
-      pathMetadataIndex: number;
-    } | null;
-    serializedShotPaths?: {
-      __typename?: "SerializedShotPathsGQL";
-      b64EncodedBuffer?: string | null;
-    } | null;
-    annotations: Array<{
-      __typename?: "ShotAnnotationGQL";
-      shotId: number;
-      notes: string;
-      type: { __typename?: "ShotAnnotationTypeGQL"; id: number; name: string };
-    }>;
-  }>;
-};
 
-export type ShotWithAllFeaturesFragment = {
-  __typename?: "ShotGQL";
-  id: number;
-  videoId: number;
-  startFrame: number;
-  endFrame: number;
-  startTime: number;
-  endTime: number;
-  falsePositiveScore?: number | null;
-  createdAt?: any | null;
-  updatedAt?: any | null;
-  user?: { __typename?: "UserGQL"; id: number } | null;
-  cueObjectFeatures?: {
-    __typename?: "CueObjectFeaturesGQL";
-    cueObjectDistance?: number | null;
-    cueObjectAngle?: number | null;
-    cueBallSpeed?: number | null;
-    shotDirection?: ShotDirectionEnum | null;
-    spinType?: SpinTypeEnum | null;
-  } | null;
-  pocketingIntentionFeatures?: {
-    __typename?: "PocketingIntentionFeaturesGQL";
-    make?: boolean | null;
-    targetPocketDistance?: number | null;
-    targetPocketAngle?: number | null;
-    targetPocketAngleDirection?: ShotDirectionEnum | null;
-    marginOfErrorInDegrees?: number | null;
-    intendedPocketType?: PocketEnum | null;
-  } | null;
-  pocketingIntentionInfo?: {
-    __typename?: "PocketingIntentionInfoGQL";
-    ballId: number;
-    pocketId: PocketIdentifier;
-    pathMetadataIndex: number;
-  } | null;
-  serializedShotPaths?: {
-    __typename?: "SerializedShotPathsGQL";
-    b64EncodedBuffer?: string | null;
-  } | null;
-  annotations: Array<{
-    __typename?: "ShotAnnotationGQL";
-    shotId: number;
-    notes: string;
-    type: { __typename?: "ShotAnnotationTypeGQL"; id: number; name: string };
-  }>;
-};
+export type GetShotsByIdsQuery = { __typename?: 'Query', getShotsByIds: Array<{ __typename?: 'ShotGQL', id: number, videoId: number, startFrame: number, endFrame: number, startTime: number, endTime: number, falsePositiveScore?: number | null, createdAt?: any | null, updatedAt?: any | null, user?: { __typename?: 'UserGQL', id: number } | null, cueObjectFeatures?: { __typename?: 'CueObjectFeaturesGQL', cueObjectDistance?: number | null, cueObjectAngle?: number | null, cueBallSpeed?: number | null, shotDirection?: ShotDirectionEnum | null, spinType?: SpinTypeEnum | null } | null, pocketingIntentionFeatures?: { __typename?: 'PocketingIntentionFeaturesGQL', make?: boolean | null, targetPocketDistance?: number | null, targetPocketAngle?: number | null, targetPocketAngleDirection?: ShotDirectionEnum | null, marginOfErrorInDegrees?: number | null, intendedPocketType?: PocketEnum | null } | null, pocketingIntentionInfo?: { __typename?: 'PocketingIntentionInfoGQL', ballId: number, pocketId: PocketIdentifier, pathMetadataIndex: number } | null, serializedShotPaths?: { __typename?: 'SerializedShotPathsGQL', b64EncodedBuffer?: string | null } | null, annotations: Array<{ __typename?: 'ShotAnnotationGQL', shotId: number, notes: string, type: { __typename?: 'ShotAnnotationTypeGQL', id: number, name: string } }> }> };
+
+export type ShotWithAllFeaturesFragment = { __typename?: 'ShotGQL', id: number, videoId: number, startFrame: number, endFrame: number, startTime: number, endTime: number, falsePositiveScore?: number | null, createdAt?: any | null, updatedAt?: any | null, user?: { __typename?: 'UserGQL', id: number } | null, cueObjectFeatures?: { __typename?: 'CueObjectFeaturesGQL', cueObjectDistance?: number | null, cueObjectAngle?: number | null, cueBallSpeed?: number | null, shotDirection?: ShotDirectionEnum | null, spinType?: SpinTypeEnum | null } | null, pocketingIntentionFeatures?: { __typename?: 'PocketingIntentionFeaturesGQL', make?: boolean | null, targetPocketDistance?: number | null, targetPocketAngle?: number | null, targetPocketAngleDirection?: ShotDirectionEnum | null, marginOfErrorInDegrees?: number | null, intendedPocketType?: PocketEnum | null } | null, pocketingIntentionInfo?: { __typename?: 'PocketingIntentionInfoGQL', ballId: number, pocketId: PocketIdentifier, pathMetadataIndex: number } | null, serializedShotPaths?: { __typename?: 'SerializedShotPathsGQL', b64EncodedBuffer?: string | null } | null, annotations: Array<{ __typename?: 'ShotAnnotationGQL', shotId: number, notes: string, type: { __typename?: 'ShotAnnotationTypeGQL', id: number, name: string } }> };
 
 export type GetProfileImageUploadLinkMutationVariables = Exact<{
-  fileExt?: InputMaybe<Scalars["String"]["input"]>;
+  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 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"];
+  profileImageUri: Scalars['String']['input'];
 }>;
 
-export type EditProfileImageUriMutation = {
-  __typename?: "Mutation";
-  editProfileImageUri: {
-    __typename?: "UserGQL";
-    id: number;
-    firebaseUid?: string | null;
-    username: string;
-    profileImageUri?: string | null;
-    createdAt?: any | null;
-    updatedAt?: any | null;
-  };
-};
 
-export type GetLoggedInUserQueryVariables = Exact<{ [key: string]: never }>;
+export type EditProfileImageUriMutation = { __typename?: 'Mutation', editProfileImageUri: { __typename?: 'UserGQL', id: number, firebaseUid?: string | null, username: string, profileImageUri?: string | null, createdAt?: any | null, updatedAt?: any | null } };
 
-export type GetLoggedInUserQuery = {
-  __typename?: "Query";
-  getLoggedInUser?: {
-    __typename?: "UserGQL";
-    id: number;
-    firebaseUid?: string | null;
-    username: string;
-    isAdmin?: boolean | null;
-    profileImageUri?: string | null;
-    fargoRating?: number | null;
-    activeVideoId?: number | null;
-    createdAt?: any | null;
-    updatedAt?: any | null;
-  } | null;
-};
+export type GetLoggedInUserQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type GetLoggedInUserQuery = { __typename?: 'Query', getLoggedInUser?: { __typename?: 'UserGQL', id: number, firebaseUid?: string | null, username: string, isAdmin?: boolean | null, profileImageUri?: string | null, fargoRating?: number | null, activeVideoId?: number | null, createdAt?: any | null, updatedAt?: any | null } | null };
 
 export type GetUserPlayTimeQueryVariables = Exact<{
-  userId: Scalars["Int"]["input"];
+  userId: Scalars['Int']['input'];
 }>;
 
-export type GetUserPlayTimeQuery = {
-  __typename?: "Query";
-  getPlayTime: { __typename?: "UserPlayTimeGQL"; totalSeconds: number };
-};
+
+export type GetUserPlayTimeQuery = { __typename?: 'Query', getPlayTime: { __typename?: 'UserPlayTimeGQL', totalSeconds: number } };
 
 export type GetUsernamesQueryVariables = Exact<{
-  matchString: Scalars["String"]["input"];
-  limit?: InputMaybe<Scalars["Int"]["input"]>;
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  matchString: Scalars['String']['input'];
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  after?: InputMaybe<Scalars['String']['input']>;
 }>;
 
-export type GetUsernamesQuery = {
-  __typename?: "Query";
-  getUsernames: Array<string>;
-};
+
+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"]>;
+  userId: Scalars['Int']['input'];
+  matchString: Scalars['String']['input'];
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  after?: InputMaybe<Scalars['String']['input']>;
 }>;
 
-export type GetUserRelationshipsMatchingQuery = {
-  __typename?: "Query";
-  getUserRelationshipsMatching: {
-    __typename?: "UserRelationshipsResult";
-    relationships: Array<{
-      __typename?: "UserRelationship";
-      toUserFollows: boolean;
-      toUserIsFollowedBy: boolean;
-      toUser: { __typename?: "UserGQL"; username: string; id: number };
-    }>;
-  };
-};
 
-export type GetUserTagsQueryVariables = Exact<{ [key: string]: never }>;
+export type GetUserRelationshipsMatchingQuery = { __typename?: 'Query', getUserRelationshipsMatching: { __typename?: 'UserRelationshipsResult', relationships: Array<{ __typename?: 'UserRelationship', toUserFollows: boolean, toUserIsFollowedBy: boolean, toUser: { __typename?: 'UserGQL', username: string, id: number } }> } };
 
-export type GetUserTagsQuery = {
-  __typename?: "Query";
-  getUserTags: Array<{ __typename?: "TagGQL"; id: number; name: string }>;
-};
+export type GetUserTagsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type GetUserTagsQuery = { __typename?: 'Query', getUserTags: Array<{ __typename?: 'TagGQL', id: number, name: string }> };
 
 export type FollowUserMutationVariables = Exact<{
-  followedUserId: Scalars["Int"]["input"];
+  followedUserId: Scalars['Int']['input'];
 }>;
 
-export type FollowUserMutation = {
-  __typename?: "Mutation";
-  followUser: {
-    __typename?: "UserGQL";
-    username: string;
-    id: number;
-    following?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-    followers?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-  };
-};
+
+export type FollowUserMutation = { __typename?: 'Mutation', followUser: { __typename?: 'UserGQL', username: string, id: number, following?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null, followers?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null } };
 
 export type UnfollowUserMutationVariables = Exact<{
-  followedUserId: Scalars["Int"]["input"];
+  followedUserId: Scalars['Int']['input'];
 }>;
 
-export type UnfollowUserMutation = {
-  __typename?: "Mutation";
-  unfollowUser: {
-    __typename?: "UserGQL";
-    username: string;
-    id: number;
-    following?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-    followers?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-  };
-};
 
-export type GetUserFollowingFollowersQueryVariables = Exact<{
-  [key: string]: never;
+export type UnfollowUserMutation = { __typename?: 'Mutation', unfollowUser: { __typename?: 'UserGQL', username: string, id: number, following?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null, followers?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null } };
+
+export type GetUserFollowingFollowersQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type GetUserFollowingFollowersQuery = { __typename?: 'Query', getLoggedInUser?: { __typename?: 'UserGQL', id: number, following?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null, followers?: Array<{ __typename?: 'UserGQL', id: number, username: string }> | null } | null };
+
+export type DoesUsernameExistQueryVariables = Exact<{
+  candidateUsername: Scalars['String']['input'];
 }>;
 
-export type GetUserFollowingFollowersQuery = {
-  __typename?: "Query";
-  getLoggedInUser?: {
-    __typename?: "UserGQL";
-    id: number;
-    following?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-    followers?: Array<{
-      __typename?: "UserGQL";
-      id: number;
-      username: string;
-    }> | null;
-  } | null;
-};
+
+export type DoesUsernameExistQuery = { __typename?: 'Query', doesUsernameExist: boolean };
 
 export type GetStreamMonitoringDetailsQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
-  debuggingJson?: InputMaybe<Scalars["JSON"]["input"]>;
+  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";
-      crop: {
-        __typename?: "BoundingBoxGQL";
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-      };
-      pockets: Array<{
-        __typename?: "BoundingBoxGQL";
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-      }>;
-      sourcePoints: {
-        __typename?: "PocketPointsGQL";
-        topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-        topSide: { __typename?: "IntPoint2D"; x: number; y: number };
-        topRight: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
-      };
-    } | null;
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      id: string;
-      linksRequested: number;
-      uploadsCompleted: number;
-      segmentProcessingCursor: number;
-      isCompleted: boolean;
-      uploadCompletionCursor: number;
-      lastIntendedSegmentBound?: number | null;
-      initPlaylistUploadStatus?: InitPlaylistUploadStatusEnum | null;
-    } | null;
-    currentProcessing?: {
-      __typename?: "VideoProcessingGQL";
-      errors: Array<{
-        __typename?: "VideoProcessingErrorGQL";
-        message: string;
-        startSegmentIndex?: number | null;
-        endSegmentIndex?: number | null;
-      }>;
-    } | null;
-  };
-};
+
+export type GetStreamMonitoringDetailsQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, totalShots: number, makePercentage: number, elapsedTime?: number | null, currentHomography?: { __typename?: 'HomographyInfoGQL', crop: { __typename?: 'BoundingBoxGQL', left: number, top: number, width: number, height: number }, pockets: Array<{ __typename?: 'BoundingBoxGQL', left: number, top: number, width: number, height: number }>, sourcePoints: { __typename?: 'PocketPointsGQL', topLeft: { __typename?: 'IntPoint2D', x: number, y: number }, topSide: { __typename?: 'IntPoint2D', x: number, y: number }, topRight: { __typename?: 'IntPoint2D', x: number, y: number }, bottomLeft: { __typename?: 'IntPoint2D', x: number, y: number }, bottomSide: { __typename?: 'IntPoint2D', x: number, y: number }, bottomRight: { __typename?: 'IntPoint2D', x: number, y: number } } } | null, stream?: { __typename?: 'UploadStreamGQL', id: string, linksRequested: number, uploadsCompleted: number, segmentProcessingCursor: number, isCompleted: boolean, uploadCompletionCursor: number, lastIntendedSegmentBound?: number | null, initPlaylistUploadStatus?: InitPlaylistUploadStatusEnum | null } | null, currentProcessing?: { __typename?: 'VideoProcessingGQL', errors: Array<{ __typename?: 'VideoProcessingErrorGQL', message: string, startSegmentIndex?: number | null, endSegmentIndex?: number | null }> } | null } };
 
 export type GetVideoUpdatePageDetailsQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetVideoUpdatePageDetailsQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    name?: string | null;
-    totalShots: number;
-    makePercentage: number;
-    elapsedTime?: number | null;
-    tableSize: number;
-    tags: Array<{
-      __typename?: "VideoTag";
-      name: string;
-      tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
-    }>;
-  };
-};
+
+export type GetVideoUpdatePageDetailsQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, name?: string | null, totalShots: number, makePercentage: number, elapsedTime?: number | null, tableSize: number, tags: Array<{ __typename?: 'VideoTag', name: string, tagClasses: Array<{ __typename?: 'VideoTagClass', name: string }> }> } };
 
 export type DeleteVideoMutationVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type DeleteVideoMutation = {
-  __typename?: "Mutation";
-  deleteVideo: boolean;
-};
+
+export type DeleteVideoMutation = { __typename?: 'Mutation', deleteVideo: boolean };
 
 export type GetVideoDetailsQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetVideoDetailsQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    name?: string | null;
-    screenshotUri?: string | null;
-    averageTimeBetweenShots?: number | null;
-    elapsedTime?: number | null;
-    endTime?: any | null;
-    makePercentage: number;
-    medianRun?: number | null;
-    startTime?: any | null;
-    totalShots: number;
-    totalShotsMade: number;
-    createdAt?: any | null;
-    updatedAt?: any | null;
-    tableSize: number;
-    owner?: {
-      __typename?: "UserGQL";
-      id: number;
-      firebaseUid?: string | null;
-      username: string;
-      profileImageUri?: string | null;
-    } | null;
-    tags: Array<{
-      __typename?: "VideoTag";
-      name: string;
-      tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
-    }>;
-  };
-};
+
+export type GetVideoDetailsQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, name?: string | null, screenshotUri?: string | null, averageTimeBetweenShots?: number | null, elapsedTime?: number | null, endTime?: any | null, makePercentage: number, medianRun?: number | null, startTime?: any | null, totalShots: number, totalShotsMade: number, createdAt?: any | null, updatedAt?: any | null, tableSize: number, owner?: { __typename?: 'UserGQL', id: number, firebaseUid?: string | null, username: string, profileImageUri?: string | null } | null, tags: Array<{ __typename?: 'VideoTag', name: string, tagClasses: Array<{ __typename?: 'VideoTagClass', name: string }> }> } };
 
 export type GetVideosQueryVariables = Exact<{
-  videoIds: Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"];
+  videoIds: Array<Scalars['Int']['input']> | Scalars['Int']['input'];
 }>;
 
-export type GetVideosQuery = {
-  __typename?: "Query";
-  getVideos: Array<{
-    __typename?: "VideoGQL";
-    id: number;
-    framesPerSecond: number;
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      id: string;
-      streamSegmentType: StreamSegmentTypeEnum;
-      segments: Array<{
-        __typename?: "UploadSegmentGQL";
-        uploaded: boolean;
-        valid: boolean;
-        segmentIndex: number;
-        endFrameIndex?: number | null;
-        framesPerSecond?: number | null;
-      }>;
-    } | null;
-    playlist?: {
-      __typename?: "HLSPlaylistGQL";
-      segmentDurations: Array<number>;
-    } | null;
-  }>;
-};
 
-export type VideoStreamMetadataFragment = {
-  __typename?: "VideoGQL";
-  id: number;
-  framesPerSecond: number;
-  stream?: {
-    __typename?: "UploadStreamGQL";
-    id: string;
-    streamSegmentType: StreamSegmentTypeEnum;
-    segments: Array<{
-      __typename?: "UploadSegmentGQL";
-      uploaded: boolean;
-      valid: boolean;
-      segmentIndex: number;
-      endFrameIndex?: number | null;
-      framesPerSecond?: number | null;
-    }>;
-  } | null;
-  playlist?: {
-    __typename?: "HLSPlaylistGQL";
-    segmentDurations: Array<number>;
-  } | null;
-};
+export type GetVideosQuery = { __typename?: 'Query', getVideos: Array<{ __typename?: 'VideoGQL', id: number, framesPerSecond: number, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segments: Array<{ __typename?: 'UploadSegmentGQL', uploaded: boolean, valid: boolean, segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }> } | null, playlist?: { __typename?: 'HLSPlaylistGQL', segmentDurations: Array<number> } | null }> };
+
+export type VideoStreamMetadataFragment = { __typename?: 'VideoGQL', id: number, framesPerSecond: number, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segments: Array<{ __typename?: 'UploadSegmentGQL', uploaded: boolean, valid: boolean, segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }> } | null, playlist?: { __typename?: 'HLSPlaylistGQL', segmentDurations: Array<number> } | null };
 
 export type GetVideoForShotTimeQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetVideoForShotTimeQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    framesPerSecond: number;
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      id: string;
-      streamSegmentType: StreamSegmentTypeEnum;
-      segments: Array<{
-        __typename?: "UploadSegmentGQL";
-        uploaded: boolean;
-        valid: boolean;
-        segmentIndex: number;
-        endFrameIndex?: number | null;
-        framesPerSecond?: number | null;
-      }>;
-    } | null;
-    playlist?: {
-      __typename?: "HLSPlaylistGQL";
-      segmentDurations: Array<number>;
-    } | null;
-  };
-};
+
+export type GetVideoForShotTimeQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, framesPerSecond: number, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segments: Array<{ __typename?: 'UploadSegmentGQL', uploaded: boolean, valid: boolean, segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }> } | null, playlist?: { __typename?: 'HLSPlaylistGQL', segmentDurations: Array<number> } | null } };
 
 export type GetVideoQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetVideoQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    playlist?: {
-      __typename?: "HLSPlaylistGQL";
-      segmentDurations: Array<number>;
-    } | null;
-    homographyHistory: Array<{
-      __typename?: "HomographyInfoGQL";
-      frameIndex: number;
-      crop: {
-        __typename?: "BoundingBoxGQL";
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-      };
-      pockets: Array<{
-        __typename?: "BoundingBoxGQL";
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-      }>;
-      sourcePoints: {
-        __typename?: "PocketPointsGQL";
-        topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-        topSide: { __typename?: "IntPoint2D"; x: number; y: number };
-        topRight: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
-        bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
-      };
-    }>;
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      id: string;
-      streamSegmentType: StreamSegmentTypeEnum;
-      segments: Array<{
-        __typename?: "UploadSegmentGQL";
-        segmentIndex: number;
-        endFrameIndex?: number | null;
-        framesPerSecond?: number | null;
-      }>;
-      resolution: {
-        __typename?: "VideoResolutionGQL";
-        width?: number | null;
-        height?: number | null;
-      };
-    } | null;
-  };
-};
+
+export type GetVideoQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, playlist?: { __typename?: 'HLSPlaylistGQL', segmentDurations: Array<number> } | null, homographyHistory: Array<{ __typename?: 'HomographyInfoGQL', frameIndex: number, crop: { __typename?: 'BoundingBoxGQL', left: number, top: number, width: number, height: number }, pockets: Array<{ __typename?: 'BoundingBoxGQL', left: number, top: number, width: number, height: number }>, sourcePoints: { __typename?: 'PocketPointsGQL', topLeft: { __typename?: 'IntPoint2D', x: number, y: number }, topSide: { __typename?: 'IntPoint2D', x: number, y: number }, topRight: { __typename?: 'IntPoint2D', x: number, y: number }, bottomLeft: { __typename?: 'IntPoint2D', x: number, y: number }, bottomSide: { __typename?: 'IntPoint2D', x: number, y: number }, bottomRight: { __typename?: 'IntPoint2D', x: number, y: number } } }>, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segments: Array<{ __typename?: 'UploadSegmentGQL', segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }>, resolution: { __typename?: 'VideoResolutionGQL', width?: number | null, height?: number | null } } | null } };
 
 export type GetAverageTimePerShotForVideoQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetAverageTimePerShotForVideoQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    averageTimeBetweenShots?: number | null;
-  };
-};
+
+export type GetAverageTimePerShotForVideoQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, averageTimeBetweenShots?: number | null } };
 
 export type GetElapsedTimeForVideoQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetElapsedTimeForVideoQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    elapsedTime?: number | null;
-  };
-};
+
+export type GetElapsedTimeForVideoQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, elapsedTime?: number | null } };
 
 export type GetMedianRunForVideoQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetMedianRunForVideoQuery = {
-  __typename?: "Query";
-  getVideo: { __typename?: "VideoGQL"; id: number; medianRun?: number | null };
-};
 
-export type StreamWithEndFramesFragment = {
-  __typename?: "UploadStreamGQL";
-  id: string;
-  streamSegmentType: StreamSegmentTypeEnum;
-  segmentEndFrames: Array<number>;
-  resolution: {
-    __typename?: "VideoResolutionGQL";
-    width?: number | null;
-    height?: number | null;
-  };
-  segments: Array<{
-    __typename?: "UploadSegmentGQL";
-    uploaded: boolean;
-    valid: boolean;
-    segmentIndex: number;
-    endFrameIndex?: number | null;
-    framesPerSecond?: number | null;
-  }>;
-};
+export type GetMedianRunForVideoQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, medianRun?: number | null } };
 
-export type SegmentEndFramesFragment = {
-  __typename?: "SegmentEndFramesGQL";
-  id: number;
-  segmentEndFrames: Array<number>;
-};
+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 SegmentStartTimesFragment = {
-  __typename?: "SegmentStartTimesGQL";
-  id: number;
-  segmentStartTimes: Array<number>;
-};
+export type SegmentEndFramesFragment = { __typename?: 'SegmentEndFramesGQL', id: number, segmentEndFrames: Array<number> };
 
-export type PlaylistWithSegmentStartTimesFragment = {
-  __typename?: "HLSPlaylistGQL";
-  videoId: number;
-  segmentDurations: Array<number>;
-  segmentStartTimes: Array<number>;
-};
+export type SegmentStartTimesFragment = { __typename?: 'SegmentStartTimesGQL', id: number, segmentStartTimes: Array<number> };
 
-export type VideoDurationDataFragment = {
-  __typename?: "VideoGQL";
-  id: number;
-  framesPerSecond: number;
-  playlist?: {
-    __typename?: "HLSPlaylistGQL";
-    videoId: number;
-    segmentDurations: Array<number>;
-    segmentStartTimes: Array<number>;
-  } | null;
-  stream?: {
-    __typename?: "UploadStreamGQL";
-    id: string;
-    streamSegmentType: StreamSegmentTypeEnum;
-    segmentEndFrames: Array<number>;
-    resolution: {
-      __typename?: "VideoResolutionGQL";
-      width?: number | null;
-      height?: number | null;
-    };
-    segments: Array<{
-      __typename?: "UploadSegmentGQL";
-      uploaded: boolean;
-      valid: boolean;
-      segmentIndex: number;
-      endFrameIndex?: number | null;
-      framesPerSecond?: number | null;
-    }>;
-  } | null;
-};
+export type PlaylistWithSegmentStartTimesFragment = { __typename?: 'HLSPlaylistGQL', videoId: number, segmentDurations: Array<number>, segmentStartTimes: Array<number> };
+
+export type VideoDurationDataFragment = { __typename?: 'VideoGQL', id: number, framesPerSecond: number, playlist?: { __typename?: 'HLSPlaylistGQL', videoId: number, segmentDurations: Array<number>, segmentStartTimes: Array<number> } | null, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segmentEndFrames: Array<number>, resolution: { __typename?: 'VideoResolutionGQL', width?: number | null, height?: number | null }, segments: Array<{ __typename?: 'UploadSegmentGQL', uploaded: boolean, valid: boolean, segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }> } | null };
 
 export type GetVideoForClipTimesQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetVideoForClipTimesQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    framesPerSecond: number;
-    playlist?: {
-      __typename?: "HLSPlaylistGQL";
-      videoId: number;
-      segmentDurations: Array<number>;
-      segmentStartTimes: Array<number>;
-    } | null;
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      id: string;
-      streamSegmentType: StreamSegmentTypeEnum;
-      segmentEndFrames: Array<number>;
-      resolution: {
-        __typename?: "VideoResolutionGQL";
-        width?: number | null;
-        height?: number | null;
-      };
-      segments: Array<{
-        __typename?: "UploadSegmentGQL";
-        uploaded: boolean;
-        valid: boolean;
-        segmentIndex: number;
-        endFrameIndex?: number | null;
-        framesPerSecond?: number | null;
-      }>;
-    } | null;
-  };
-};
+
+export type GetVideoForClipTimesQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, framesPerSecond: number, playlist?: { __typename?: 'HLSPlaylistGQL', videoId: number, segmentDurations: Array<number>, segmentStartTimes: Array<number> } | null, stream?: { __typename?: 'UploadStreamGQL', id: string, streamSegmentType: StreamSegmentTypeEnum, segmentEndFrames: Array<number>, resolution: { __typename?: 'VideoResolutionGQL', width?: number | null, height?: number | null }, segments: Array<{ __typename?: 'UploadSegmentGQL', uploaded: boolean, valid: boolean, segmentIndex: number, endFrameIndex?: number | null, framesPerSecond?: number | null }> } | null } };
 
 export type GetHeaderInfoByVideoIdQueryVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetHeaderInfoByVideoIdQuery = {
-  __typename?: "Query";
-  getVideo: {
-    __typename?: "VideoGQL";
-    id: number;
-    name?: string | null;
-    startTime?: any | null;
-  };
-};
+
+export type GetHeaderInfoByVideoIdQuery = { __typename?: 'Query', getVideo: { __typename?: 'VideoGQL', id: number, name?: string | null, startTime?: any | null } };
 
 export type CreateUploadStreamMutationVariables = Exact<{
   videoMetadataInput: VideoMetadataInput;
 }>;
 
-export type CreateUploadStreamMutation = {
-  __typename?: "Mutation";
-  createUploadStream: {
-    __typename?: "CreateUploadStreamReturn";
-    videoId: number;
-  };
-};
+
+export type CreateUploadStreamMutation = { __typename?: 'Mutation', createUploadStream: { __typename?: 'CreateUploadStreamReturn', videoId: number } };
 
 export type GetUploadLinkMutationVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
-  segmentIndex: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
+  segmentIndex: Scalars['Int']['input'];
 }>;
 
-export type GetUploadLinkMutation = {
-  __typename?: "Mutation";
-  getUploadLink: {
-    __typename?: "GetUploadLinkReturn";
-    value:
-      | {
-          __typename?: "GetUploadLinkErrors";
-          error:
-            | { __typename?: "InitUploadAlreadyCompletedErr" }
-            | {
-                __typename?: "MustHaveSetForUploadLinkErr";
-                resolution?: boolean | null;
-                framesPerSecond?: boolean | null;
-              }
-            | { __typename?: "NoInitForChunkedUploadErr" }
-            | {
-                __typename?: "ProcessingFailedErr";
-                processing: {
-                  __typename?: "VideoProcessingGQL";
-                  status: ProcessingStatusEnum;
-                  errors: Array<{
-                    __typename?: "VideoProcessingErrorGQL";
-                    message: string;
-                  }>;
-                };
-              }
-            | { __typename?: "SegmentAlreadyUploadedErr"; segmentId: number }
-            | { __typename?: "TooManyInitUploadsErr" }
-            | { __typename?: "TooManyProfileImageUploadsErr" };
-        }
-      | {
-          __typename?: "UploadLink";
-          uploadUrl: string;
-          headers: Array<{
-            __typename?: "Header";
-            key: string;
-            value: string;
-          } | null>;
-        };
-    stream?: {
-      __typename?: "UploadStreamGQL";
-      uploadCompletionCursor: number;
-    } | null;
-  };
-};
+
+export type GetUploadLinkMutation = { __typename?: 'Mutation', getUploadLink: { __typename?: 'GetUploadLinkReturn', value: { __typename?: 'GetUploadLinkErrors', error: { __typename?: 'InitUploadAlreadyCompletedErr' } | { __typename?: 'MustHaveSetForUploadLinkErr', resolution?: boolean | null, framesPerSecond?: boolean | null } | { __typename?: 'NoInitForChunkedUploadErr' } | { __typename?: 'ProcessingFailedErr', processing: { __typename?: 'VideoProcessingGQL', status: ProcessingStatusEnum, errors: Array<{ __typename?: 'VideoProcessingErrorGQL', message: string }> } } | { __typename?: 'SegmentAlreadyUploadedErr', segmentId: number } | { __typename?: 'TooManyInitUploadsErr' } | { __typename?: 'TooManyProfileImageUploadsErr' } } | { __typename?: 'UploadLink', uploadUrl: string, headers: Array<{ __typename?: 'Header', key: string, value: string } | null> }, stream?: { __typename?: 'UploadStreamGQL', uploadCompletionCursor: number } | null } };
 
 export type GetHlsInitUploadLinkMutationVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
 }>;
 
-export type GetHlsInitUploadLinkMutation = {
-  __typename?: "Mutation";
-  getHlsInitUploadLink: {
-    __typename?: "GetUploadLinkReturn";
-    value:
-      | {
-          __typename?: "GetUploadLinkErrors";
-          error:
-            | {
-                __typename?: "InitUploadAlreadyCompletedErr";
-                segmentType: StreamSegmentTypeEnum;
-              }
-            | { __typename?: "MustHaveSetForUploadLinkErr" }
-            | {
-                __typename?: "NoInitForChunkedUploadErr";
-                segmentType: StreamSegmentTypeEnum;
-              }
-            | { __typename?: "ProcessingFailedErr" }
-            | { __typename?: "SegmentAlreadyUploadedErr" }
-            | { __typename?: "TooManyInitUploadsErr"; linksRequested: number }
-            | { __typename?: "TooManyProfileImageUploadsErr" };
-        }
-      | {
-          __typename?: "UploadLink";
-          uploadUrl: string;
-          headers: Array<{
-            __typename?: "Header";
-            key: string;
-            value: string;
-          } | null>;
-        };
-  };
-};
+
+export type GetHlsInitUploadLinkMutation = { __typename?: 'Mutation', getHlsInitUploadLink: { __typename?: 'GetUploadLinkReturn', value: { __typename?: 'GetUploadLinkErrors', error: { __typename?: 'InitUploadAlreadyCompletedErr', segmentType: StreamSegmentTypeEnum } | { __typename?: 'MustHaveSetForUploadLinkErr' } | { __typename?: 'NoInitForChunkedUploadErr', segmentType: StreamSegmentTypeEnum } | { __typename?: 'ProcessingFailedErr' } | { __typename?: 'SegmentAlreadyUploadedErr' } | { __typename?: 'TooManyInitUploadsErr', linksRequested: number } | { __typename?: 'TooManyProfileImageUploadsErr' } } | { __typename?: 'UploadLink', uploadUrl: string, headers: Array<{ __typename?: 'Header', key: string, value: string } | null> } } };
 
 export type SetSegmentDurationMutationVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
-  segmentIndex: Scalars["Int"]["input"];
-  duration: Scalars["Float"]["input"];
+  videoId: Scalars['Int']['input'];
+  segmentIndex: Scalars['Int']['input'];
+  duration: Scalars['Float']['input'];
 }>;
 
-export type SetSegmentDurationMutation = {
-  __typename?: "Mutation";
-  setSegmentDuration: boolean;
-};
+
+export type SetSegmentDurationMutation = { __typename?: 'Mutation', setSegmentDuration: boolean };
 
 export type EditUploadStreamMutationVariables = Exact<{
-  videoId: Scalars["Int"]["input"];
+  videoId: Scalars['Int']['input'];
   videoMetadataInput: VideoMetadataInput;
 }>;
 
-export type EditUploadStreamMutation = {
-  __typename?: "Mutation";
-  editUploadStream: boolean;
-};
+
+export type EditUploadStreamMutation = { __typename?: 'Mutation', editUploadStream: boolean };
 
 export type GetUploadStreamsQueryVariables = Exact<{
-  limit?: Scalars["Int"]["input"];
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  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 GetUploadStreamsQuery = { __typename?: 'Query', getUserVideos: { __typename?: 'VideoHistoryGQL', videos: Array<{ __typename?: 'VideoGQL', id: number }>, pageInfo: { __typename?: 'PageInfoGQL', hasNextPage: boolean, endCursor?: string | null } } };
 
 export type GetUploadStreamsWithDetailsQueryVariables = Exact<{
-  limit?: Scalars["Int"]["input"];
-  after?: InputMaybe<Scalars["String"]["input"]>;
+  limit?: Scalars['Int']['input'];
+  after?: InputMaybe<Scalars['String']['input']>;
   filters?: InputMaybe<VideoFilterInput>;
 }>;
 
-export type GetUploadStreamsWithDetailsQuery = {
-  __typename?: "Query";
-  getUserVideos: {
-    __typename?: "VideoHistoryGQL";
-    videos: Array<{
-      __typename?: "VideoGQL";
-      id: number;
-      name?: string | null;
-      startTime?: any | null;
-      stream?: {
-        __typename?: "UploadStreamGQL";
-        isCompleted: boolean;
-        lastIntendedSegmentBound?: number | null;
-        uploadCompletionCursor: number;
-        uploadsCompleted: number;
-      } | null;
-    }>;
-    pageInfo: {
-      __typename?: "PageInfoGQL";
-      hasNextPage: boolean;
-      endCursor?: string | null;
-    };
-  };
-};
+
+export type GetUploadStreamsWithDetailsQuery = { __typename?: 'Query', getUserVideos: { __typename?: 'VideoHistoryGQL', videos: Array<{ __typename?: 'VideoGQL', id: number, name?: string | null, startTime?: any | null, stream?: { __typename?: 'UploadStreamGQL', isCompleted: boolean, lastIntendedSegmentBound?: number | null, uploadCompletionCursor: number, uploadsCompleted: number } | null }>, pageInfo: { __typename?: 'PageInfoGQL', hasNextPage: boolean, endCursor?: string | null } } };
 
 export const ShotWithAllFeaturesFragmentDoc = gql`
-  fragment ShotWithAllFeatures on ShotGQL {
+    fragment ShotWithAllFeatures on ShotGQL {
+  id
+  videoId
+  startFrame
+  endFrame
+  startTime @client
+  endTime @client
+  user {
     id
-    videoId
-    startFrame
-    endFrame
-    startTime @client
-    endTime @client
-    user {
-      id
-    }
-    falsePositiveScore
-    createdAt
-    updatedAt
-    cueObjectFeatures {
-      cueObjectDistance
-      cueObjectAngle
-      cueBallSpeed
-      shotDirection
-      spinType
-    }
-    pocketingIntentionFeatures {
-      make
-      targetPocketDistance
-      targetPocketAngle
-      targetPocketAngleDirection
-      marginOfErrorInDegrees
-      intendedPocketType
-    }
-    pocketingIntentionInfo {
-      ballId
-      pocketId
-      pathMetadataIndex
-    }
-    serializedShotPaths {
-      b64EncodedBuffer
-    }
-    annotations {
-      shotId
-      type {
-        id
-        name
-      }
-      notes
-    }
   }
-`;
+  falsePositiveScore
+  createdAt
+  updatedAt
+  cueObjectFeatures {
+    cueObjectDistance
+    cueObjectAngle
+    cueBallSpeed
+    shotDirection
+    spinType
+  }
+  pocketingIntentionFeatures {
+    make
+    targetPocketDistance
+    targetPocketAngle
+    targetPocketAngleDirection
+    marginOfErrorInDegrees
+    intendedPocketType
+  }
+  pocketingIntentionInfo {
+    ballId
+    pocketId
+    pathMetadataIndex
+  }
+  serializedShotPaths {
+    b64EncodedBuffer
+  }
+  annotations {
+    shotId
+    type {
+      id
+      name
+    }
+    notes
+  }
+}
+    `;
 export const VideoStreamMetadataFragmentDoc = gql`
-  fragment VideoStreamMetadata on VideoGQL {
-    id
-    framesPerSecond
-    stream {
-      id
-      streamSegmentType
-      segments {
-        uploaded
-        valid
-        segmentIndex
-        endFrameIndex
-        framesPerSecond
-      }
-    }
-    playlist {
-      segmentDurations
-    }
-  }
-`;
-export const SegmentEndFramesFragmentDoc = gql`
-  fragment SegmentEndFrames on SegmentEndFramesGQL {
-    id
-    segmentEndFrames
-  }
-`;
-export const SegmentStartTimesFragmentDoc = gql`
-  fragment SegmentStartTimes on SegmentStartTimesGQL {
-    id
-    segmentStartTimes
-  }
-`;
-export const PlaylistWithSegmentStartTimesFragmentDoc = gql`
-  fragment PlaylistWithSegmentStartTimes on HLSPlaylistGQL {
-    videoId
-    segmentDurations
-    segmentStartTimes @client
-  }
-`;
-export const StreamWithEndFramesFragmentDoc = gql`
-  fragment StreamWithEndFrames on UploadStreamGQL {
+    fragment VideoStreamMetadata on VideoGQL {
+  id
+  framesPerSecond
+  stream {
     id
     streamSegmentType
-    segmentEndFrames @client
-    resolution {
-      width
-      height
-    }
     segments {
       uploaded
       valid
@@ -3998,35 +1416,75 @@ export const StreamWithEndFramesFragmentDoc = gql`
       framesPerSecond
     }
   }
-`;
-export const VideoDurationDataFragmentDoc = gql`
-  fragment VideoDurationData on VideoGQL {
-    id
+  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
-    playlist {
-      ...PlaylistWithSegmentStartTimes
-    }
-    stream {
-      ...StreamWithEndFrames
-    }
   }
-  ${PlaylistWithSegmentStartTimesFragmentDoc}
-  ${StreamWithEndFramesFragmentDoc}
-`;
+}
+    `;
+export const VideoDurationDataFragmentDoc = gql`
+    fragment VideoDurationData on VideoGQL {
+  id
+  framesPerSecond
+  playlist {
+    ...PlaylistWithSegmentStartTimes
+  }
+  stream {
+    ...StreamWithEndFrames
+  }
+}
+    ${PlaylistWithSegmentStartTimesFragmentDoc}
+${StreamWithEndFramesFragmentDoc}`;
 export const GetAggregatedShotMetricsDocument = gql`
-  query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
-    getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
-      aggregationIdentifiers {
-        featureName
-        groupName
-      }
-      targetMetrics {
-        count
-        makePercentage
-      }
+    query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
+  getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
+    aggregationIdentifiers {
+      featureName
+      groupName
+    }
+    targetMetrics {
+      count
+      makePercentage
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetAggregatedShotMetricsQuery__
@@ -4044,66 +1502,33 @@ export const GetAggregatedShotMetricsDocument = gql`
  *   },
  * });
  */
-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 function useGetAggregatedShotMetricsQuery(baseOptions: Apollo.QueryHookOptions<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>(GetAggregatedShotMetricsDocument, options);
+      }
+export function useGetAggregatedShotMetricsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>(GetAggregatedShotMetricsDocument, options);
+        }
+export function useGetAggregatedShotMetricsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>(GetAggregatedShotMetricsDocument, options);
+        }
+export type GetAggregatedShotMetricsQueryHookResult = ReturnType<typeof useGetAggregatedShotMetricsQuery>;
+export type GetAggregatedShotMetricsLazyQueryHookResult = ReturnType<typeof useGetAggregatedShotMetricsLazyQuery>;
+export type GetAggregatedShotMetricsSuspenseQueryHookResult = ReturnType<typeof useGetAggregatedShotMetricsSuspenseQuery>;
+export type GetAggregatedShotMetricsQueryResult = Apollo.QueryResult<GetAggregatedShotMetricsQuery, GetAggregatedShotMetricsQueryVariables>;
 export const GetDeployedConfigDocument = gql`
-  query getDeployedConfig {
-    getDeployedConfig {
-      allowNewUsers
-      devMode
-      environment
-      firebase
-      minimumAllowedAppVersion
-    }
+    query getDeployedConfig {
+  getDeployedConfig {
+    allowNewUsers
+    devMode
+    environment
+    firebase
+    minimumAllowedAppVersion
   }
-`;
+}
+    `;
 
 /**
  * __useGetDeployedConfigQuery__
@@ -4120,97 +1545,60 @@ export const GetDeployedConfigDocument = gql`
  *   },
  * });
  */
-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 function useGetDeployedConfigQuery(baseOptions?: Apollo.QueryHookOptions<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>(GetDeployedConfigDocument, options);
+      }
+export function useGetDeployedConfigLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>(GetDeployedConfigDocument, options);
+        }
+export function useGetDeployedConfigSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>(GetDeployedConfigDocument, options);
+        }
+export type GetDeployedConfigQueryHookResult = ReturnType<typeof useGetDeployedConfigQuery>;
+export type GetDeployedConfigLazyQueryHookResult = ReturnType<typeof useGetDeployedConfigLazyQuery>;
+export type GetDeployedConfigSuspenseQueryHookResult = ReturnType<typeof useGetDeployedConfigSuspenseQuery>;
+export type GetDeployedConfigQueryResult = Apollo.QueryResult<GetDeployedConfigQuery, GetDeployedConfigQueryVariables>;
 export const GetFeedDocument = gql`
-  query GetFeed(
-    $limit: Int! = 5
-    $after: String = null
-    $filters: VideoFilterInput = null
-  ) {
-    getUserVideos(limit: $limit, after: $after, filters: $filters) {
-      videos {
+    query GetFeed($limit: Int! = 5, $after: String = null, $filters: VideoFilterInput = null) {
+  getUserVideos(limit: $limit, after: $after, filters: $filters) {
+    videos {
+      id
+      owner {
+        username
+      }
+      name
+      screenshotUri
+      totalShotsMade
+      totalShots
+      makePercentage
+      createdAt
+      updatedAt
+      startTime
+      endTime
+      elapsedTime
+      screenshotUri
+      stream {
         id
-        owner {
-          username
-        }
-        name
-        screenshotUri
-        totalShotsMade
-        totalShots
-        makePercentage
-        createdAt
-        updatedAt
-        startTime
-        endTime
-        elapsedTime
-        screenshotUri
-        stream {
-          id
-          isCompleted
-        }
-        tableSize
-        tags {
-          tagClasses {
-            name
-          }
+        isCompleted
+      }
+      tableSize
+      tags {
+        tagClasses {
           name
         }
-      }
-      pageInfo {
-        hasNextPage
-        endCursor
+        name
       }
     }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
   }
-`;
+}
+    `;
 
 /**
  * __useGetFeedQuery__
@@ -4230,62 +1618,33 @@ export const GetFeedDocument = gql`
  *   },
  * });
  */
-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 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 type GetFeedSuspenseQueryHookResult = ReturnType<typeof useGetFeedSuspenseQuery>;
+export type GetFeedQueryResult = Apollo.QueryResult<GetFeedQuery, GetFeedQueryVariables>;
 export const GetVideoMakePercentageIntervalsDocument = gql`
-  query GetVideoMakePercentageIntervals(
-    $videoId: ID!
-    $intervalDuration: Int!
+    query GetVideoMakePercentageIntervals($videoId: ID!, $intervalDuration: Int!) {
+  getVideoMakePercentageIntervals(
+    videoId: $videoId
+    intervalDuration: $intervalDuration
   ) {
-    getVideoMakePercentageIntervals(
-      videoId: $videoId
-      intervalDuration: $intervalDuration
-    ) {
-      makePercentage
-      elapsedTime
-    }
+    makePercentage
+    elapsedTime
   }
-`;
+}
+    `;
 
 /**
  * __useGetVideoMakePercentageIntervalsQuery__
@@ -4304,68 +1663,35 @@ export const GetVideoMakePercentageIntervalsDocument = gql`
  *   },
  * });
  */
-export function useGetVideoMakePercentageIntervalsQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >(GetVideoMakePercentageIntervalsDocument, options);
-}
-export function useGetVideoMakePercentageIntervalsLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >(GetVideoMakePercentageIntervalsDocument, options);
-}
-export function useGetVideoMakePercentageIntervalsSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    GetVideoMakePercentageIntervalsQuery,
-    GetVideoMakePercentageIntervalsQueryVariables
-  >(GetVideoMakePercentageIntervalsDocument, options);
-}
-export type GetVideoMakePercentageIntervalsQueryHookResult = ReturnType<
-  typeof useGetVideoMakePercentageIntervalsQuery
->;
-export type GetVideoMakePercentageIntervalsLazyQueryHookResult = ReturnType<
-  typeof useGetVideoMakePercentageIntervalsLazyQuery
->;
-export type GetVideoMakePercentageIntervalsSuspenseQueryHookResult = ReturnType<
-  typeof useGetVideoMakePercentageIntervalsSuspenseQuery
->;
-export type GetVideoMakePercentageIntervalsQueryResult = Apollo.QueryResult<
-  GetVideoMakePercentageIntervalsQuery,
-  GetVideoMakePercentageIntervalsQueryVariables
->;
-export const GetSerializedShotPathsDocument = gql`
-  query GetSerializedShotPaths($filterInput: FilterInput!) {
-    getShots(filterInput: $filterInput) {
-      id
-      videoId
-      startFrame
-      endFrame
-      serializedShotPaths {
-        b64EncodedBuffer
+export function useGetVideoMakePercentageIntervalsQuery(baseOptions: Apollo.QueryHookOptions<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>(GetVideoMakePercentageIntervalsDocument, options);
       }
+export function useGetVideoMakePercentageIntervalsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>(GetVideoMakePercentageIntervalsDocument, options);
+        }
+export function useGetVideoMakePercentageIntervalsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>(GetVideoMakePercentageIntervalsDocument, options);
+        }
+export type GetVideoMakePercentageIntervalsQueryHookResult = ReturnType<typeof useGetVideoMakePercentageIntervalsQuery>;
+export type GetVideoMakePercentageIntervalsLazyQueryHookResult = ReturnType<typeof useGetVideoMakePercentageIntervalsLazyQuery>;
+export type GetVideoMakePercentageIntervalsSuspenseQueryHookResult = ReturnType<typeof useGetVideoMakePercentageIntervalsSuspenseQuery>;
+export type GetVideoMakePercentageIntervalsQueryResult = Apollo.QueryResult<GetVideoMakePercentageIntervalsQuery, GetVideoMakePercentageIntervalsQueryVariables>;
+export const GetSerializedShotPathsDocument = gql`
+    query GetSerializedShotPaths($filterInput: FilterInput!) {
+  getShots(filterInput: $filterInput) {
+    id
+    videoId
+    startFrame
+    endFrame
+    serializedShotPaths {
+      b64EncodedBuffer
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetSerializedShotPathsQuery__
@@ -4383,63 +1709,30 @@ export const GetSerializedShotPathsDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetShotAnnotationTypes {
+  getShotAnnotationTypes {
+    id
+    name
   }
-`;
+}
+    `;
 
 /**
  * __useGetShotAnnotationTypesQuery__
@@ -4456,83 +1749,44 @@ export const GetShotAnnotationTypesDocument = gql`
  *   },
  * });
  */
-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
-        }
+export function useGetShotAnnotationTypesQuery(baseOptions?: Apollo.QueryHookOptions<GetShotAnnotationTypesQuery, GetShotAnnotationTypesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetShotAnnotationTypesQuery, GetShotAnnotationTypesQueryVariables>(GetShotAnnotationTypesDocument, options);
       }
-      error {
+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
-        msg
+        type {
+          id
+          name
+        }
+        notes
       }
     }
+    error {
+      shotId
+      msg
+    }
   }
-`;
-export type UpdateShotAnnotationsMutationFn = Apollo.MutationFunction<
-  UpdateShotAnnotationsMutation,
-  UpdateShotAnnotationsMutationVariables
->;
+}
+    `;
+export type UpdateShotAnnotationsMutationFn = Apollo.MutationFunction<UpdateShotAnnotationsMutation, UpdateShotAnnotationsMutationVariables>;
 
 /**
  * __useUpdateShotAnnotationsMutation__
@@ -4552,49 +1806,31 @@ export type UpdateShotAnnotationsMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
+    query GetShotsWithVideoGql($filterInput: FilterInput!, $shotsOrdering: GetShotsOrdering, $limit: Int) {
+  getOrderedShots(
+    filterInput: $filterInput
+    shotsOrdering: $shotsOrdering
+    limit: $limit
   ) {
-    getOrderedShots(
-      filterInput: $filterInput
-      shotsOrdering: $shotsOrdering
-      limit: $limit
-    ) {
-      shots {
-        id
-        videoId
-        video {
-          screenshotUri
-          endTime
-        }
+    shots {
+      id
+      videoId
+      video {
+        screenshotUri
+        endTime
       }
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetShotsWithVideoGqlQuery__
@@ -4614,77 +1850,38 @@ export const GetShotsWithVideoGqlDocument = gql`
  *   },
  * });
  */
-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 GetShotsWithMetadataFilterResultDocument = gql`
-  query GetShotsWithMetadataFilterResult(
-    $filterInput: FilterInput!
-    $shotsOrdering: GetShotsOrdering
-    $limit: Int
-    $ids: [Int!]
-  ) {
-    getOrderedShots(
-      filterInput: $filterInput
-      shotsOrdering: $shotsOrdering
-      limit: $limit
-      ids: $ids
-    ) {
-      count
-      shots {
-        ...ShotWithAllFeatures
+export function useGetShotsWithVideoGqlQuery(baseOptions: Apollo.QueryHookOptions<GetShotsWithVideoGqlQuery, GetShotsWithVideoGqlQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetShotsWithVideoGqlQuery, GetShotsWithVideoGqlQueryVariables>(GetShotsWithVideoGqlDocument, options);
       }
-      ids
+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 GetShotsWithMetadataFilterResultDocument = gql`
+    query GetShotsWithMetadataFilterResult($filterInput: FilterInput!, $shotsOrdering: GetShotsOrdering, $limit: Int, $ids: [Int!]) {
+  getOrderedShots(
+    filterInput: $filterInput
+    shotsOrdering: $shotsOrdering
+    limit: $limit
+    ids: $ids
+  ) {
+    count
+    shots {
+      ...ShotWithAllFeatures
     }
+    ids
   }
-  ${ShotWithAllFeaturesFragmentDoc}
-`;
+}
+    ${ShotWithAllFeaturesFragmentDoc}`;
 
 /**
  * __useGetShotsWithMetadataFilterResultQuery__
@@ -4705,76 +1902,38 @@ export const GetShotsWithMetadataFilterResultDocument = gql`
  *   },
  * });
  */
-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
+export function useGetShotsWithMetadataFilterResultQuery(baseOptions: Apollo.QueryHookOptions<GetShotsWithMetadataFilterResultQuery, GetShotsWithMetadataFilterResultQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetShotsWithMetadataFilterResultQuery, GetShotsWithMetadataFilterResultQueryVariables>(GetShotsWithMetadataFilterResultDocument, options);
       }
-      ids
+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}
-`;
+}
+    ${ShotWithAllFeaturesFragmentDoc}`;
 
 /**
  * __useGetShotsWithMetadataQuery__
@@ -4795,63 +1954,29 @@ export const GetShotsWithMetadataDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetShotsByIds($ids: [Int!]!) {
+  getShotsByIds(ids: $ids) {
+    ...ShotWithAllFeatures
   }
-  ${ShotWithAllFeaturesFragmentDoc}
-`;
+}
+    ${ShotWithAllFeaturesFragmentDoc}`;
 
 /**
  * __useGetShotsByIdsQuery__
@@ -4869,81 +1994,45 @@ export const GetShotsByIdsDocument = gql`
  *   },
  * });
  */
-export function useGetShotsByIdsQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    GetShotsByIdsQuery,
-    GetShotsByIdsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>(
-    GetShotsByIdsDocument,
-    options,
-  );
-}
-export function useGetShotsByIdsLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetShotsByIdsQuery,
-    GetShotsByIdsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>(
-    GetShotsByIdsDocument,
-    options,
-  );
-}
-export function useGetShotsByIdsSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetShotsByIdsQuery,
-    GetShotsByIdsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    GetShotsByIdsQuery,
-    GetShotsByIdsQueryVariables
-  >(GetShotsByIdsDocument, options);
-}
-export type GetShotsByIdsQueryHookResult = ReturnType<
-  typeof useGetShotsByIdsQuery
->;
-export type GetShotsByIdsLazyQueryHookResult = ReturnType<
-  typeof useGetShotsByIdsLazyQuery
->;
-export type GetShotsByIdsSuspenseQueryHookResult = ReturnType<
-  typeof useGetShotsByIdsSuspenseQuery
->;
-export type GetShotsByIdsQueryResult = Apollo.QueryResult<
-  GetShotsByIdsQuery,
-  GetShotsByIdsQueryVariables
->;
-export const GetProfileImageUploadLinkDocument = gql`
-  mutation getProfileImageUploadLink($fileExt: String = ".png") {
-    getProfileImageUploadLink(fileExt: $fileExt) {
-      value {
-        ... on UploadLink {
-          uploadUrl
-          headers {
-            key
-            value
-          }
+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);
         }
-        ... on GetProfileUploadLinkErrors {
-          error {
-            ... on TooManyProfileImageUploadsErr {
-              linksRequested
-            }
+export function useGetShotsByIdsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>(GetShotsByIdsDocument, options);
+        }
+export type GetShotsByIdsQueryHookResult = ReturnType<typeof useGetShotsByIdsQuery>;
+export type GetShotsByIdsLazyQueryHookResult = ReturnType<typeof useGetShotsByIdsLazyQuery>;
+export type GetShotsByIdsSuspenseQueryHookResult = ReturnType<typeof useGetShotsByIdsSuspenseQuery>;
+export type GetShotsByIdsQueryResult = Apollo.QueryResult<GetShotsByIdsQuery, GetShotsByIdsQueryVariables>;
+export const GetProfileImageUploadLinkDocument = gql`
+    mutation getProfileImageUploadLink($fileExt: String = ".png") {
+  getProfileImageUploadLink(fileExt: $fileExt) {
+    value {
+      ... on UploadLink {
+        uploadUrl
+        headers {
+          key
+          value
+        }
+      }
+      ... on GetProfileUploadLinkErrors {
+        error {
+          ... on TooManyProfileImageUploadsErr {
+            linksRequested
           }
         }
       }
     }
   }
-`;
-export type GetProfileImageUploadLinkMutationFn = Apollo.MutationFunction<
-  GetProfileImageUploadLinkMutation,
-  GetProfileImageUploadLinkMutationVariables
->;
+}
+    `;
+export type GetProfileImageUploadLinkMutationFn = Apollo.MutationFunction<GetProfileImageUploadLinkMutation, GetProfileImageUploadLinkMutationVariables>;
 
 /**
  * __useGetProfileImageUploadLinkMutation__
@@ -4962,44 +2051,26 @@ export type GetProfileImageUploadLinkMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 function useGetProfileImageUploadLinkMutation(baseOptions?: Apollo.MutationHookOptions<GetProfileImageUploadLinkMutation, GetProfileImageUploadLinkMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useMutation<GetProfileImageUploadLinkMutation, GetProfileImageUploadLinkMutationVariables>(GetProfileImageUploadLinkDocument, options);
+      }
+export type GetProfileImageUploadLinkMutationHookResult = ReturnType<typeof useGetProfileImageUploadLinkMutation>;
+export type GetProfileImageUploadLinkMutationResult = Apollo.MutationResult<GetProfileImageUploadLinkMutation>;
+export type GetProfileImageUploadLinkMutationOptions = Apollo.BaseMutationOptions<GetProfileImageUploadLinkMutation, GetProfileImageUploadLinkMutationVariables>;
 export const EditProfileImageUriDocument = gql`
-  mutation editProfileImageUri($profileImageUri: String!) {
-    editProfileImageUri(profileImageUri: $profileImageUri) {
-      id
-      firebaseUid
-      username
-      profileImageUri
-      createdAt
-      updatedAt
-    }
+    mutation editProfileImageUri($profileImageUri: String!) {
+  editProfileImageUri(profileImageUri: $profileImageUri) {
+    id
+    firebaseUid
+    username
+    profileImageUri
+    createdAt
+    updatedAt
   }
-`;
-export type EditProfileImageUriMutationFn = Apollo.MutationFunction<
-  EditProfileImageUriMutation,
-  EditProfileImageUriMutationVariables
->;
+}
+    `;
+export type EditProfileImageUriMutationFn = Apollo.MutationFunction<EditProfileImageUriMutation, EditProfileImageUriMutationVariables>;
 
 /**
  * __useEditProfileImageUriMutation__
@@ -5018,42 +2089,28 @@ export type EditProfileImageUriMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 function useEditProfileImageUriMutation(baseOptions?: Apollo.MutationHookOptions<EditProfileImageUriMutation, EditProfileImageUriMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useMutation<EditProfileImageUriMutation, EditProfileImageUriMutationVariables>(EditProfileImageUriDocument, options);
+      }
+export type EditProfileImageUriMutationHookResult = ReturnType<typeof useEditProfileImageUriMutation>;
+export type EditProfileImageUriMutationResult = Apollo.MutationResult<EditProfileImageUriMutation>;
+export type EditProfileImageUriMutationOptions = Apollo.BaseMutationOptions<EditProfileImageUriMutation, EditProfileImageUriMutationVariables>;
 export const GetLoggedInUserDocument = gql`
-  query getLoggedInUser {
-    getLoggedInUser {
-      id
-      firebaseUid
-      username
-      isAdmin
-      profileImageUri
-      fargoRating
-      activeVideoId
-      createdAt
-      updatedAt
-    }
+    query getLoggedInUser {
+  getLoggedInUser {
+    id
+    firebaseUid
+    username
+    isAdmin
+    profileImageUri
+    fargoRating
+    activeVideoId
+    createdAt
+    updatedAt
   }
-`;
+}
+    `;
 
 /**
  * __useGetLoggedInUserQuery__
@@ -5070,62 +2127,29 @@ export const GetLoggedInUserDocument = gql`
  *   },
  * });
  */
-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 function useGetLoggedInUserQuery(baseOptions?: Apollo.QueryHookOptions<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>(GetLoggedInUserDocument, options);
+      }
+export function useGetLoggedInUserLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>(GetLoggedInUserDocument, options);
+        }
+export function useGetLoggedInUserSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>(GetLoggedInUserDocument, options);
+        }
+export type GetLoggedInUserQueryHookResult = ReturnType<typeof useGetLoggedInUserQuery>;
+export type GetLoggedInUserLazyQueryHookResult = ReturnType<typeof useGetLoggedInUserLazyQuery>;
+export type GetLoggedInUserSuspenseQueryHookResult = ReturnType<typeof useGetLoggedInUserSuspenseQuery>;
+export type GetLoggedInUserQueryResult = Apollo.QueryResult<GetLoggedInUserQuery, GetLoggedInUserQueryVariables>;
 export const GetUserPlayTimeDocument = gql`
-  query GetUserPlayTime($userId: Int!) {
-    getPlayTime(userId: $userId) {
-      totalSeconds
-    }
+    query GetUserPlayTime($userId: Int!) {
+  getPlayTime(userId: $userId) {
+    totalSeconds
   }
-`;
+}
+    `;
 
 /**
  * __useGetUserPlayTimeQuery__
@@ -5143,64 +2167,27 @@ export const GetUserPlayTimeDocument = gql`
  *   },
  * });
  */
-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 function useGetUserPlayTimeQuery(baseOptions: Apollo.QueryHookOptions<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>(GetUserPlayTimeDocument, options);
+      }
+export function useGetUserPlayTimeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>(GetUserPlayTimeDocument, options);
+        }
+export function useGetUserPlayTimeSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>(GetUserPlayTimeDocument, options);
+        }
+export type GetUserPlayTimeQueryHookResult = ReturnType<typeof useGetUserPlayTimeQuery>;
+export type GetUserPlayTimeLazyQueryHookResult = ReturnType<typeof useGetUserPlayTimeLazyQuery>;
+export type GetUserPlayTimeSuspenseQueryHookResult = ReturnType<typeof useGetUserPlayTimeSuspenseQuery>;
+export type GetUserPlayTimeQueryResult = Apollo.QueryResult<GetUserPlayTimeQuery, GetUserPlayTimeQueryVariables>;
 export const GetUsernamesDocument = gql`
-  query getUsernames(
-    $matchString: String!
-    $limit: Int = null
-    $after: String = null
-  ) {
-    getUsernames(matchString: $matchString, limit: $limit, after: $after)
-  }
-`;
+    query getUsernames($matchString: String!, $limit: Int = null, $after: String = null) {
+  getUsernames(matchString: $matchString, limit: $limit, after: $after)
+}
+    `;
 
 /**
  * __useGetUsernamesQuery__
@@ -5220,79 +2207,41 @@ export const GetUsernamesDocument = gql`
  *   },
  * });
  */
-export function useGetUsernamesQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    GetUsernamesQuery,
-    GetUsernamesQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
-    GetUsernamesDocument,
-    options,
-  );
-}
-export function useGetUsernamesLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetUsernamesQuery,
-    GetUsernamesQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
-    GetUsernamesDocument,
-    options,
-  );
-}
-export function useGetUsernamesSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetUsernamesQuery,
-    GetUsernamesQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(
-    GetUsernamesDocument,
-    options,
-  );
-}
-export type GetUsernamesQueryHookResult = ReturnType<
-  typeof useGetUsernamesQuery
->;
-export type GetUsernamesLazyQueryHookResult = ReturnType<
-  typeof useGetUsernamesLazyQuery
->;
-export type GetUsernamesSuspenseQueryHookResult = ReturnType<
-  typeof useGetUsernamesSuspenseQuery
->;
-export type GetUsernamesQueryResult = Apollo.QueryResult<
-  GetUsernamesQuery,
-  GetUsernamesQueryVariables
->;
-export const GetUserRelationshipsMatchingDocument = gql`
-  query getUserRelationshipsMatching(
-    $userId: Int!
-    $matchString: String!
-    $limit: Int = null
-    $after: String = null
-  ) {
-    getUserRelationshipsMatching(
-      userId: $userId
-      matchString: $matchString
-      limit: $limit
-      after: $after
-    ) {
-      relationships {
-        toUser {
-          username
-          id
-        }
-        toUserFollows
-        toUserIsFollowedBy
+export function useGetUsernamesQuery(baseOptions: Apollo.QueryHookOptions<GetUsernamesQuery, GetUsernamesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(GetUsernamesDocument, options);
       }
+export function useGetUsernamesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUsernamesQuery, GetUsernamesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(GetUsernamesDocument, options);
+        }
+export function useGetUsernamesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetUsernamesQuery, GetUsernamesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetUsernamesQuery, GetUsernamesQueryVariables>(GetUsernamesDocument, options);
+        }
+export type GetUsernamesQueryHookResult = ReturnType<typeof useGetUsernamesQuery>;
+export type GetUsernamesLazyQueryHookResult = ReturnType<typeof useGetUsernamesLazyQuery>;
+export type GetUsernamesSuspenseQueryHookResult = ReturnType<typeof useGetUsernamesSuspenseQuery>;
+export type GetUsernamesQueryResult = Apollo.QueryResult<GetUsernamesQuery, GetUsernamesQueryVariables>;
+export const GetUserRelationshipsMatchingDocument = gql`
+    query getUserRelationshipsMatching($userId: Int!, $matchString: String!, $limit: Int = null, $after: String = null) {
+  getUserRelationshipsMatching(
+    userId: $userId
+    matchString: $matchString
+    limit: $limit
+    after: $after
+  ) {
+    relationships {
+      toUser {
+        username
+        id
+      }
+      toUserFollows
+      toUserIsFollowedBy
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetUserRelationshipsMatchingQuery__
@@ -5313,63 +2262,30 @@ export const GetUserRelationshipsMatchingDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetUserTags {
+  getUserTags {
+    id
+    name
   }
-`;
+}
+    `;
 
 /**
  * __useGetUserTagsQuery__
@@ -5386,73 +2302,39 @@ export const GetUserTagsDocument = gql`
  *   },
  * });
  */
-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 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 type GetUserTagsLazyQueryHookResult = ReturnType<typeof useGetUserTagsLazyQuery>;
+export type GetUserTagsSuspenseQueryHookResult = ReturnType<typeof useGetUserTagsSuspenseQuery>;
+export type GetUserTagsQueryResult = Apollo.QueryResult<GetUserTagsQuery, GetUserTagsQueryVariables>;
 export const FollowUserDocument = gql`
-  mutation followUser($followedUserId: Int!) {
-    followUser(followedUserId: $followedUserId) {
-      username
+    mutation followUser($followedUserId: Int!) {
+  followUser(followedUserId: $followedUserId) {
+    username
+    id
+    following {
       id
-      following {
-        id
-        username
-      }
-      followers {
-        id
-        username
-      }
+      username
+    }
+    followers {
+      id
+      username
     }
   }
-`;
-export type FollowUserMutationFn = Apollo.MutationFunction<
-  FollowUserMutation,
-  FollowUserMutationVariables
->;
+}
+    `;
+export type FollowUserMutationFn = Apollo.MutationFunction<FollowUserMutation, FollowUserMutationVariables>;
 
 /**
  * __useFollowUserMutation__
@@ -5471,47 +2353,30 @@ export type FollowUserMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 function useFollowUserMutation(baseOptions?: Apollo.MutationHookOptions<FollowUserMutation, FollowUserMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useMutation<FollowUserMutation, FollowUserMutationVariables>(FollowUserDocument, options);
+      }
+export type FollowUserMutationHookResult = ReturnType<typeof useFollowUserMutation>;
+export type FollowUserMutationResult = Apollo.MutationResult<FollowUserMutation>;
+export type FollowUserMutationOptions = Apollo.BaseMutationOptions<FollowUserMutation, FollowUserMutationVariables>;
 export const UnfollowUserDocument = gql`
-  mutation unfollowUser($followedUserId: Int!) {
-    unfollowUser(followedUserId: $followedUserId) {
-      username
+    mutation unfollowUser($followedUserId: Int!) {
+  unfollowUser(followedUserId: $followedUserId) {
+    username
+    id
+    following {
       id
-      following {
-        id
-        username
-      }
-      followers {
-        id
-        username
-      }
+      username
+    }
+    followers {
+      id
+      username
     }
   }
-`;
-export type UnfollowUserMutationFn = Apollo.MutationFunction<
-  UnfollowUserMutation,
-  UnfollowUserMutationVariables
->;
+}
+    `;
+export type UnfollowUserMutationFn = Apollo.MutationFunction<UnfollowUserMutation, UnfollowUserMutationVariables>;
 
 /**
  * __useUnfollowUserMutation__
@@ -5530,42 +2395,28 @@ export type UnfollowUserMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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 {
+    query getUserFollowingFollowers {
+  getLoggedInUser {
+    id
+    following {
       id
-      following {
-        id
-        username
-      }
-      followers {
-        id
-        username
-      }
+      username
+    }
+    followers {
+      id
+      username
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetUserFollowingFollowersQuery__
@@ -5582,122 +2433,127 @@ export const GetUserFollowingFollowersDocument = gql`
  *   },
  * });
  */
-export function useGetUserFollowingFollowersQuery(
-  baseOptions?: Apollo.QueryHookOptions<
-    GetUserFollowingFollowersQuery,
-    GetUserFollowingFollowersQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<
-    GetUserFollowingFollowersQuery,
-    GetUserFollowingFollowersQueryVariables
-  >(GetUserFollowingFollowersDocument, options);
+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)
 }
-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
->;
+    `;
+
+/**
+ * __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 GetStreamMonitoringDetailsDocument = gql`
-  query GetStreamMonitoringDetails($videoId: Int!, $debuggingJson: JSON) {
-    getVideo(videoId: $videoId, debuggingJson: $debuggingJson) {
-      id
-      totalShots
-      makePercentage
-      elapsedTime
-      currentHomography {
-        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
-          }
-        }
+    query GetStreamMonitoringDetails($videoId: Int!, $debuggingJson: JSON) {
+  getVideo(videoId: $videoId, debuggingJson: $debuggingJson) {
+    id
+    totalShots
+    makePercentage
+    elapsedTime
+    currentHomography {
+      crop {
+        left
+        top
+        width
+        height
       }
-      stream {
-        id
-        linksRequested
-        uploadsCompleted
-        segmentProcessingCursor
-        isCompleted
-        uploadCompletionCursor
-        lastIntendedSegmentBound
-        initPlaylistUploadStatus
+      pockets {
+        left
+        top
+        width
+        height
       }
-      currentProcessing {
-        errors {
-          message
-          startSegmentIndex
-          endSegmentIndex
+      sourcePoints {
+        topLeft {
+          x
+          y
+        }
+        topSide {
+          x
+          y
+        }
+        topRight {
+          x
+          y
+        }
+        bottomLeft {
+          x
+          y
+        }
+        bottomSide {
+          x
+          y
+        }
+        bottomRight {
+          x
+          y
         }
       }
     }
+    stream {
+      id
+      linksRequested
+      uploadsCompleted
+      segmentProcessingCursor
+      isCompleted
+      uploadCompletionCursor
+      lastIntendedSegmentBound
+      initPlaylistUploadStatus
+    }
+    currentProcessing {
+      errors {
+        message
+        startSegmentIndex
+        endSegmentIndex
+      }
+    }
   }
-`;
+}
+    `;
 
 /**
  * __useGetStreamMonitoringDetailsQuery__
@@ -5716,73 +2572,40 @@ export const GetStreamMonitoringDetailsDocument = gql`
  *   },
  * });
  */
-export function useGetStreamMonitoringDetailsQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >(GetStreamMonitoringDetailsDocument, options);
-}
-export function useGetStreamMonitoringDetailsLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >(GetStreamMonitoringDetailsDocument, options);
-}
-export function useGetStreamMonitoringDetailsSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    GetStreamMonitoringDetailsQuery,
-    GetStreamMonitoringDetailsQueryVariables
-  >(GetStreamMonitoringDetailsDocument, options);
-}
-export type GetStreamMonitoringDetailsQueryHookResult = ReturnType<
-  typeof useGetStreamMonitoringDetailsQuery
->;
-export type GetStreamMonitoringDetailsLazyQueryHookResult = ReturnType<
-  typeof useGetStreamMonitoringDetailsLazyQuery
->;
-export type GetStreamMonitoringDetailsSuspenseQueryHookResult = ReturnType<
-  typeof useGetStreamMonitoringDetailsSuspenseQuery
->;
-export type GetStreamMonitoringDetailsQueryResult = Apollo.QueryResult<
-  GetStreamMonitoringDetailsQuery,
-  GetStreamMonitoringDetailsQueryVariables
->;
-export const GetVideoUpdatePageDetailsDocument = gql`
-  query GetVideoUpdatePageDetails($videoId: Int!) {
-    getVideo(videoId: $videoId) {
-      id
-      name
-      totalShots
-      makePercentage
-      elapsedTime
-      tableSize
-      tags {
-        tagClasses {
-          name
+export function useGetStreamMonitoringDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>(GetStreamMonitoringDetailsDocument, options);
+      }
+export function useGetStreamMonitoringDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>(GetStreamMonitoringDetailsDocument, options);
         }
+export function useGetStreamMonitoringDetailsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>(GetStreamMonitoringDetailsDocument, options);
+        }
+export type GetStreamMonitoringDetailsQueryHookResult = ReturnType<typeof useGetStreamMonitoringDetailsQuery>;
+export type GetStreamMonitoringDetailsLazyQueryHookResult = ReturnType<typeof useGetStreamMonitoringDetailsLazyQuery>;
+export type GetStreamMonitoringDetailsSuspenseQueryHookResult = ReturnType<typeof useGetStreamMonitoringDetailsSuspenseQuery>;
+export type GetStreamMonitoringDetailsQueryResult = Apollo.QueryResult<GetStreamMonitoringDetailsQuery, GetStreamMonitoringDetailsQueryVariables>;
+export const GetVideoUpdatePageDetailsDocument = gql`
+    query GetVideoUpdatePageDetails($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    name
+    totalShots
+    makePercentage
+    elapsedTime
+    tableSize
+    tags {
+      tagClasses {
         name
       }
+      name
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetVideoUpdatePageDetailsQuery__
@@ -5800,64 +2623,28 @@ export const GetVideoUpdatePageDetailsDocument = gql`
  *   },
  * });
  */
-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 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
->;
+    mutation DeleteVideo($videoId: Int!) {
+  deleteVideo(videoId: $videoId)
+}
+    `;
+export type DeleteVideoMutationFn = Apollo.MutationFunction<DeleteVideoMutation, DeleteVideoMutationVariables>;
 
 /**
  * __useDeleteVideoMutation__
@@ -5876,59 +2663,45 @@ export type DeleteVideoMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-export function useDeleteVideoMutation(
-  baseOptions?: Apollo.MutationHookOptions<
-    DeleteVideoMutation,
-    DeleteVideoMutationVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useMutation<DeleteVideoMutation, DeleteVideoMutationVariables>(
-    DeleteVideoDocument,
-    options,
-  );
-}
-export type DeleteVideoMutationHookResult = ReturnType<
-  typeof useDeleteVideoMutation
->;
-export type DeleteVideoMutationResult =
-  Apollo.MutationResult<DeleteVideoMutation>;
-export type DeleteVideoMutationOptions = Apollo.BaseMutationOptions<
-  DeleteVideoMutation,
-  DeleteVideoMutationVariables
->;
-export const GetVideoDetailsDocument = gql`
-  query GetVideoDetails($videoId: Int!) {
-    getVideo(videoId: $videoId) {
-      id
-      name
-      screenshotUri
-      averageTimeBetweenShots
-      elapsedTime
-      endTime
-      makePercentage
-      medianRun
-      startTime
-      totalShots
-      totalShotsMade
-      createdAt
-      updatedAt
-      tableSize
-      owner {
-        id
-        firebaseUid
-        username
-        profileImageUri
+export function useDeleteVideoMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVideoMutation, DeleteVideoMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useMutation<DeleteVideoMutation, DeleteVideoMutationVariables>(DeleteVideoDocument, options);
       }
-      tags {
-        tagClasses {
-          name
-        }
+export type DeleteVideoMutationHookResult = ReturnType<typeof useDeleteVideoMutation>;
+export type DeleteVideoMutationResult = Apollo.MutationResult<DeleteVideoMutation>;
+export type DeleteVideoMutationOptions = Apollo.BaseMutationOptions<DeleteVideoMutation, DeleteVideoMutationVariables>;
+export const GetVideoDetailsDocument = gql`
+    query GetVideoDetails($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    name
+    screenshotUri
+    averageTimeBetweenShots
+    elapsedTime
+    endTime
+    makePercentage
+    medianRun
+    startTime
+    totalShots
+    totalShotsMade
+    createdAt
+    updatedAt
+    tableSize
+    owner {
+      id
+      firebaseUid
+      username
+      profileImageUri
+    }
+    tags {
+      tagClasses {
         name
       }
+      name
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetVideoDetailsQuery__
@@ -5946,63 +2719,29 @@ export const GetVideoDetailsDocument = gql`
  *   },
  * });
  */
-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 function useGetVideoDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>(GetVideoDetailsDocument, options);
+      }
+export function useGetVideoDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>(GetVideoDetailsDocument, options);
+        }
+export function useGetVideoDetailsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>(GetVideoDetailsDocument, options);
+        }
+export type GetVideoDetailsQueryHookResult = ReturnType<typeof useGetVideoDetailsQuery>;
+export type GetVideoDetailsLazyQueryHookResult = ReturnType<typeof useGetVideoDetailsLazyQuery>;
+export type GetVideoDetailsSuspenseQueryHookResult = ReturnType<typeof useGetVideoDetailsSuspenseQuery>;
+export type GetVideoDetailsQueryResult = Apollo.QueryResult<GetVideoDetailsQuery, GetVideoDetailsQueryVariables>;
 export const GetVideosDocument = gql`
-  query GetVideos($videoIds: [Int!]!) {
-    getVideos(videoIds: $videoIds) {
-      ...VideoStreamMetadata
-    }
+    query GetVideos($videoIds: [Int!]!) {
+  getVideos(videoIds: $videoIds) {
+    ...VideoStreamMetadata
   }
-  ${VideoStreamMetadataFragmentDoc}
-`;
+}
+    ${VideoStreamMetadataFragmentDoc}`;
 
 /**
  * __useGetVideosQuery__
@@ -6020,58 +2759,29 @@ export const GetVideosDocument = gql`
  *   },
  * });
  */
-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 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 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
-    }
+    query GetVideoForShotTime($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    ...VideoStreamMetadata
   }
-  ${VideoStreamMetadataFragmentDoc}
-`;
+}
+    ${VideoStreamMetadataFragmentDoc}`;
 
 /**
  * __useGetVideoForShotTimeQuery__
@@ -6089,119 +2799,86 @@ export const GetVideoForShotTimeDocument = gql`
  *   },
  * });
  */
-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 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
+    query GetVideo($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    playlist {
+      segmentDurations
+    }
+    homographyHistory {
+      frameIndex
+      crop {
+        left
+        top
+        width
+        height
       }
-      homographyHistory {
-        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
-          }
-        }
+      pockets {
+        left
+        top
+        width
+        height
       }
-      stream {
-        id
-        streamSegmentType
-        segments {
-          segmentIndex
-          endFrameIndex
-          framesPerSecond
+      sourcePoints {
+        topLeft {
+          x
+          y
         }
-        resolution {
-          width
-          height
+        topSide {
+          x
+          y
+        }
+        topRight {
+          x
+          y
+        }
+        bottomLeft {
+          x
+          y
+        }
+        bottomSide {
+          x
+          y
+        }
+        bottomRight {
+          x
+          y
         }
       }
     }
+    stream {
+      id
+      streamSegmentType
+      segments {
+        segmentIndex
+        endFrameIndex
+        framesPerSecond
+      }
+      resolution {
+        width
+        height
+      }
+    }
   }
-`;
+}
+    `;
 
 /**
  * __useGetVideoQuery__
@@ -6219,58 +2896,30 @@ export const GetVideoDocument = gql`
  *   },
  * });
  */
-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 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 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
-    }
+    query GetAverageTimePerShotForVideo($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    averageTimeBetweenShots
   }
-`;
+}
+    `;
 
 /**
  * __useGetAverageTimePerShotForVideoQuery__
@@ -6288,63 +2937,30 @@ export const GetAverageTimePerShotForVideoDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetElapsedTimeForVideo($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    elapsedTime
   }
-`;
+}
+    `;
 
 /**
  * __useGetElapsedTimeForVideoQuery__
@@ -6362,63 +2978,30 @@ export const GetElapsedTimeForVideoDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetMedianRunForVideo($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    medianRun
   }
-`;
+}
+    `;
 
 /**
  * __useGetMedianRunForVideoQuery__
@@ -6436,63 +3019,29 @@ export const GetMedianRunForVideoDocument = gql`
  *   },
  * });
  */
-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 function useGetMedianRunForVideoQuery(baseOptions: Apollo.QueryHookOptions<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>(GetMedianRunForVideoDocument, options);
+      }
+export function useGetMedianRunForVideoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>(GetMedianRunForVideoDocument, options);
+        }
+export function useGetMedianRunForVideoSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>(GetMedianRunForVideoDocument, options);
+        }
+export type GetMedianRunForVideoQueryHookResult = ReturnType<typeof useGetMedianRunForVideoQuery>;
+export type GetMedianRunForVideoLazyQueryHookResult = ReturnType<typeof useGetMedianRunForVideoLazyQuery>;
+export type GetMedianRunForVideoSuspenseQueryHookResult = ReturnType<typeof useGetMedianRunForVideoSuspenseQuery>;
+export type GetMedianRunForVideoQueryResult = Apollo.QueryResult<GetMedianRunForVideoQuery, GetMedianRunForVideoQueryVariables>;
 export const GetVideoForClipTimesDocument = gql`
-  query GetVideoForClipTimes($videoId: Int!) {
-    getVideo(videoId: $videoId) {
-      ...VideoDurationData
-    }
+    query GetVideoForClipTimes($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    ...VideoDurationData
   }
-  ${VideoDurationDataFragmentDoc}
-`;
+}
+    ${VideoDurationDataFragmentDoc}`;
 
 /**
  * __useGetVideoForClipTimesQuery__
@@ -6510,64 +3059,31 @@ export const GetVideoForClipTimesDocument = gql`
  *   },
  * });
  */
-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 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
-    }
+    query GetHeaderInfoByVideoId($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    name
+    startTime
   }
-`;
+}
+    `;
 
 /**
  * __useGetHeaderInfoByVideoIdQuery__
@@ -6585,66 +3101,30 @@ export const GetHeaderInfoByVideoIdDocument = gql`
  *   },
  * });
  */
-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 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 CreateUploadStreamDocument = gql`
-  mutation CreateUploadStream($videoMetadataInput: VideoMetadataInput!) {
-    createUploadStream(videoMetadata: $videoMetadataInput) {
-      videoId
-    }
+    mutation CreateUploadStream($videoMetadataInput: VideoMetadataInput!) {
+  createUploadStream(videoMetadata: $videoMetadataInput) {
+    videoId
   }
-`;
-export type CreateUploadStreamMutationFn = Apollo.MutationFunction<
-  CreateUploadStreamMutation,
-  CreateUploadStreamMutationVariables
->;
+}
+    `;
+export type CreateUploadStreamMutationFn = Apollo.MutationFunction<CreateUploadStreamMutation, CreateUploadStreamMutationVariables>;
 
 /**
  * __useCreateUploadStreamMutation__
@@ -6663,68 +3143,51 @@ export type CreateUploadStreamMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
-          }
+    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 GetUploadLinkErrors {
+        error {
+          ... on MustHaveSetForUploadLinkErr {
+            resolution
+            framesPerSecond
+          }
+          ... on SegmentAlreadyUploadedErr {
+            segmentId
+          }
+          ... on ProcessingFailedErr {
+            processing {
+              status
+              errors {
+                message
               }
             }
           }
         }
       }
-      stream {
-        uploadCompletionCursor
-      }
+    }
+    stream {
+      uploadCompletionCursor
     }
   }
-`;
-export type GetUploadLinkMutationFn = Apollo.MutationFunction<
-  GetUploadLinkMutation,
-  GetUploadLinkMutationVariables
->;
+}
+    `;
+export type GetUploadLinkMutationFn = Apollo.MutationFunction<GetUploadLinkMutation, GetUploadLinkMutationVariables>;
 
 /**
  * __useGetUploadLinkMutation__
@@ -6744,59 +3207,42 @@ export type GetUploadLinkMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
-          }
+    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 GetUploadLinkErrors {
+        error {
+          ... on NoInitForChunkedUploadErr {
+            segmentType
+          }
+          ... on InitUploadAlreadyCompletedErr {
+            segmentType
+          }
+          ... on TooManyInitUploadsErr {
+            linksRequested
           }
         }
       }
     }
   }
-`;
-export type GetHlsInitUploadLinkMutationFn = Apollo.MutationFunction<
-  GetHlsInitUploadLinkMutation,
-  GetHlsInitUploadLinkMutationVariables
->;
+}
+    `;
+export type GetHlsInitUploadLinkMutationFn = Apollo.MutationFunction<GetHlsInitUploadLinkMutation, GetHlsInitUploadLinkMutationVariables>;
 
 /**
  * __useGetHlsInitUploadLinkMutation__
@@ -6815,44 +3261,23 @@ export type GetHlsInitUploadLinkMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
->;
+    mutation SetSegmentDuration($videoId: Int!, $segmentIndex: Int!, $duration: Float!) {
+  setSegmentDuration(
+    videoId: $videoId
+    segmentIndex: $segmentIndex
+    duration: $duration
+  )
+}
+    `;
+export type SetSegmentDurationMutationFn = Apollo.MutationFunction<SetSegmentDurationMutation, SetSegmentDurationMutationVariables>;
 
 /**
  * __useSetSegmentDurationMutation__
@@ -6873,39 +3298,19 @@ export type SetSegmentDurationMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
->;
+    mutation EditUploadStream($videoId: Int!, $videoMetadataInput: VideoMetadataInput!) {
+  editUploadStream(videoId: $videoId, videoMetadata: $videoMetadataInput)
+}
+    `;
+export type EditUploadStreamMutationFn = Apollo.MutationFunction<EditUploadStreamMutation, EditUploadStreamMutationVariables>;
 
 /**
  * __useEditUploadStreamMutation__
@@ -6925,44 +3330,26 @@ export type EditUploadStreamMutationFn = Apollo.MutationFunction<
  *   },
  * });
  */
-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 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
-      }
+    query GetUploadStreams($limit: Int! = 5, $after: String = null, $filters: VideoFilterInput = null) {
+  getUserVideos(limit: $limit, after: $after, filters: $filters) {
+    videos {
+      id
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
     }
   }
-`;
+}
+    `;
 
 /**
  * __useGetUploadStreamsQuery__
@@ -6982,80 +3369,43 @@ export const GetUploadStreamsDocument = gql`
  *   },
  * });
  */
-export function useGetUploadStreamsQuery(
-  baseOptions?: Apollo.QueryHookOptions<
-    GetUploadStreamsQuery,
-    GetUploadStreamsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(
-    GetUploadStreamsDocument,
-    options,
-  );
-}
-export function useGetUploadStreamsLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetUploadStreamsQuery,
-    GetUploadStreamsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<
-    GetUploadStreamsQuery,
-    GetUploadStreamsQueryVariables
-  >(GetUploadStreamsDocument, options);
-}
-export function useGetUploadStreamsSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetUploadStreamsQuery,
-    GetUploadStreamsQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    GetUploadStreamsQuery,
-    GetUploadStreamsQueryVariables
-  >(GetUploadStreamsDocument, options);
-}
-export type GetUploadStreamsQueryHookResult = ReturnType<
-  typeof useGetUploadStreamsQuery
->;
-export type GetUploadStreamsLazyQueryHookResult = ReturnType<
-  typeof useGetUploadStreamsLazyQuery
->;
-export type GetUploadStreamsSuspenseQueryHookResult = ReturnType<
-  typeof useGetUploadStreamsSuspenseQuery
->;
-export type GetUploadStreamsQueryResult = Apollo.QueryResult<
-  GetUploadStreamsQuery,
-  GetUploadStreamsQueryVariables
->;
-export const GetUploadStreamsWithDetailsDocument = gql`
-  query GetUploadStreamsWithDetails(
-    $limit: Int! = 5
-    $after: String = null
-    $filters: VideoFilterInput = null
-  ) {
-    getUserVideos(limit: $limit, after: $after, filters: $filters) {
-      videos {
-        id
-        name
-        startTime
-        stream {
-          isCompleted
-          lastIntendedSegmentBound
-          uploadCompletionCursor
-          uploadsCompleted
-        }
+export function useGetUploadStreamsQuery(baseOptions?: Apollo.QueryHookOptions<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(GetUploadStreamsDocument, options);
       }
-      pageInfo {
-        hasNextPage
-        endCursor
+export function useGetUploadStreamsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(GetUploadStreamsDocument, options);
+        }
+export function useGetUploadStreamsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useSuspenseQuery<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>(GetUploadStreamsDocument, options);
+        }
+export type GetUploadStreamsQueryHookResult = ReturnType<typeof useGetUploadStreamsQuery>;
+export type GetUploadStreamsLazyQueryHookResult = ReturnType<typeof useGetUploadStreamsLazyQuery>;
+export type GetUploadStreamsSuspenseQueryHookResult = ReturnType<typeof useGetUploadStreamsSuspenseQuery>;
+export type GetUploadStreamsQueryResult = Apollo.QueryResult<GetUploadStreamsQuery, GetUploadStreamsQueryVariables>;
+export const GetUploadStreamsWithDetailsDocument = gql`
+    query GetUploadStreamsWithDetails($limit: Int! = 5, $after: String = null, $filters: VideoFilterInput = null) {
+  getUserVideos(limit: $limit, after: $after, filters: $filters) {
+    videos {
+      id
+      name
+      startTime
+      stream {
+        isCompleted
+        lastIntendedSegmentBound
+        uploadCompletionCursor
+        uploadsCompleted
       }
     }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
   }
-`;
+}
+    `;
 
 /**
  * __useGetUploadStreamsWithDetailsQuery__
@@ -7075,52 +3425,19 @@ export const GetUploadStreamsWithDetailsDocument = gql`
  *   },
  * });
  */
-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
->;
+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>;
\ No newline at end of file
diff --git a/src/operations/user.gql b/src/operations/user.gql
index a621549..dab3b6a 100644
--- a/src/operations/user.gql
+++ b/src/operations/user.gql
@@ -131,3 +131,7 @@ query getUserFollowingFollowers {
     }
   }
 }
+
+query doesUsernameExist($candidateUsername: String!) {
+  doesUsernameExist(candidateUsername: $candidateUsername)
+}
\ No newline at end of file
-- 
2.46.1