Check homography

Reviewed-on: #119

src/index.tsx

@@ -1974,6 +1974,15 @@ export type MakePercentageIntervalGql = {
   makePercentage: Scalars["Float"]["output"];
 };
 
+export type MedalGql = {
+  __typename?: "MedalGQL";
+  count: Scalars["Int"]["output"];
+};
+
+export type MedalScope =
+  | { interval: TimeInterval; videoId?: never }
+  | { interval?: never; videoId: Scalars["Int"]["input"] };
+
 export type MustHaveSetForUploadLinkErr = {
   __typename?: "MustHaveSetForUploadLinkErr";
   framesPerSecond?: Maybe<Scalars["Boolean"]["output"]>;
@@ -1993,6 +2002,7 @@ export type MustHaveSetForUploadLinkErrSegmentAlreadyUploadedErrProcessingFailed
 export type Mutation = {
   __typename?: "Mutation";
   addAnnotationToShot: AddShotAnnotationReturn;
+  checkHomographyIsValid?: Maybe<HomographyInfoGql>;
   createBucketSet: BucketSetGql;
   createUploadStream: CreateUploadStreamReturn;
   deleteVideo: Scalars["Boolean"]["output"];
@@ -2015,6 +2025,11 @@ export type MutationAddAnnotationToShotArgs = {
   shotId: Scalars["Int"]["input"];
 };
 
+export type MutationCheckHomographyIsValidArgs = {
+  b64Image: Scalars["String"]["input"];
+  videoId: Scalars["Int"]["input"];
+};
+
 export type MutationCreateBucketSetArgs = {
   params: CreateBucketSetInput;
 };
@@ -2154,11 +2169,13 @@ export enum ProcessingStatusEnum {
 
 export type Query = {
   __typename?: "Query";
+  doesUsernameExist: Scalars["Boolean"]["output"];
   getAggregatedShotMetrics: Array<AggregateResultGql>;
   getBucketSet?: Maybe<BucketSetGql>;
   getDeployedConfig: DeployedConfigGql;
   getFeedVideos: VideoHistoryGql;
   getLoggedInUser?: Maybe<UserGql>;
+  getMedals: RequestedMedalsGql;
   getOrderedShots: GetShotsResult;
   getPlayTime: UserPlayTimeGql;
   getShotAnnotationTypes: Array<ShotAnnotationTypeGql>;
@@ -2176,6 +2193,10 @@ export type Query = {
   waitFor: Scalars["Float"]["output"];
 };
 
+export type QueryDoesUsernameExistArgs = {
+  candidateUsername: Scalars["String"]["input"];
+};
+
 export type QueryGetAggregatedShotMetricsArgs = {
   aggregateInput: AggregateInputGql;
 };
@@ -2190,7 +2211,13 @@ export type QueryGetFeedVideosArgs = {
   limit?: Scalars["Int"]["input"];
 };
 
+export type QueryGetMedalsArgs = {
+  scope: MedalScope;
+  userId?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type QueryGetOrderedShotsArgs = {
+  countRespectsLimit?: Scalars["Boolean"]["input"];
   filterInput: FilterInput;
   ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
   limit?: Scalars["Int"]["input"];
@@ -2206,6 +2233,7 @@ export type QueryGetShotAnnotationTypesArgs = {
 };
 
 export type QueryGetShotsArgs = {
+  countRespectsLimit?: Scalars["Boolean"]["input"];
   filterInput: FilterInput;
   limit?: Scalars["Int"]["input"];
   shotsPagination?: InputMaybe<GetShotsPagination>;
@@ -2216,6 +2244,7 @@ export type QueryGetShotsByIdsArgs = {
 };
 
 export type QueryGetShotsWithMetadataArgs = {
+  countRespectsLimit?: Scalars["Boolean"]["input"];
   filterInput: FilterInput;
   ids?: InputMaybe<Array<Scalars["Int"]["input"]>>;
   limit?: Scalars["Int"]["input"];
@@ -2264,6 +2293,44 @@ export type QueryWaitForArgs = {
   duration: Scalars["Float"]["input"];
 };
 
+export type RequestedMedalsGql = {
+  __typename?: "RequestedMedalsGQL";
+  dayStreak2?: Maybe<MedalGql>;
+  dayStreak3?: Maybe<MedalGql>;
+  dayStreak4?: Maybe<MedalGql>;
+  dayStreak5?: Maybe<MedalGql>;
+  dayStreak6?: Maybe<MedalGql>;
+  dayStreak7?: Maybe<MedalGql>;
+  dayStreak14?: Maybe<MedalGql>;
+  dayStreak21?: Maybe<MedalGql>;
+  dayStreak30?: Maybe<MedalGql>;
+  dayStreak60?: Maybe<MedalGql>;
+  dayStreak90?: Maybe<MedalGql>;
+  distanceOver66?: Maybe<MedalGql>;
+  distanceOver78?: Maybe<MedalGql>;
+  distanceOver90?: Maybe<MedalGql>;
+  runLength3?: Maybe<MedalGql>;
+  runLength5?: Maybe<MedalGql>;
+  runLength8?: Maybe<MedalGql>;
+  runLength10?: Maybe<MedalGql>;
+  runLength15?: Maybe<MedalGql>;
+  runLength20?: Maybe<MedalGql>;
+  runLength25?: Maybe<MedalGql>;
+  runLength30?: Maybe<MedalGql>;
+  runLength40?: Maybe<MedalGql>;
+  runLength50?: Maybe<MedalGql>;
+  totalMakes25?: Maybe<MedalGql>;
+  totalMakes50?: Maybe<MedalGql>;
+  totalMakes75?: Maybe<MedalGql>;
+  totalMakes100?: Maybe<MedalGql>;
+  totalMakes200?: Maybe<MedalGql>;
+  totalMakes300?: Maybe<MedalGql>;
+  totalMakes400?: Maybe<MedalGql>;
+  totalMakes500?: Maybe<MedalGql>;
+  totalMakes750?: Maybe<MedalGql>;
+  totalMakes1000?: Maybe<MedalGql>;
+};
+
 export type SegmentAlreadyUploadedErr = {
   __typename?: "SegmentAlreadyUploadedErr";
   segmentId: Scalars["Int"]["output"];
@@ -2667,6 +2734,51 @@ export type GetAggregatedShotMetricsQuery = {
   }>;
 };
 
+export type CheckHomographyIsValidMutationVariables = Exact<{
+  b64Image: Scalars["String"]["input"];
+  videoId: Scalars["Int"]["input"];
+}>;
+
+export type CheckHomographyIsValidMutation = {
+  __typename?: "Mutation";
+  checkHomographyIsValid?: {
+    __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 };
+    };
+    destPoints: {
+      __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 GetDeployedConfigQueryVariables = Exact<{ [key: string]: never }>;
 
 export type GetDeployedConfigQuery = {
@@ -2725,6 +2837,108 @@ export type GetFeedQuery = {
   };
 };
 
+export type VideoCardFieldsFragment = {
+  __typename?: "VideoGQL";
+  id: number;
+  name?: string | null;
+  screenshotUri?: string | null;
+  totalShotsMade: number;
+  totalShots: number;
+  makePercentage: number;
+  createdAt?: any | null;
+  updatedAt?: any | null;
+  startTime?: any | null;
+  endTime?: any | null;
+  elapsedTime?: number | null;
+  tableSize: number;
+  owner?: {
+    __typename?: "UserGQL";
+    id: number;
+    username: string;
+    profileImageUri?: string | null;
+  } | null;
+  stream?: {
+    __typename?: "UploadStreamGQL";
+    id: string;
+    isCompleted: boolean;
+  } | null;
+  tags: Array<{
+    __typename?: "VideoTag";
+    name: string;
+    tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
+  }>;
+  currentProcessing?: {
+    __typename?: "VideoProcessingGQL";
+    status: ProcessingStatusEnum;
+    errors: Array<{ __typename?: "VideoProcessingErrorGQL"; message: string }>;
+    statuses: Array<{
+      __typename?: "VideoProcessingStatusGQL";
+      status: ProcessingStatusEnum;
+    }>;
+  } | null;
+};
+
+export type GetVideoFeedQueryVariables = Exact<{
+  limit?: Scalars["Int"]["input"];
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  filters?: InputMaybe<VideoFilterInput>;
+}>;
+
+export type GetVideoFeedQuery = {
+  __typename?: "Query";
+  getFeedVideos: {
+    __typename?: "VideoHistoryGQL";
+    videos: Array<{
+      __typename?: "VideoGQL";
+      id: number;
+      name?: string | null;
+      screenshotUri?: string | null;
+      totalShotsMade: number;
+      totalShots: number;
+      makePercentage: number;
+      createdAt?: any | null;
+      updatedAt?: any | null;
+      startTime?: any | null;
+      endTime?: any | null;
+      elapsedTime?: number | null;
+      tableSize: number;
+      owner?: {
+        __typename?: "UserGQL";
+        id: number;
+        username: string;
+        profileImageUri?: string | null;
+      } | null;
+      stream?: {
+        __typename?: "UploadStreamGQL";
+        id: string;
+        isCompleted: boolean;
+      } | null;
+      tags: Array<{
+        __typename?: "VideoTag";
+        name: string;
+        tagClasses: Array<{ __typename?: "VideoTagClass"; name: string }>;
+      }>;
+      currentProcessing?: {
+        __typename?: "VideoProcessingGQL";
+        status: ProcessingStatusEnum;
+        errors: Array<{
+          __typename?: "VideoProcessingErrorGQL";
+          message: string;
+        }>;
+        statuses: Array<{
+          __typename?: "VideoProcessingStatusGQL";
+          status: ProcessingStatusEnum;
+        }>;
+      } | null;
+    }>;
+    pageInfo: {
+      __typename?: "PageInfoGQL";
+      hasNextPage: boolean;
+      endCursor?: string | null;
+    };
+  };
+};
+
 export type GetVideoMakePercentageIntervalsQueryVariables = Exact<{
   videoId: Scalars["ID"]["input"];
   intervalDuration: Scalars["Int"]["input"];
@@ -2825,11 +3039,26 @@ export type GetShotsWithVideoGqlQuery = {
   };
 };
 
+export type GetShotsWithJustIdsQueryVariables = Exact<{
+  filterInput: FilterInput;
+  shotsOrdering?: InputMaybe<GetShotsOrdering>;
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+}>;
+
+export type GetShotsWithJustIdsQuery = {
+  __typename?: "Query";
+  getOrderedShots: {
+    __typename?: "GetShotsResult";
+    shots: Array<{ __typename?: "ShotGQL"; id: number; videoId: number }>;
+  };
+};
+
 export type GetShotsWithMetadataFilterResultQueryVariables = Exact<{
   filterInput: FilterInput;
   shotsOrdering?: InputMaybe<GetShotsOrdering>;
   limit?: InputMaybe<Scalars["Int"]["input"]>;
   ids?: InputMaybe<Array<Scalars["Int"]["input"]> | Scalars["Int"]["input"]>;
+  countRespectsLimit?: InputMaybe<Scalars["Boolean"]["input"]>;
 }>;
 
 export type GetShotsWithMetadataFilterResultQuery = {
@@ -3177,8 +3406,17 @@ export type FollowUserMutation = {
   followUser: {
     __typename?: "UserGQL";
     username: string;
-    following?: Array<{ __typename?: "UserGQL"; id: number }> | null;
-    followers?: Array<{ __typename?: "UserGQL"; id: number }> | null;
+    id: number;
+    following?: Array<{
+      __typename?: "UserGQL";
+      id: number;
+      username: string;
+    }> | null;
+    followers?: Array<{
+      __typename?: "UserGQL";
+      id: number;
+      username: string;
+    }> | null;
   };
 };
 
@@ -3191,8 +3429,17 @@ export type UnfollowUserMutation = {
   unfollowUser: {
     __typename?: "UserGQL";
     username: string;
-    following?: Array<{ __typename?: "UserGQL"; id: number }> | null;
-    followers?: Array<{ __typename?: "UserGQL"; id: number }> | null;
+    id: number;
+    following?: Array<{
+      __typename?: "UserGQL";
+      id: number;
+      username: string;
+    }> | null;
+    followers?: Array<{
+      __typename?: "UserGQL";
+      id: number;
+      username: string;
+    }> | null;
   };
 };
 
@@ -3218,6 +3465,15 @@ export type GetUserFollowingFollowersQuery = {
   } | null;
 };
 
+export type DoesUsernameExistQueryVariables = Exact<{
+  candidateUsername: Scalars["String"]["input"];
+}>;
+
+export type DoesUsernameExistQuery = {
+  __typename?: "Query";
+  doesUsernameExist: boolean;
+};
+
 export type GetStreamMonitoringDetailsQueryVariables = Exact<{
   videoId: Scalars["Int"]["input"];
   debuggingJson?: InputMaybe<Scalars["JSON"]["input"]>;
@@ -3819,6 +4075,47 @@ export type GetUploadStreamsWithDetailsQuery = {
   };
 };
 
+export const VideoCardFieldsFragmentDoc = gql`
+  fragment VideoCardFields on VideoGQL {
+    id
+    owner {
+      id
+      username
+      profileImageUri
+    }
+    name
+    screenshotUri
+    totalShotsMade
+    totalShots
+    makePercentage
+    createdAt
+    updatedAt
+    startTime
+    endTime
+    elapsedTime
+    screenshotUri
+    stream {
+      id
+      isCompleted
+    }
+    tableSize
+    tags {
+      tagClasses {
+        name
+      }
+      name
+    }
+    currentProcessing {
+      errors {
+        message
+      }
+      status
+      statuses {
+        status
+      }
+    }
+  }
+`;
 export const ShotWithAllFeaturesFragmentDoc = gql`
   fragment ShotWithAllFeatures on ShotGQL {
     id
@@ -4017,6 +4314,121 @@ export type GetAggregatedShotMetricsQueryResult = Apollo.QueryResult<
   GetAggregatedShotMetricsQuery,
   GetAggregatedShotMetricsQueryVariables
 >;
+export const CheckHomographyIsValidDocument = gql`
+  mutation checkHomographyIsValid($b64Image: String!, $videoId: Int!) {
+    checkHomographyIsValid(b64Image: $b64Image, videoId: $videoId) {
+      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
+        }
+      }
+      destPoints {
+        topLeft {
+          x
+          y
+        }
+        topSide {
+          x
+          y
+        }
+        topRight {
+          x
+          y
+        }
+        bottomLeft {
+          x
+          y
+        }
+        bottomSide {
+          x
+          y
+        }
+        bottomRight {
+          x
+          y
+        }
+      }
+    }
+  }
+`;
+export type CheckHomographyIsValidMutationFn = Apollo.MutationFunction<
+  CheckHomographyIsValidMutation,
+  CheckHomographyIsValidMutationVariables
+>;
+
+/**
+ * __useCheckHomographyIsValidMutation__
+ *
+ * To run a mutation, you first call `useCheckHomographyIsValidMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCheckHomographyIsValidMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [checkHomographyIsValidMutation, { data, loading, error }] = useCheckHomographyIsValidMutation({
+ *   variables: {
+ *      b64Image: // value for 'b64Image'
+ *      videoId: // value for 'videoId'
+ *   },
+ * });
+ */
+export function useCheckHomographyIsValidMutation(
+  baseOptions?: Apollo.MutationHookOptions<
+    CheckHomographyIsValidMutation,
+    CheckHomographyIsValidMutationVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useMutation<
+    CheckHomographyIsValidMutation,
+    CheckHomographyIsValidMutationVariables
+  >(CheckHomographyIsValidDocument, options);
+}
+export type CheckHomographyIsValidMutationHookResult = ReturnType<
+  typeof useCheckHomographyIsValidMutation
+>;
+export type CheckHomographyIsValidMutationResult =
+  Apollo.MutationResult<CheckHomographyIsValidMutation>;
+export type CheckHomographyIsValidMutationOptions = Apollo.BaseMutationOptions<
+  CheckHomographyIsValidMutation,
+  CheckHomographyIsValidMutationVariables
+>;
 export const GetDeployedConfigDocument = gql`
   query getDeployedConfig {
     getDeployedConfig {
@@ -4196,6 +4608,92 @@ export type GetFeedQueryResult = Apollo.QueryResult<
   GetFeedQuery,
   GetFeedQueryVariables
 >;
+export const GetVideoFeedDocument = gql`
+  query GetVideoFeed(
+    $limit: Int! = 5
+    $after: String = null
+    $filters: VideoFilterInput = null
+  ) {
+    getFeedVideos(limit: $limit, after: $after, filters: $filters) {
+      videos {
+        ...VideoCardFields
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+  ${VideoCardFieldsFragmentDoc}
+`;
+
+/**
+ * __useGetVideoFeedQuery__
+ *
+ * To run a query within a React component, call `useGetVideoFeedQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVideoFeedQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetVideoFeedQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      after: // value for 'after'
+ *      filters: // value for 'filters'
+ *   },
+ * });
+ */
+export function useGetVideoFeedQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetVideoFeedQuery,
+    GetVideoFeedQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
+    GetVideoFeedDocument,
+    options,
+  );
+}
+export function useGetVideoFeedLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetVideoFeedQuery,
+    GetVideoFeedQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
+    GetVideoFeedDocument,
+    options,
+  );
+}
+export function useGetVideoFeedSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetVideoFeedQuery,
+    GetVideoFeedQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<GetVideoFeedQuery, GetVideoFeedQueryVariables>(
+    GetVideoFeedDocument,
+    options,
+  );
+}
+export type GetVideoFeedQueryHookResult = ReturnType<
+  typeof useGetVideoFeedQuery
+>;
+export type GetVideoFeedLazyQueryHookResult = ReturnType<
+  typeof useGetVideoFeedLazyQuery
+>;
+export type GetVideoFeedSuspenseQueryHookResult = ReturnType<
+  typeof useGetVideoFeedSuspenseQuery
+>;
+export type GetVideoFeedQueryResult = Apollo.QueryResult<
+  GetVideoFeedQuery,
+  GetVideoFeedQueryVariables
+>;
 export const GetVideoMakePercentageIntervalsDocument = gql`
   query GetVideoMakePercentageIntervals(
     $videoId: ID!
@@ -4587,18 +5085,106 @@ export type GetShotsWithVideoGqlQueryResult = Apollo.QueryResult<
   GetShotsWithVideoGqlQuery,
   GetShotsWithVideoGqlQueryVariables
 >;
+export const GetShotsWithJustIdsDocument = gql`
+  query GetShotsWithJustIds(
+    $filterInput: FilterInput!
+    $shotsOrdering: GetShotsOrdering
+    $limit: Int
+  ) {
+    getOrderedShots(
+      filterInput: $filterInput
+      shotsOrdering: $shotsOrdering
+      limit: $limit
+    ) {
+      shots {
+        id
+        videoId
+      }
+    }
+  }
+`;
+
+/**
+ * __useGetShotsWithJustIdsQuery__
+ *
+ * To run a query within a React component, call `useGetShotsWithJustIdsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetShotsWithJustIdsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetShotsWithJustIdsQuery({
+ *   variables: {
+ *      filterInput: // value for 'filterInput'
+ *      shotsOrdering: // value for 'shotsOrdering'
+ *      limit: // value for 'limit'
+ *   },
+ * });
+ */
+export function useGetShotsWithJustIdsQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >(GetShotsWithJustIdsDocument, options);
+}
+export function useGetShotsWithJustIdsLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >(GetShotsWithJustIdsDocument, options);
+}
+export function useGetShotsWithJustIdsSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetShotsWithJustIdsQuery,
+    GetShotsWithJustIdsQueryVariables
+  >(GetShotsWithJustIdsDocument, options);
+}
+export type GetShotsWithJustIdsQueryHookResult = ReturnType<
+  typeof useGetShotsWithJustIdsQuery
+>;
+export type GetShotsWithJustIdsLazyQueryHookResult = ReturnType<
+  typeof useGetShotsWithJustIdsLazyQuery
+>;
+export type GetShotsWithJustIdsSuspenseQueryHookResult = ReturnType<
+  typeof useGetShotsWithJustIdsSuspenseQuery
+>;
+export type GetShotsWithJustIdsQueryResult = Apollo.QueryResult<
+  GetShotsWithJustIdsQuery,
+  GetShotsWithJustIdsQueryVariables
+>;
 export const GetShotsWithMetadataFilterResultDocument = gql`
   query GetShotsWithMetadataFilterResult(
     $filterInput: FilterInput!
     $shotsOrdering: GetShotsOrdering
     $limit: Int
     $ids: [Int!]
+    $countRespectsLimit: Boolean
   ) {
     getOrderedShots(
       filterInput: $filterInput
       shotsOrdering: $shotsOrdering
       limit: $limit
       ids: $ids
+      countRespectsLimit: $countRespectsLimit
     ) {
       count
       shots {
@@ -4626,6 +5212,7 @@ export const GetShotsWithMetadataFilterResultDocument = gql`
  *      shotsOrdering: // value for 'shotsOrdering'
  *      limit: // value for 'limit'
  *      ids: // value for 'ids'
+ *      countRespectsLimit: // value for 'countRespectsLimit'
  *   },
  * });
  */
@@ -5361,11 +5948,14 @@ export const FollowUserDocument = gql`
   mutation followUser($followedUserId: Int!) {
     followUser(followedUserId: $followedUserId) {
       username
+      id
       following {
         id
+        username
       }
       followers {
         id
+        username
       }
     }
   }
@@ -5417,11 +6007,14 @@ export const UnfollowUserDocument = gql`
   mutation unfollowUser($followedUserId: Int!) {
     unfollowUser(followedUserId: $followedUserId) {
       username
+      id
       following {
         id
+        username
       }
       followers {
         id
+        username
       }
     }
   }
@@ -5549,6 +6142,77 @@ export type GetUserFollowingFollowersQueryResult = Apollo.QueryResult<
   GetUserFollowingFollowersQuery,
   GetUserFollowingFollowersQueryVariables
 >;
+export const DoesUsernameExistDocument = gql`
+  query doesUsernameExist($candidateUsername: String!) {
+    doesUsernameExist(candidateUsername: $candidateUsername)
+  }
+`;
+
+/**
+ * __useDoesUsernameExistQuery__
+ *
+ * To run a query within a React component, call `useDoesUsernameExistQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDoesUsernameExistQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useDoesUsernameExistQuery({
+ *   variables: {
+ *      candidateUsername: // value for 'candidateUsername'
+ *   },
+ * });
+ */
+export function useDoesUsernameExistQuery(
+  baseOptions: Apollo.QueryHookOptions<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >(DoesUsernameExistDocument, options);
+}
+export function useDoesUsernameExistLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >(DoesUsernameExistDocument, options);
+}
+export function useDoesUsernameExistSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    DoesUsernameExistQuery,
+    DoesUsernameExistQueryVariables
+  >(DoesUsernameExistDocument, options);
+}
+export type DoesUsernameExistQueryHookResult = ReturnType<
+  typeof useDoesUsernameExistQuery
+>;
+export type DoesUsernameExistLazyQueryHookResult = ReturnType<
+  typeof useDoesUsernameExistLazyQuery
+>;
+export type DoesUsernameExistSuspenseQueryHookResult = ReturnType<
+  typeof useDoesUsernameExistSuspenseQuery
+>;
+export type DoesUsernameExistQueryResult = Apollo.QueryResult<
+  DoesUsernameExistQuery,
+  DoesUsernameExistQueryVariables
+>;
 export const GetStreamMonitoringDetailsDocument = gql`
   query GetStreamMonitoringDetails($videoId: Int!, $debuggingJson: JSON) {
     getVideo(videoId: $videoId, debuggingJson: $debuggingJson) {

src/operations/check_homography.gql

@@ -0,0 +1,69 @@
+mutation checkHomographyIsValid($b64Image: String!, $videoId: Int!) {
+  checkHomographyIsValid(b64Image: $b64Image, videoId: $videoId) {
+    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
+      }
+    }
+    destPoints {
+      topLeft {
+        x
+        y
+      }
+      topSide {
+        x
+        y
+      }
+      topRight {
+        x
+        y
+      }
+      bottomLeft {
+        x
+        y
+      }
+      bottomSide {
+        x
+        y
+      }
+      bottomRight {
+        x
+        y
+      }
+    }
+  }
+}

src/operations/feed.gql

@@ -1,3 +1,4 @@
+# DO NOT USE: use getVideoFeed instead
 query GetFeed(
   $limit: Int! = 5
   $after: String = null
@@ -38,3 +39,59 @@ query GetFeed(
     }
   }
 }
+
+fragment VideoCardFields on VideoGQL {
+  id
+  owner {
+    id
+    username
+    profileImageUri
+  }
+  name
+  screenshotUri
+  totalShotsMade
+  totalShots
+  makePercentage
+  createdAt
+  updatedAt
+  startTime
+  endTime
+  elapsedTime
+  screenshotUri
+  stream {
+    id
+    isCompleted
+  }
+  tableSize
+  tags {
+    tagClasses {
+      name
+    }
+    name
+  }
+  currentProcessing {
+    errors {
+      message
+    }
+    status
+    statuses {
+      status
+    }
+  }
+}
+
+query GetVideoFeed(
+  $limit: Int! = 5
+  $after: String = null
+  $filters: VideoFilterInput = null
+) {
+  getFeedVideos(limit: $limit, after: $after, filters: $filters) {
+    videos {
+      ...VideoCardFields
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}

src/operations/shots.gql

@@ -40,6 +40,7 @@ mutation UpdateShotAnnotations(
   }
 }
 
+## Should be deprecated
 query GetShotsWithVideoGql(
   $filterInput: FilterInput!
   $shotsOrdering: GetShotsOrdering
@@ -61,18 +62,37 @@ query GetShotsWithVideoGql(
   }
 }
 
+query GetShotsWithJustIds(
+  $filterInput: FilterInput!
+  $shotsOrdering: GetShotsOrdering
+  $limit: Int
+) {
+  getOrderedShots(
+    filterInput: $filterInput
+    shotsOrdering: $shotsOrdering
+    limit: $limit
+  ) {
+    shots {
+      id
+      videoId
+    }
+  }
+}
+
 ## Reserved for playlists (which are created from a filter)
 query GetShotsWithMetadataFilterResult(
   $filterInput: FilterInput!
   $shotsOrdering: GetShotsOrdering
   $limit: Int
   $ids: [Int!]
+  $countRespectsLimit: Boolean
 ) {
   getOrderedShots(
     filterInput: $filterInput
     shotsOrdering: $shotsOrdering
     limit: $limit
     ids: $ids
+    countRespectsLimit: $countRespectsLimit
   ) {
     count
     shots {

src/operations/user.gql

@@ -91,11 +91,14 @@ query GetUserTags {
 mutation followUser($followedUserId: Int!) {
   followUser(followedUserId: $followedUserId) {
     username
+    id
     following {
       id
+      username
     }
     followers {
       id
+      username
     }
   }
 }
@@ -103,11 +106,14 @@ mutation followUser($followedUserId: Int!) {
 mutation unfollowUser($followedUserId: Int!) {
   unfollowUser(followedUserId: $followedUserId) {
     username
+    id
     following {
       id
+      username
     }
     followers {
       id
+      username
     }
   }
 }
@@ -125,3 +131,7 @@ query getUserFollowingFollowers {
     }
   }
 }
+
+query doesUsernameExist($candidateUsername: String!) {
+  doesUsernameExist(candidateUsername: $candidateUsername)
+}

src/schema.gql

@@ -9,26 +9,31 @@ type Query {
     videoId: ID!
     intervalDuration: Int! = 300
   ): [MakePercentageIntervalGQL!]!
+  getMedals(scope: MedalScope!, userId: Int = null): RequestedMedalsGQL!
   getOrderedShots(
     filterInput: FilterInput!
     ids: [Int!] = null
     shotsOrdering: GetShotsOrdering = null
     limit: Int! = 500
+    countRespectsLimit: Boolean! = false
   ): GetShotsResult!
   getShotsWithMetadata(
     filterInput: FilterInput!
     ids: [Int!] = null
     shotsPagination: GetShotsPagination = null
     limit: Int! = 500
+    countRespectsLimit: Boolean! = false
   ): GetShotsResult!
   getShots(
     filterInput: FilterInput!
     shotsPagination: GetShotsPagination = null
     limit: Int! = 500
+    countRespectsLimit: Boolean! = false
   ): [ShotGQL!]!
   getShotsByIds(ids: [Int!]!): [ShotGQL!]!
   getShotAnnotationTypes(errorTypes: Boolean = false): [ShotAnnotationTypeGQL!]!
   getUser(userId: Int!): UserGQL
+  doesUsernameExist(candidateUsername: String!): Boolean!
   getLoggedInUser: UserGQL
   getUsernames(
     matchString: String = null
@@ -266,6 +271,52 @@ type MakePercentageIntervalGQL {
   elapsedTime: Float!
 }
 
+type RequestedMedalsGQL {
+  distanceOver66: MedalGQL
+  distanceOver78: MedalGQL
+  distanceOver90: MedalGQL
+  runLength3: MedalGQL
+  runLength5: MedalGQL
+  runLength8: MedalGQL
+  runLength10: MedalGQL
+  runLength15: MedalGQL
+  runLength20: MedalGQL
+  runLength25: MedalGQL
+  runLength30: MedalGQL
+  runLength40: MedalGQL
+  runLength50: MedalGQL
+  totalMakes25: MedalGQL
+  totalMakes50: MedalGQL
+  totalMakes75: MedalGQL
+  totalMakes100: MedalGQL
+  totalMakes200: MedalGQL
+  totalMakes300: MedalGQL
+  totalMakes400: MedalGQL
+  totalMakes500: MedalGQL
+  totalMakes750: MedalGQL
+  totalMakes1000: MedalGQL
+  dayStreak2: MedalGQL
+  dayStreak3: MedalGQL
+  dayStreak4: MedalGQL
+  dayStreak5: MedalGQL
+  dayStreak6: MedalGQL
+  dayStreak7: MedalGQL
+  dayStreak14: MedalGQL
+  dayStreak21: MedalGQL
+  dayStreak30: MedalGQL
+  dayStreak60: MedalGQL
+  dayStreak90: MedalGQL
+}
+
+type MedalGQL {
+  count: Int!
+}
+
+input MedalScope @oneOf {
+  videoId: Int
+  interval: TimeInterval
+}
+
 type GetShotsResult {
   shots: [ShotGQL!]!
   count: Int
@@ -617,6 +668,7 @@ type Mutation {
   editUser(input: EditUserInputGQL!): UserGQL!
   followUser(followedUserId: Int!): UserGQL!
   unfollowUser(followedUserId: Int!): UserGQL!
+  checkHomographyIsValid(b64Image: String!, videoId: Int!): HomographyInfoGQL
   createUploadStream(
     videoMetadata: VideoMetadataInput!
   ): CreateUploadStreamReturn!