Regenerate schema with upstream Strawberry

Regenerated from backend Python: adds the HomographyBackendGQL enum
(CLASSIC/TABLENET) and the optional homographyBackend field on
VideoMetadataInput, for per-video homography backend selection.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/index.tsx

@@ -2404,6 +2404,11 @@ export type Header = {
   value: Scalars["String"]["output"];
 };
 
+export enum HomographyBackendGql {
+  Classic = "CLASSIC",
+  Tablenet = "TABLENET",
+}
+
 export type HomographyInfoGql = {
   __typename?: "HomographyInfoGQL";
   crop: BoundingBoxGql;
@@ -3088,6 +3093,7 @@ export type Query = {
   getQuotaStatus: QuotaStatusGql;
   getResolvedTier: ResolvedTierGql;
   getRuns: GetRunsResult;
+  getSessionCoach: SessionCoachGql;
   getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
   getShotTableState: ShotTableStateGql;
   getShots: Array<ShotGql>;
@@ -3231,6 +3237,10 @@ export type QueryGetRunsArgs = {
   runsOrdering?: InputMaybe<GetRunsOrdering>;
 };
 
+export type QueryGetSessionCoachArgs = {
+  videoId: Scalars["Int"]["input"];
+};
+
 export type QueryGetShotAnnotationTypesArgs = {
   errorTypes?: InputMaybe<Scalars["Boolean"]["input"]>;
 };
@@ -3546,6 +3556,84 @@ export type SerializedShotPathsGql = {
   b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
 };
 
+export enum SessionCoachCandidateFamilyEnum {
+  Aiming = "AIMING",
+  BackCut = "BACK_CUT",
+  CueToObjectDistance = "CUE_TO_OBJECT_DISTANCE",
+  CutAngle = "CUT_ANGLE",
+  ObjectToPocketDistance = "OBJECT_TO_POCKET_DISTANCE",
+  Spin = "SPIN",
+}
+
+export type SessionCoachCandidateGql = {
+  __typename?: "SessionCoachCandidateGQL";
+  action: Scalars["String"]["output"];
+  body: Scalars["String"]["output"];
+  drillId?: Maybe<Scalars["String"]["output"]>;
+  evidence: SessionCoachEvidenceGql;
+  family: SessionCoachCandidateFamilyEnum;
+  id: Scalars["ID"]["output"];
+  kind: SessionCoachCandidateKindEnum;
+  limitations: Array<Scalars["String"]["output"]>;
+  rank: Scalars["Int"]["output"];
+  supportingShotIds: Array<Scalars["Int"]["output"]>;
+  title: Scalars["String"]["output"];
+};
+
+export enum SessionCoachCandidateKindEnum {
+  DirectionalMiss = "DIRECTIONAL_MISS",
+  OutcomePattern = "OUTCOME_PATTERN",
+  UsagePattern = "USAGE_PATTERN",
+}
+
+export type SessionCoachEvidenceGql = {
+  __typename?: "SessionCoachEvidenceGQL";
+  attemptCount: Scalars["Int"]["output"];
+  bucketKey: Scalars["String"]["output"];
+  bucketLabel: Scalars["String"]["output"];
+  comparisonAttemptCount: Scalars["Int"]["output"];
+  comparisonMadeCount: Scalars["Int"]["output"];
+  comparisonMakePercentage?: Maybe<Scalars["Float"]["output"]>;
+  madeCount: Scalars["Int"]["output"];
+  makePercentage: Scalars["Float"]["output"];
+  missedCount: Scalars["Int"]["output"];
+  patternShotCount: Scalars["Int"]["output"];
+  rankReason: Scalars["String"]["output"];
+  score: Scalars["Float"]["output"];
+};
+
+export type SessionCoachGql = {
+  __typename?: "SessionCoachGQL";
+  analysisVersion: Scalars["String"]["output"];
+  analyzedShotCount: Scalars["Int"]["output"];
+  candidates: Array<SessionCoachCandidateGql>;
+  generatedAt: Scalars["DateTime"]["output"];
+  ineligibilityReason?: Maybe<SessionCoachIneligibilityReasonEnum>;
+  madeCount: Scalars["Int"]["output"];
+  makePercentage?: Maybe<Scalars["Float"]["output"]>;
+  missedCount: Scalars["Int"]["output"];
+  primaryCandidate?: Maybe<SessionCoachCandidateGql>;
+  processingId?: Maybe<Scalars["Int"]["output"]>;
+  processingStatus?: Maybe<Scalars["String"]["output"]>;
+  shotCount: Scalars["Int"]["output"];
+  state: SessionCoachStateEnum;
+  summary?: Maybe<Scalars["String"]["output"]>;
+  unknownOutcomeCount: Scalars["Int"]["output"];
+  videoId: Scalars["Int"]["output"];
+};
+
+export enum SessionCoachIneligibilityReasonEnum {
+  Multiplayer = "MULTIPLAYER",
+}
+
+export enum SessionCoachStateEnum {
+  Failed = "FAILED",
+  Ineligible = "INELIGIBLE",
+  NoTrackedShots = "NO_TRACKED_SHOTS",
+  Processing = "PROCESSING",
+  Ready = "READY",
+}
+
 export type ShotAnnotationGql = {
   __typename?: "ShotAnnotationGQL";
   createdAt?: Maybe<Scalars["DateTime"]["output"]>;
@@ -4195,6 +4283,7 @@ export type VideoMetadataInput = {
   framesPerSecond?: InputMaybe<Scalars["Float"]["input"]>;
   /** @deprecated `game_type` is deprecated. Use `tags` instead. */
   gameType?: InputMaybe<Scalars["String"]["input"]>;
+  homographyBackend?: InputMaybe<HomographyBackendGql>;
   lastIntendedSegmentBound?: InputMaybe<Scalars["Int"]["input"]>;
   pocketSize?: InputMaybe<Scalars["Float"]["input"]>;
   private?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -4784,6 +4873,7 @@ export type GetFeedQuery = {
         __typename?: "UploadStreamGQL";
         id: string;
         lastIntendedSegmentBound?: number | null;
+        uploadCompletionCursor: number;
         streamSegmentType: StreamSegmentTypeEnum;
         isCompleted: boolean;
         lastSegmentUploadedAt?: any | null;
@@ -4898,6 +4988,7 @@ export type VideoCardFieldsFragment = {
     __typename?: "UploadStreamGQL";
     id: string;
     lastIntendedSegmentBound?: number | null;
+    uploadCompletionCursor: number;
     streamSegmentType: StreamSegmentTypeEnum;
     isCompleted: boolean;
     lastSegmentUploadedAt?: any | null;
@@ -5045,6 +5136,7 @@ export type GetVideoFeedQuery = {
         __typename?: "UploadStreamGQL";
         id: string;
         lastIntendedSegmentBound?: number | null;
+        uploadCompletionCursor: number;
         streamSegmentType: StreamSegmentTypeEnum;
         isCompleted: boolean;
         lastSegmentUploadedAt?: any | null;
@@ -6616,6 +6708,79 @@ export type ReactToVideoMutation = {
   reactToVideo: boolean;
 };
 
+export type GetRecordedStreamsQueryVariables = Exact<{
+  limit?: Scalars["Int"]["input"];
+}>;
+
+export type GetRecordedStreamsQuery = {
+  __typename?: "Query";
+  getFeedVideos: {
+    __typename?: "VideoHistoryGQL";
+    videos: Array<{
+      __typename?: "VideoGQL";
+      id: number;
+      name?: string | null;
+      createdAt?: any | null;
+      screenshotUri?: string | null;
+      framesPerSecond: number;
+      totalShots: number;
+      owner?: {
+        __typename?: "UserGQL";
+        id: number;
+        username: string;
+        profileImageUri?: string | null;
+      } | null;
+    }>;
+  };
+};
+
+export type GetRecordedStreamShotsQueryVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+  limit?: Scalars["Int"]["input"];
+}>;
+
+export type GetRecordedStreamShotsQuery = {
+  __typename?: "Query";
+  getOrderedShots: {
+    __typename?: "GetShotsResult";
+    shots: Array<{
+      __typename?: "ShotGQL";
+      id: number;
+      videoId: number;
+      startFrame: number;
+      endFrame: number;
+      serializedShotPaths?: {
+        __typename?: "SerializedShotPathsGQL";
+        b64EncodedBuffer?: string | null;
+      } | null;
+      cueObjectFeatures?: {
+        __typename?: "CueObjectFeaturesGQL";
+        cueObjectDistance?: number | null;
+        cueObjectAngle?: number | null;
+        cueBallSpeed?: number | null;
+        shotDirection?: ShotDirectionEnum | null;
+        spinType?: SpinTypeEnum | null;
+      } | null;
+      pocketingIntentionFeatures?: {
+        __typename?: "PocketingIntentionFeaturesGQL";
+        make?: boolean | null;
+        targetPocketDistance?: number | null;
+        targetPocketAngle?: number | null;
+        targetPocketAngleDirection?: ShotDirectionEnum | null;
+        marginOfErrorInDegrees?: number | null;
+        intendedPocketType?: PocketEnum | null;
+        difficulty?: number | null;
+      } | null;
+      pocketingIntentionInfo?: {
+        __typename?: "PocketingIntentionInfoGQL";
+        ballId: number;
+        pocketId: PocketIdentifier;
+        pathMetadataIndex: number;
+      } | null;
+    }>;
+  };
+};
+
 export type GetRunsForHighlightsQueryVariables = Exact<{
   filterInput: RunFilterInput;
   runIds?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
@@ -6690,6 +6855,116 @@ export type GetRunsWithTimestampsQuery = {
   };
 };
 
+export type GetSessionCoachQueryVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type GetSessionCoachQuery = {
+  __typename?: "Query";
+  getSessionCoach: {
+    __typename?: "SessionCoachGQL";
+    videoId: number;
+    processingId?: number | null;
+    analysisVersion: string;
+    state: SessionCoachStateEnum;
+    generatedAt: any;
+    processingStatus?: string | null;
+    ineligibilityReason?: SessionCoachIneligibilityReasonEnum | null;
+    summary?: string | null;
+    shotCount: number;
+    madeCount: number;
+    missedCount: number;
+    unknownOutcomeCount: number;
+    analyzedShotCount: number;
+    makePercentage?: number | null;
+    primaryCandidate?: {
+      __typename?: "SessionCoachCandidateGQL";
+      id: string;
+      rank: number;
+      family: SessionCoachCandidateFamilyEnum;
+      kind: SessionCoachCandidateKindEnum;
+      title: string;
+      body: string;
+      action: string;
+      supportingShotIds: Array<number>;
+      drillId?: string | null;
+      limitations: Array<string>;
+      evidence: {
+        __typename?: "SessionCoachEvidenceGQL";
+        bucketKey: string;
+        bucketLabel: string;
+        attemptCount: number;
+        madeCount: number;
+        missedCount: number;
+        makePercentage: number;
+        comparisonAttemptCount: number;
+        comparisonMadeCount: number;
+        comparisonMakePercentage?: number | null;
+        patternShotCount: number;
+        score: number;
+        rankReason: string;
+      };
+    } | null;
+    candidates: Array<{
+      __typename?: "SessionCoachCandidateGQL";
+      id: string;
+      rank: number;
+      family: SessionCoachCandidateFamilyEnum;
+      kind: SessionCoachCandidateKindEnum;
+      title: string;
+      body: string;
+      action: string;
+      supportingShotIds: Array<number>;
+      drillId?: string | null;
+      limitations: Array<string>;
+      evidence: {
+        __typename?: "SessionCoachEvidenceGQL";
+        bucketKey: string;
+        bucketLabel: string;
+        attemptCount: number;
+        madeCount: number;
+        missedCount: number;
+        makePercentage: number;
+        comparisonAttemptCount: number;
+        comparisonMadeCount: number;
+        comparisonMakePercentage?: number | null;
+        patternShotCount: number;
+        score: number;
+        rankReason: string;
+      };
+    }>;
+  };
+};
+
+export type SessionCoachCandidateFieldsFragment = {
+  __typename?: "SessionCoachCandidateGQL";
+  id: string;
+  rank: number;
+  family: SessionCoachCandidateFamilyEnum;
+  kind: SessionCoachCandidateKindEnum;
+  title: string;
+  body: string;
+  action: string;
+  supportingShotIds: Array<number>;
+  drillId?: string | null;
+  limitations: Array<string>;
+  evidence: {
+    __typename?: "SessionCoachEvidenceGQL";
+    bucketKey: string;
+    bucketLabel: string;
+    attemptCount: number;
+    madeCount: number;
+    missedCount: number;
+    makePercentage: number;
+    comparisonAttemptCount: number;
+    comparisonMadeCount: number;
+    comparisonMakePercentage?: number | null;
+    patternShotCount: number;
+    score: number;
+    rankReason: string;
+  };
+};
+
 export type PlayerSummaryFieldsFragment = {
   __typename?: "PlayerSummaryGQL";
   clusterId: number;
@@ -6847,34 +7122,28 @@ export type GetLiveTableStateQuery = {
         __typename?: "RGBColorGQL";
         hex: string;
       } | null>;
-      homography?: {
-        __typename?: "HomographyInfoGQL";
-        id?: number | null;
-        frameIndex: number;
-        crop: {
-          __typename?: "BoundingBoxGQL";
-          left: number;
-          top: number;
-          width: number;
-          height: number;
-        };
-        pockets: Array<{
-          __typename?: "BoundingBoxGQL";
-          left: number;
-          top: number;
-          width: number;
-          height: number;
-        }>;
-        sourcePoints: {
-          __typename?: "PocketPointsGQL";
-          topLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-          topSide: { __typename?: "IntPoint2D"; x: number; y: number };
-          topRight: { __typename?: "IntPoint2D"; x: number; y: number };
-          bottomLeft: { __typename?: "IntPoint2D"; x: number; y: number };
-          bottomSide: { __typename?: "IntPoint2D"; x: number; y: number };
-          bottomRight: { __typename?: "IntPoint2D"; x: number; y: number };
-        };
-      } | null;
+    };
+  };
+};
+
+export type GetShotTableStateQueryVariables = Exact<{
+  shotId: Scalars["Int"]["input"];
+}>;
+
+export type GetShotTableStateQuery = {
+  __typename?: "Query";
+  getShotTableState: {
+    __typename?: "ShotTableStateGQL";
+    shotId: number;
+    videoId: number;
+    frameIndex: number;
+    tableState: {
+      __typename?: "TableStateGQL";
+      identifierToPosition: Array<Array<number>>;
+      identifierToColor: Array<{
+        __typename?: "RGBColorGQL";
+        hex: string;
+      } | null>;
     };
   };
 };
@@ -8126,6 +8395,7 @@ export type GetVideoCardQuery = {
       __typename?: "UploadStreamGQL";
       id: string;
       lastIntendedSegmentBound?: number | null;
+      uploadCompletionCursor: number;
       streamSegmentType: StreamSegmentTypeEnum;
       isCompleted: boolean;
       lastSegmentUploadedAt?: any | null;
@@ -8953,6 +9223,7 @@ export const VideoCardFieldsFragmentDoc = gql`
     stream {
       id
       lastIntendedSegmentBound
+      uploadCompletionCursor
       streamSegmentType
       isCompleted
       lastSegmentUploadedAt
@@ -9140,6 +9411,34 @@ export const PocketingIntentionFragmentFragmentDoc = gql`
     difficulty
   }
 `;
+export const SessionCoachCandidateFieldsFragmentDoc = gql`
+  fragment SessionCoachCandidateFields on SessionCoachCandidateGQL {
+    id
+    rank
+    family
+    kind
+    title
+    body
+    action
+    supportingShotIds
+    drillId
+    limitations
+    evidence {
+      bucketKey
+      bucketLabel
+      attemptCount
+      madeCount
+      missedCount
+      makePercentage
+      comparisonAttemptCount
+      comparisonMadeCount
+      comparisonMakePercentage
+      patternShotCount
+      score
+      rankReason
+    }
+  }
+`;
 export const PlayerClusterShotFieldsFragmentDoc = gql`
   fragment PlayerClusterShotFields on PlayerClusterShotGQL {
     shotId
@@ -14232,6 +14531,203 @@ export type ReactToVideoMutationOptions = Apollo.BaseMutationOptions<
   ReactToVideoMutation,
   ReactToVideoMutationVariables
 >;
+export const GetRecordedStreamsDocument = gql`
+  query GetRecordedStreams($limit: Int! = 25) {
+    getFeedVideos(
+      limit: $limit
+      filters: { isStreamCompleted: true, excludeVideosWithNoShots: true }
+      includePrivate: MINE
+      feedInput: { allUsers: true }
+    ) {
+      videos {
+        id
+        name
+        createdAt
+        screenshotUri
+        framesPerSecond
+        totalShots
+        owner {
+          id
+          username
+          profileImageUri
+        }
+      }
+    }
+  }
+`;
+
+/**
+ * __useGetRecordedStreamsQuery__
+ *
+ * To run a query within a React component, call `useGetRecordedStreamsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRecordedStreamsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRecordedStreamsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetRecordedStreamsQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >(GetRecordedStreamsDocument, options);
+}
+export function useGetRecordedStreamsLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >(GetRecordedStreamsDocument, options);
+}
+export function useGetRecordedStreamsSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetRecordedStreamsQuery,
+    GetRecordedStreamsQueryVariables
+  >(GetRecordedStreamsDocument, options);
+}
+export type GetRecordedStreamsQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamsQuery
+>;
+export type GetRecordedStreamsLazyQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamsLazyQuery
+>;
+export type GetRecordedStreamsSuspenseQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamsSuspenseQuery
+>;
+export type GetRecordedStreamsQueryResult = Apollo.QueryResult<
+  GetRecordedStreamsQuery,
+  GetRecordedStreamsQueryVariables
+>;
+export const GetRecordedStreamShotsDocument = gql`
+  query GetRecordedStreamShots($videoId: Int!, $limit: Int! = 200) {
+    getOrderedShots(
+      filterInput: { videoId: [$videoId] }
+      shotsOrdering: { orderings: [{ startFrame: { descending: false } }] }
+      limit: $limit
+    ) {
+      shots {
+        id
+        videoId
+        startFrame
+        endFrame
+        serializedShotPaths {
+          b64EncodedBuffer
+        }
+        cueObjectFeatures {
+          cueObjectDistance
+          cueObjectAngle
+          cueBallSpeed
+          shotDirection
+          spinType
+        }
+        pocketingIntentionFeatures {
+          make
+          targetPocketDistance
+          targetPocketAngle
+          targetPocketAngleDirection
+          marginOfErrorInDegrees
+          intendedPocketType
+          difficulty
+        }
+        pocketingIntentionInfo {
+          ballId
+          pocketId
+          pathMetadataIndex
+        }
+      }
+    }
+  }
+`;
+
+/**
+ * __useGetRecordedStreamShotsQuery__
+ *
+ * To run a query within a React component, call `useGetRecordedStreamShotsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRecordedStreamShotsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRecordedStreamShotsQuery({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetRecordedStreamShotsQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >(GetRecordedStreamShotsDocument, options);
+}
+export function useGetRecordedStreamShotsLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >(GetRecordedStreamShotsDocument, options);
+}
+export function useGetRecordedStreamShotsSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetRecordedStreamShotsQuery,
+    GetRecordedStreamShotsQueryVariables
+  >(GetRecordedStreamShotsDocument, options);
+}
+export type GetRecordedStreamShotsQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamShotsQuery
+>;
+export type GetRecordedStreamShotsLazyQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamShotsLazyQuery
+>;
+export type GetRecordedStreamShotsSuspenseQueryHookResult = ReturnType<
+  typeof useGetRecordedStreamShotsSuspenseQuery
+>;
+export type GetRecordedStreamShotsQueryResult = Apollo.QueryResult<
+  GetRecordedStreamShotsQuery,
+  GetRecordedStreamShotsQueryVariables
+>;
 export const GetRunsForHighlightsDocument = gql`
   query GetRunsForHighlights(
     $filterInput: RunFilterInput!
@@ -14431,6 +14927,99 @@ export type GetRunsWithTimestampsQueryResult = Apollo.QueryResult<
   GetRunsWithTimestampsQuery,
   GetRunsWithTimestampsQueryVariables
 >;
+export const GetSessionCoachDocument = gql`
+  query GetSessionCoach($videoId: Int!) {
+    getSessionCoach(videoId: $videoId) {
+      videoId
+      processingId
+      analysisVersion
+      state
+      generatedAt
+      processingStatus
+      ineligibilityReason
+      summary
+      shotCount
+      madeCount
+      missedCount
+      unknownOutcomeCount
+      analyzedShotCount
+      makePercentage
+      primaryCandidate {
+        ...SessionCoachCandidateFields
+      }
+      candidates {
+        ...SessionCoachCandidateFields
+      }
+    }
+  }
+  ${SessionCoachCandidateFieldsFragmentDoc}
+`;
+
+/**
+ * __useGetSessionCoachQuery__
+ *
+ * To run a query within a React component, call `useGetSessionCoachQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSessionCoachQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetSessionCoachQuery({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useGetSessionCoachQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetSessionCoachQuery, GetSessionCoachQueryVariables>(
+    GetSessionCoachDocument,
+    options,
+  );
+}
+export function useGetSessionCoachLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >(GetSessionCoachDocument, options);
+}
+export function useGetSessionCoachSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetSessionCoachQuery,
+    GetSessionCoachQueryVariables
+  >(GetSessionCoachDocument, options);
+}
+export type GetSessionCoachQueryHookResult = ReturnType<
+  typeof useGetSessionCoachQuery
+>;
+export type GetSessionCoachLazyQueryHookResult = ReturnType<
+  typeof useGetSessionCoachLazyQuery
+>;
+export type GetSessionCoachSuspenseQueryHookResult = ReturnType<
+  typeof useGetSessionCoachSuspenseQuery
+>;
+export type GetSessionCoachQueryResult = Apollo.QueryResult<
+  GetSessionCoachQuery,
+  GetSessionCoachQueryVariables
+>;
 export const VideoPlayerClustersDocument = gql`
   query VideoPlayerClusters($videoId: Int!) {
     videoPlayerClusters(videoId: $videoId) {
@@ -14653,13 +15242,9 @@ export const GetLiveTableStateDocument = gql`
         identifierToColor {
           hex
         }
-        homography {
-          ...HomographyInfo
-        }
       }
     }
   }
-  ${HomographyInfoFragmentDoc}
 `;
 
 /**
@@ -14727,6 +15312,87 @@ export type GetLiveTableStateQueryResult = Apollo.QueryResult<
   GetLiveTableStateQuery,
   GetLiveTableStateQueryVariables
 >;
+export const GetShotTableStateDocument = gql`
+  query GetShotTableState($shotId: Int!) {
+    getShotTableState(shotId: $shotId) {
+      shotId
+      videoId
+      frameIndex
+      tableState {
+        identifierToPosition
+        identifierToColor {
+          hex
+        }
+      }
+    }
+  }
+`;
+
+/**
+ * __useGetShotTableStateQuery__
+ *
+ * To run a query within a React component, call `useGetShotTableStateQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetShotTableStateQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetShotTableStateQuery({
+ *   variables: {
+ *      shotId: // value for 'shotId'
+ *   },
+ * });
+ */
+export function useGetShotTableStateQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >(GetShotTableStateDocument, options);
+}
+export function useGetShotTableStateLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >(GetShotTableStateDocument, options);
+}
+export function useGetShotTableStateSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetShotTableStateQuery,
+    GetShotTableStateQueryVariables
+  >(GetShotTableStateDocument, options);
+}
+export type GetShotTableStateQueryHookResult = ReturnType<
+  typeof useGetShotTableStateQuery
+>;
+export type GetShotTableStateLazyQueryHookResult = ReturnType<
+  typeof useGetShotTableStateLazyQuery
+>;
+export type GetShotTableStateSuspenseQueryHookResult = ReturnType<
+  typeof useGetShotTableStateSuspenseQuery
+>;
+export type GetShotTableStateQueryResult = Apollo.QueryResult<
+  GetShotTableStateQuery,
+  GetShotTableStateQueryVariables
+>;
 export const SimulateShotDocument = gql`
   query SimulateShot($simulationInput: SimulateShotInputGQL!) {
     simulateShot(simulationInput: $simulationInput) {

src/operations/feed.gql

@@ -41,6 +41,7 @@ fragment VideoCardFields on VideoGQL {
   stream {
     id
     lastIntendedSegmentBound
+    uploadCompletionCursor
     streamSegmentType
     isCompleted
     lastSegmentUploadedAt

src/operations/recorded_shots.gql

@@ -0,0 +1,62 @@
+# Lightweight two-step picker data for loading a recorded shot into Shot Lab.
+query GetRecordedStreams($limit: Int! = 25) {
+  getFeedVideos(
+    limit: $limit
+    filters: { isStreamCompleted: true, excludeVideosWithNoShots: true }
+    includePrivate: MINE
+    feedInput: { allUsers: true }
+  ) {
+    videos {
+      id
+      name
+      createdAt
+      screenshotUri
+      framesPerSecond
+      totalShots
+      owner {
+        id
+        username
+        profileImageUri
+      }
+    }
+  }
+}
+
+query GetRecordedStreamShots($videoId: Int!, $limit: Int! = 200) {
+  getOrderedShots(
+    filterInput: { videoId: [$videoId] }
+    shotsOrdering: { orderings: [{ startFrame: { descending: false } }] }
+    limit: $limit
+  ) {
+    shots {
+      id
+      videoId
+      startFrame
+      endFrame
+      serializedShotPaths {
+        b64EncodedBuffer
+      }
+      cueObjectFeatures {
+        cueObjectDistance
+        cueObjectAngle
+        cueBallSpeed
+        shotDirection
+        spinType
+      }
+      pocketingIntentionFeatures {
+        make
+        targetPocketDistance
+        targetPocketAngle
+        targetPocketAngleDirection
+        marginOfErrorInDegrees
+        intendedPocketType
+        difficulty
+      }
+      pocketingIntentionInfo {
+        ballId
+        pocketId
+        pathMetadataIndex
+      }
+    }
+  }
+}

src/operations/session-coach.gql

@@ -0,0 +1,51 @@
+query GetSessionCoach($videoId: Int!) {
+  getSessionCoach(videoId: $videoId) {
+    videoId
+    processingId
+    analysisVersion
+    state
+    generatedAt
+    processingStatus
+    ineligibilityReason
+    summary
+    shotCount
+    madeCount
+    missedCount
+    unknownOutcomeCount
+    analyzedShotCount
+    makePercentage
+    primaryCandidate {
+      ...SessionCoachCandidateFields
+    }
+    candidates {
+      ...SessionCoachCandidateFields
+    }
+  }
+}
+
+fragment SessionCoachCandidateFields on SessionCoachCandidateGQL {
+  id
+  rank
+  family
+  kind
+  title
+  body
+  action
+  supportingShotIds
+  drillId
+  limitations
+  evidence {
+    bucketKey
+    bucketLabel
+    attemptCount
+    madeCount
+    missedCount
+    makePercentage
+    comparisonAttemptCount
+    comparisonMadeCount
+    comparisonMakePercentage
+    patternShotCount
+    score
+    rankReason
+  }
+}

src/operations/shot_simulation.gql

@@ -24,8 +24,19 @@ query GetLiveTableState($videoId: Int!) {
       identifierToColor {
         hex
       }
-      homography {
-        ...HomographyInfo
+    }
+  }
+}
+
+query GetShotTableState($shotId: Int!) {
+  getShotTableState(shotId: $shotId) {
+    shotId
+    videoId
+    frameIndex
+    tableState {
+      identifierToPosition
+      identifierToColor {
+        hex
       }
     }
   }