Add client side start and end time

Reviewed-on: #76
Reviewed-by: Ivan Malison <ivanmalison@gmail.com>

codegen.yml

@@ -1,5 +1,7 @@
 overwrite: true
-schema: "src/schema.gql"
+schema:
+  - "src/schema.gql"
+  - "src/client-schema.gql"
 documents: "src/**/*.gql"
 generates:
   src/index.tsx:

src/client-schema.gql

@@ -0,0 +1,7 @@
+# see: https://www.apollographql.com/docs/react/local-state/managing-state-with-field-policies/
+directive @client on FIELD
+
+extend type ShotGQL {
+  startTime: Float!
+  endTime: Float!
+}

src/index.tsx

@@ -1747,6 +1747,7 @@ export type Mutation = {
   getUploadLink: GetUploadLinkReturn;
   setLoggerLevel: Scalars["Boolean"]["output"];
   setSegmentDuration: Scalars["Boolean"]["output"];
+  updateShotAnnotations: UpdateShotAnnotationReturn;
 };
 
 export type MutationAddAnnotationToShotArgs = {
@@ -1800,6 +1801,11 @@ export type MutationSetSegmentDurationArgs = {
   videoId: Scalars["Int"]["input"];
 };
 
+export type MutationUpdateShotAnnotationsArgs = {
+  annotations: Array<UpdateAnnotationInputGql>;
+  shotId: Scalars["Int"]["input"];
+};
+
 export type NoInitForChunkedUploadErr = {
   __typename?: "NoInitForChunkedUploadErr";
   segmentType: StreamSegmentTypeEnum;
@@ -2015,12 +2021,14 @@ export type ShotGql = {
   createdAt?: Maybe<Scalars["DateTime"]["output"]>;
   cueObjectFeatures?: Maybe<CueObjectFeaturesGql>;
   endFrame: Scalars["Int"]["output"];
+  endTime: Scalars["Float"]["output"];
   falsePositiveScore?: Maybe<Scalars["Float"]["output"]>;
   id: Scalars["Int"]["output"];
   pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
   pocketingIntentionInfo?: Maybe<PocketingIntentionInfoGql>;
   serializedShotPaths?: Maybe<SerializedShotPathsGql>;
   startFrame: Scalars["Int"]["output"];
+  startTime: Scalars["Float"]["output"];
   updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
   user?: Maybe<UserGql>;
   video?: Maybe<VideoGql>;
@@ -2061,6 +2069,15 @@ export type SuccessfulAddAddShotAnnotationErrors =
   | AddShotAnnotationErrors
   | SuccessfulAdd;
 
+export type SuccessfulUpdate = {
+  __typename?: "SuccessfulUpdate";
+  value: Scalars["Boolean"]["output"];
+};
+
+export type SuccessfulUpdateUpdateShotAnnotationErrors =
+  | SuccessfulUpdate
+  | UpdateShotAnnotationErrors;
+
 export type TagGql = {
   __typename?: "TagGQL";
   group?: Maybe<Scalars["String"]["output"]>;
@@ -2098,6 +2115,21 @@ export type TooManyProfileImageUploadsErr = {
   linksRequested: Scalars["Int"]["output"];
 };
 
+export type UpdateAnnotationInputGql = {
+  name: Scalars["String"]["input"];
+  notes?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type UpdateShotAnnotationErrors = {
+  __typename?: "UpdateShotAnnotationErrors";
+  error?: Maybe<DoesNotOwnShotErr>;
+};
+
+export type UpdateShotAnnotationReturn = {
+  __typename?: "UpdateShotAnnotationReturn";
+  value: SuccessfulUpdateUpdateShotAnnotationErrors;
+};
+
 export type UploadLink = {
   __typename?: "UploadLink";
   headers: Array<Maybe<Header>>;
@@ -2424,6 +2456,74 @@ export type GetShotsWithVideoGqlQuery = {
   };
 };
 
+export type GetShotsWithMetadataFilterResultQueryVariables = Exact<{
+  filterInput: FilterInput;
+  shotsPagination?: InputMaybe<GetShotsPagination>;
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
+}>;
+
+export type GetShotsWithMetadataFilterResultQuery = {
+  __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;
+      video?: {
+        __typename?: "VideoGQL";
+        id: number;
+        stream?: {
+          __typename?: "UploadStreamGQL";
+          resolution: {
+            __typename?: "VideoResolutionGQL";
+            width?: number | null;
+            height?: number | null;
+          };
+        } | 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;
+      } | null;
+      pocketingIntentionInfo?: {
+        __typename?: "PocketingIntentionInfoGQL";
+        ballId: number;
+        pocketId: PocketIdentifier;
+        pathMetadataIndex: number;
+      } | null;
+      serializedShotPaths?: {
+        __typename?: "SerializedShotPathsGQL";
+        b64EncodedBuffer?: string | null;
+      } | null;
+    }>;
+  };
+};
+
 export type GetShotsWithMetadataQueryVariables = Exact<{
   filterInput: FilterInput;
   shotsPagination?: InputMaybe<GetShotsPagination>;
@@ -2443,12 +2543,15 @@ export type GetShotsWithMetadataQuery = {
       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;
       video?: {
         __typename?: "VideoGQL";
+        id: number;
         stream?: {
           __typename?: "UploadStreamGQL";
           resolution: {
@@ -2501,12 +2604,15 @@ export type GetShotsByIdsQuery = {
     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;
     video?: {
       __typename?: "VideoGQL";
+      id: number;
       stream?: {
         __typename?: "UploadStreamGQL";
         resolution: {
@@ -2552,12 +2658,15 @@ export type ShotWithAllFeaturesFragment = {
   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;
   video?: {
     __typename?: "VideoGQL";
+    id: number;
     stream?: {
       __typename?: "UploadStreamGQL";
       resolution: {
@@ -2844,6 +2953,59 @@ export type GetVideosQuery = {
   }>;
 };
 
+export type VideoStreamMetadataFragment = {
+  __typename?: "VideoGQL";
+  id: number;
+  framesPerSecond: number;
+  stream?: {
+    __typename?: "UploadStreamGQL";
+    id: string;
+    streamSegmentType: StreamSegmentTypeEnum;
+    segments: Array<{
+      __typename?: "UploadSegmentGQL";
+      uploaded: boolean;
+      valid: boolean;
+      segmentIndex: number;
+      endFrameIndex?: number | null;
+      framesPerSecond?: number | null;
+    }>;
+  } | null;
+  playlist?: {
+    __typename?: "HLSPlaylistGQL";
+    segmentDurations: Array<number>;
+  } | null;
+};
+
+export type GetVideoForShotTimeQueryVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type GetVideoForShotTimeQuery = {
+  __typename?: "Query";
+  getVideo: {
+    __typename?: "VideoGQL";
+    id: number;
+    framesPerSecond: number;
+    stream?: {
+      __typename?: "UploadStreamGQL";
+      id: string;
+      streamSegmentType: StreamSegmentTypeEnum;
+      segments: Array<{
+        __typename?: "UploadSegmentGQL";
+        uploaded: boolean;
+        valid: boolean;
+        segmentIndex: number;
+        endFrameIndex?: number | null;
+        framesPerSecond?: number | null;
+      }>;
+    } | null;
+    playlist?: {
+      __typename?: "HLSPlaylistGQL";
+      segmentDurations: Array<number>;
+    } | null;
+  };
+};
+
 export type GetVideoQueryVariables = Exact<{
   videoId: Scalars["Int"]["input"];
 }>;
@@ -2967,6 +3129,20 @@ export type GetVideoForClipTimesQuery = {
   };
 };
 
+export type GetHeaderInfoByVideoIdQueryVariables = Exact<{
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type GetHeaderInfoByVideoIdQuery = {
+  __typename?: "Query";
+  getVideo: {
+    __typename?: "VideoGQL";
+    id: number;
+    name?: string | null;
+    startTime?: any | null;
+  };
+};
+
 export type CreateUploadStreamMutationVariables = Exact<{
   videoMetadataInput: VideoMetadataInput;
 }>;
@@ -3145,11 +3321,14 @@ export const ShotWithAllFeaturesFragmentDoc = gql`
     videoId
     startFrame
     endFrame
+    startTime @client
+    endTime @client
     user {
       id
     }
     falsePositiveScore
     video {
+      id
       stream {
         resolution {
           width
@@ -3184,6 +3363,26 @@ export const ShotWithAllFeaturesFragmentDoc = gql`
     }
   }
 `;
+export const VideoStreamMetadataFragmentDoc = gql`
+  fragment VideoStreamMetadata on VideoGQL {
+    id
+    framesPerSecond
+    stream {
+      id
+      streamSegmentType
+      segments {
+        uploaded
+        valid
+        segmentIndex
+        endFrameIndex
+        framesPerSecond
+      }
+    }
+    playlist {
+      segmentDurations
+    }
+  }
+`;
 export const GetAggregatedShotMetricsDocument = gql`
   query GetAggregatedShotMetrics($aggregateInput: AggregateInputGQL!) {
     getAggregatedShotMetrics(aggregateInput: $aggregateInput) {
@@ -3757,6 +3956,96 @@ export type GetShotsWithVideoGqlQueryResult = Apollo.QueryResult<
   GetShotsWithVideoGqlQuery,
   GetShotsWithVideoGqlQueryVariables
 >;
+export const GetShotsWithMetadataFilterResultDocument = gql`
+  query GetShotsWithMetadataFilterResult(
+    $filterInput: FilterInput!
+    $shotsPagination: GetShotsPagination
+    $limit: Int
+    $ids: [Int!]
+  ) {
+    getShotsWithMetadata(
+      filterInput: $filterInput
+      shotsPagination: $shotsPagination
+      limit: $limit
+      ids: $ids
+    ) {
+      count
+      shots {
+        ...ShotWithAllFeatures
+      }
+      ids
+    }
+  }
+  ${ShotWithAllFeaturesFragmentDoc}
+`;
+
+/**
+ * __useGetShotsWithMetadataFilterResultQuery__
+ *
+ * To run a query within a React component, call `useGetShotsWithMetadataFilterResultQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetShotsWithMetadataFilterResultQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetShotsWithMetadataFilterResultQuery({
+ *   variables: {
+ *      filterInput: // value for 'filterInput'
+ *      shotsPagination: // value for 'shotsPagination'
+ *      limit: // value for 'limit'
+ *      ids: // value for 'ids'
+ *   },
+ * });
+ */
+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!
@@ -4709,24 +4998,10 @@ export type GetVideoDetailsQueryResult = Apollo.QueryResult<
 export const GetVideosDocument = gql`
   query GetVideos($videoIds: [Int!]!) {
     getVideos(videoIds: $videoIds) {
-      id
-      framesPerSecond
-      stream {
-        id
-        streamSegmentType
-        segments {
-          uploaded
-          valid
-          segmentIndex
-          endFrameIndex
-          framesPerSecond
-        }
-      }
-      playlist {
-        segmentDurations
-      }
+      ...VideoStreamMetadata
     }
   }
+  ${VideoStreamMetadataFragmentDoc}
 `;
 
 /**
@@ -4789,6 +5064,80 @@ export type GetVideosQueryResult = Apollo.QueryResult<
   GetVideosQuery,
   GetVideosQueryVariables
 >;
+export const GetVideoForShotTimeDocument = gql`
+  query GetVideoForShotTime($videoId: Int!) {
+    getVideo(videoId: $videoId) {
+      ...VideoStreamMetadata
+    }
+  }
+  ${VideoStreamMetadataFragmentDoc}
+`;
+
+/**
+ * __useGetVideoForShotTimeQuery__
+ *
+ * To run a query within a React component, call `useGetVideoForShotTimeQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVideoForShotTimeQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetVideoForShotTimeQuery({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useGetVideoForShotTimeQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >(GetVideoForShotTimeDocument, options);
+}
+export function useGetVideoForShotTimeLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >(GetVideoForShotTimeDocument, options);
+}
+export function useGetVideoForShotTimeSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetVideoForShotTimeQuery,
+    GetVideoForShotTimeQueryVariables
+  >(GetVideoForShotTimeDocument, options);
+}
+export type GetVideoForShotTimeQueryHookResult = ReturnType<
+  typeof useGetVideoForShotTimeQuery
+>;
+export type GetVideoForShotTimeLazyQueryHookResult = ReturnType<
+  typeof useGetVideoForShotTimeLazyQuery
+>;
+export type GetVideoForShotTimeSuspenseQueryHookResult = ReturnType<
+  typeof useGetVideoForShotTimeSuspenseQuery
+>;
+export type GetVideoForShotTimeQueryResult = Apollo.QueryResult<
+  GetVideoForShotTimeQuery,
+  GetVideoForShotTimeQueryVariables
+>;
 export const GetVideoDocument = gql`
   query GetVideo($videoId: Int!) {
     getVideo(videoId: $videoId) {
@@ -5223,6 +5572,81 @@ export type GetVideoForClipTimesQueryResult = Apollo.QueryResult<
   GetVideoForClipTimesQuery,
   GetVideoForClipTimesQueryVariables
 >;
+export const GetHeaderInfoByVideoIdDocument = gql`
+  query GetHeaderInfoByVideoId($videoId: Int!) {
+    getVideo(videoId: $videoId) {
+      id
+      name
+      startTime
+    }
+  }
+`;
+
+/**
+ * __useGetHeaderInfoByVideoIdQuery__
+ *
+ * To run a query within a React component, call `useGetHeaderInfoByVideoIdQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetHeaderInfoByVideoIdQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetHeaderInfoByVideoIdQuery({
+ *   variables: {
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useGetHeaderInfoByVideoIdQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >(GetHeaderInfoByVideoIdDocument, options);
+}
+export function useGetHeaderInfoByVideoIdLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >(GetHeaderInfoByVideoIdDocument, options);
+}
+export function useGetHeaderInfoByVideoIdSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetHeaderInfoByVideoIdQuery,
+    GetHeaderInfoByVideoIdQueryVariables
+  >(GetHeaderInfoByVideoIdDocument, options);
+}
+export type GetHeaderInfoByVideoIdQueryHookResult = ReturnType<
+  typeof useGetHeaderInfoByVideoIdQuery
+>;
+export type GetHeaderInfoByVideoIdLazyQueryHookResult = ReturnType<
+  typeof useGetHeaderInfoByVideoIdLazyQuery
+>;
+export type GetHeaderInfoByVideoIdSuspenseQueryHookResult = ReturnType<
+  typeof useGetHeaderInfoByVideoIdSuspenseQuery
+>;
+export type GetHeaderInfoByVideoIdQueryResult = Apollo.QueryResult<
+  GetHeaderInfoByVideoIdQuery,
+  GetHeaderInfoByVideoIdQueryVariables
+>;
 export const CreateUploadStreamDocument = gql`
   mutation CreateUploadStream($videoMetadataInput: VideoMetadataInput!) {
     createUploadStream(videoMetadata: $videoMetadataInput) {

src/operations/shots.gql

@@ -31,6 +31,28 @@ query GetShotsWithVideoGql($filterInput: FilterInput!, $limit: Int) {
   }
 }
 
+## Reserved for playlists (which are created from a filter)
+query GetShotsWithMetadataFilterResult(
+  $filterInput: FilterInput!
+  $shotsPagination: GetShotsPagination
+  $limit: Int
+  $ids: [Int!]
+) {
+  getShotsWithMetadata(
+    filterInput: $filterInput
+    shotsPagination: $shotsPagination
+    limit: $limit
+    ids: $ids
+  ) {
+    count
+    shots {
+      ...ShotWithAllFeatures
+    }
+    ids
+  }
+}
+
+# TODO: Delete
 query GetShotsWithMetadata(
   $filterInput: FilterInput!
   $shotsPagination: GetShotsPagination
@@ -62,11 +84,14 @@ fragment ShotWithAllFeatures on ShotGQL {
   videoId
   startFrame
   endFrame
+  startTime @client
+  endTime @client
   user {
     id
   }
   falsePositiveScore
   video {
+    id
     stream {
       resolution {
         width

src/operations/video.gql

@@ -117,25 +117,34 @@ query GetVideoDetails($videoId: Int!) {
 
 query GetVideos($videoIds: [Int!]!) {
   getVideos(videoIds: $videoIds) {
-    id
-    framesPerSecond
-    stream {
-      id
-      streamSegmentType
-      segments {
-        uploaded
-        valid
-        segmentIndex
-        endFrameIndex
-        framesPerSecond
-      }
-    }
-    playlist {
-      segmentDurations
-    }
+    ...VideoStreamMetadata
   }
 }
 
+fragment VideoStreamMetadata on VideoGQL {
+  id
+  framesPerSecond
+  stream {
+    id
+    streamSegmentType
+    segments {
+      uploaded
+      valid
+      segmentIndex
+      endFrameIndex
+      framesPerSecond
+    }
+  }
+  playlist {
+    segmentDurations
+  }
+}
+
+query GetVideoForShotTime($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    ...VideoStreamMetadata
+  }
+}
 query GetVideo($videoId: Int!) {
   getVideo(videoId: $videoId) {
     id
@@ -237,3 +246,11 @@ query GetVideoForClipTimes($videoId: Int!) {
     }
   }
 }
+
+query GetHeaderInfoByVideoId($videoId: Int!) {
+  getVideo(videoId: $videoId) {
+    id
+    name
+    startTime
+  }
+}

src/schema.gql

@@ -545,6 +545,10 @@ type Mutation {
     annotationName: String!
     notes: String = null
   ): AddShotAnnotationReturn!
+  updateShotAnnotations(
+    shotId: Int!
+    annotations: [UpdateAnnotationInputGQL!]!
+  ): UpdateShotAnnotationReturn!
   getProfileImageUploadLink(
     fileExt: String = ".png"
   ): GetProfileUploadLinkReturn!
@@ -598,6 +602,27 @@ type OtherErrorNeedsNote {
   msg: String
 }
 
+type UpdateShotAnnotationReturn {
+  value: SuccessfulUpdateUpdateShotAnnotationErrors!
+}
+
+union SuccessfulUpdateUpdateShotAnnotationErrors =
+    SuccessfulUpdate
+  | UpdateShotAnnotationErrors
+
+type SuccessfulUpdate {
+  value: Boolean!
+}
+
+type UpdateShotAnnotationErrors {
+  error: DoesNotOwnShotErr
+}
+
+input UpdateAnnotationInputGQL {
+  name: String!
+  notes: String = null
+}
+
 type GetProfileUploadLinkReturn {
   value: UploadLinkGetProfileUploadLinkErrors!
 }