Select storage limit fields for upload links

src/index.tsx

@@ -2844,18 +2844,6 @@ export type PocketingIntentionInfoGql = {
   pocketId: PocketIdentifier;
 };
 
-export type PotAimGql = {
-  __typename?: "PotAimGQL";
-  converged: Scalars["Boolean"]["output"];
-  cutAngle: Scalars["Float"]["output"];
-  feasible: Scalars["Boolean"]["output"];
-  geometricPhi: Scalars["Float"]["output"];
-  occludingBallIds: Array<Scalars["Int"]["output"]>;
-  phi: Scalars["Float"]["output"];
-  potted: Scalars["Boolean"]["output"];
-  requiredPrecision: Scalars["Float"]["output"];
-};
-
 export type ProcessingFailedErr = {
   __typename?: "ProcessingFailedErr";
   processing: VideoProcessingGql;
@@ -2877,7 +2865,6 @@ export type Query = {
   challenge?: Maybe<Challenge>;
   challengeLeaderboard: Array<ChallengeEntry>;
   challenges: Array<Challenge>;
-  computePotAim: PotAimGql;
   doesUsernameExist: Scalars["Boolean"]["output"];
   getAggregatedShotMetrics: Array<AggregateResultGql>;
   getAppleAppAccountToken: Scalars["String"]["output"];
@@ -2940,12 +2927,6 @@ export type QueryChallengesArgs = {
   includeDismissed?: Scalars["Boolean"]["input"];
 };
 
-export type QueryComputePotAimArgs = {
-  pocket: PocketIdentifier;
-  simulationInput: SimulateShotInputGql;
-  targetBallId: Scalars["Int"]["input"];
-};
-
 export type QueryDoesUsernameExistArgs = {
   candidateUsername: Scalars["String"]["input"];
 };
@@ -4401,6 +4382,7 @@ export type GetDeployedConfigQuery = {
     minimumAllowedAppVersion: string;
     subscriptionGatingEnabled: boolean;
     quotaEnforcementEnabled: boolean;
+    storageLimitEnforcementEnabled: boolean;
     defaultAndroidRecordingFormat: StreamSegmentTypeEnum;
     bucketUrl: string;
     bannerMessages: Array<{
@@ -5290,6 +5272,45 @@ export type GetSubscriptionStatusQuery = {
   };
 };
 
+export type GetResolvedTierQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GetResolvedTierQuery = {
+  __typename?: "Query";
+  getResolvedTier: {
+    __typename?: "ResolvedTierGQL";
+    tierName: string;
+    tierDisplayName: string;
+    hasActiveSubscription: boolean;
+    entitlementSource?: EntitlementSourceTypeEnum | null;
+    entitlementStatus?: string | null;
+    entitlementStartsAt?: any | null;
+    entitlementEndsAt?: any | null;
+    capabilities: Array<string>;
+  };
+};
+
+export type GetStorageStatusQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GetStorageStatusQuery = {
+  __typename?: "Query";
+  getStorageStatus?: {
+    __typename?: "StorageStatusGQL";
+    userId: number;
+    tierName: string;
+    retainedStorageUsedBytes: any;
+    retainedStorageLimitBytes?: any | null;
+    isUnlimited: boolean;
+    policyConfigured: boolean;
+    remainingStorageBytes?: any | null;
+    storageUsageRatio?: number | null;
+    isNearLimit: boolean;
+    isOverLimit: boolean;
+    usageCalculated: boolean;
+    usageSource?: string | null;
+    lastCalculatedAt?: any | null;
+  } | null;
+};
+
 export type GetAppleAppAccountTokenQueryVariables = Exact<{
   [key: string]: never;
 }>;
@@ -5560,74 +5581,6 @@ export type FinalizePlayerAssignmentsMutation = {
   }>;
 };
 
-export type GetTableStateQueryVariables = Exact<{
-  b64Image: Scalars["String"]["input"];
-  tableSize?: InputMaybe<Scalars["Float"]["input"]>;
-  useHomography?: InputMaybe<HomographyInputGql>;
-}>;
-
-export type GetTableStateQuery = {
-  __typename?: "Query";
-  getTableState: {
-    __typename?: "TableStateGQL";
-    identifierToPosition: Array<Array<number>>;
-  };
-};
-
-export type SimulateShotQueryVariables = Exact<{
-  simulationInput: SimulateShotInputGql;
-}>;
-
-export type SimulateShotQuery = {
-  __typename?: "Query";
-  simulateShot: {
-    __typename?: "ShotProjectionGQL";
-    pottedBallIds: Array<number>;
-    trajectories: Array<{
-      __typename?: "BallTrajectoryGQL";
-      ballId: number;
-      points: Array<{
-        __typename?: "TrajectoryPointGQL";
-        time: number;
-        position: Array<number>;
-      }>;
-    }>;
-    events: Array<{
-      __typename?: "SimulationEventGQL";
-      eventType: SimulationEventType;
-      time: number;
-      ballIds: Array<number>;
-      position?: Array<number> | null;
-    }>;
-    finalState: Array<{
-      __typename?: "SimulationBallStateGQL";
-      ballId: number;
-      position: Array<number>;
-    }>;
-  };
-};
-
-export type ComputePotAimQueryVariables = Exact<{
-  simulationInput: SimulateShotInputGql;
-  targetBallId: Scalars["Int"]["input"];
-  pocket: PocketIdentifier;
-}>;
-
-export type ComputePotAimQuery = {
-  __typename?: "Query";
-  computePotAim: {
-    __typename?: "PotAimGQL";
-    phi: number;
-    geometricPhi: number;
-    cutAngle: number;
-    requiredPrecision: number;
-    feasible: boolean;
-    potted: boolean;
-    converged: boolean;
-    occludingBallIds: Array<number>;
-  };
-};
-
 export type GetSerializedShotPathsQueryVariables = Exact<{
   filterInput: FilterInput;
 }>;
@@ -7382,7 +7335,14 @@ export type GetUploadLinkMutation = {
                 };
               }
             | { __typename?: "SegmentAlreadyUploadedErr"; segmentId: number }
-            | { __typename?: "StorageLimitExceededErr" }
+            | {
+                __typename?: "StorageLimitExceededErr";
+                reason: string;
+                tierName: string;
+                retainedStorageUsedBytes: any;
+                retainedStorageLimitBytes?: any | null;
+                remainingStorageBytes?: any | null;
+              }
             | { __typename?: "TooManyInitUploadsErr" }
             | { __typename?: "TooManyProfileImageUploadsErr" };
         }
@@ -9416,6 +9376,7 @@ export const GetDeployedConfigDocument = gql`
       minimumAllowedAppVersion
       subscriptionGatingEnabled
       quotaEnforcementEnabled
+      storageLimitEnforcementEnabled
       bannerMessages {
         color
         dismissible
@@ -11263,6 +11224,169 @@ export type GetSubscriptionStatusQueryResult = Apollo.QueryResult<
   GetSubscriptionStatusQuery,
   GetSubscriptionStatusQueryVariables
 >;
+export const GetResolvedTierDocument = gql`
+  query GetResolvedTier {
+    getResolvedTier {
+      tierName
+      tierDisplayName
+      hasActiveSubscription
+      entitlementSource
+      entitlementStatus
+      entitlementStartsAt
+      entitlementEndsAt
+      capabilities
+    }
+  }
+`;
+
+/**
+ * __useGetResolvedTierQuery__
+ *
+ * To run a query within a React component, call `useGetResolvedTierQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetResolvedTierQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetResolvedTierQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetResolvedTierQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetResolvedTierQuery,
+    GetResolvedTierQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetResolvedTierQuery, GetResolvedTierQueryVariables>(
+    GetResolvedTierDocument,
+    options,
+  );
+}
+export function useGetResolvedTierLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetResolvedTierQuery,
+    GetResolvedTierQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetResolvedTierQuery,
+    GetResolvedTierQueryVariables
+  >(GetResolvedTierDocument, options);
+}
+export function useGetResolvedTierSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetResolvedTierQuery,
+    GetResolvedTierQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetResolvedTierQuery,
+    GetResolvedTierQueryVariables
+  >(GetResolvedTierDocument, options);
+}
+export type GetResolvedTierQueryHookResult = ReturnType<
+  typeof useGetResolvedTierQuery
+>;
+export type GetResolvedTierLazyQueryHookResult = ReturnType<
+  typeof useGetResolvedTierLazyQuery
+>;
+export type GetResolvedTierSuspenseQueryHookResult = ReturnType<
+  typeof useGetResolvedTierSuspenseQuery
+>;
+export type GetResolvedTierQueryResult = Apollo.QueryResult<
+  GetResolvedTierQuery,
+  GetResolvedTierQueryVariables
+>;
+export const GetStorageStatusDocument = gql`
+  query GetStorageStatus {
+    getStorageStatus {
+      userId
+      tierName
+      retainedStorageUsedBytes
+      retainedStorageLimitBytes
+      isUnlimited
+      policyConfigured
+      remainingStorageBytes
+      storageUsageRatio
+      isNearLimit
+      isOverLimit
+      usageCalculated
+      usageSource
+      lastCalculatedAt
+    }
+  }
+`;
+
+/**
+ * __useGetStorageStatusQuery__
+ *
+ * To run a query within a React component, call `useGetStorageStatusQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetStorageStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetStorageStatusQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetStorageStatusQuery(
+  baseOptions?: Apollo.QueryHookOptions<
+    GetStorageStatusQuery,
+    GetStorageStatusQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useQuery<GetStorageStatusQuery, GetStorageStatusQueryVariables>(
+    GetStorageStatusDocument,
+    options,
+  );
+}
+export function useGetStorageStatusLazyQuery(
+  baseOptions?: Apollo.LazyQueryHookOptions<
+    GetStorageStatusQuery,
+    GetStorageStatusQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useLazyQuery<
+    GetStorageStatusQuery,
+    GetStorageStatusQueryVariables
+  >(GetStorageStatusDocument, options);
+}
+export function useGetStorageStatusSuspenseQuery(
+  baseOptions?: Apollo.SuspenseQueryHookOptions<
+    GetStorageStatusQuery,
+    GetStorageStatusQueryVariables
+  >,
+) {
+  const options = { ...defaultOptions, ...baseOptions };
+  return Apollo.useSuspenseQuery<
+    GetStorageStatusQuery,
+    GetStorageStatusQueryVariables
+  >(GetStorageStatusDocument, options);
+}
+export type GetStorageStatusQueryHookResult = ReturnType<
+  typeof useGetStorageStatusQuery
+>;
+export type GetStorageStatusLazyQueryHookResult = ReturnType<
+  typeof useGetStorageStatusLazyQuery
+>;
+export type GetStorageStatusSuspenseQueryHookResult = ReturnType<
+  typeof useGetStorageStatusSuspenseQuery
+>;
+export type GetStorageStatusQueryResult = Apollo.QueryResult<
+  GetStorageStatusQuery,
+  GetStorageStatusQueryVariables
+>;
 export const GetAppleAppAccountTokenDocument = gql`
   query GetAppleAppAccountToken {
     getAppleAppAccountToken
@@ -11887,269 +12011,6 @@ export type FinalizePlayerAssignmentsMutationOptions =
     FinalizePlayerAssignmentsMutation,
     FinalizePlayerAssignmentsMutationVariables
   >;
-export const GetTableStateDocument = gql`
-  query GetTableState(
-    $b64Image: String!
-    $tableSize: Float
-    $useHomography: HomographyInputGQL
-  ) {
-    getTableState(
-      b64Image: $b64Image
-      tableSize: $tableSize
-      useHomography: $useHomography
-    ) {
-      identifierToPosition
-    }
-  }
-`;
-
-/**
- * __useGetTableStateQuery__
- *
- * To run a query within a React component, call `useGetTableStateQuery` and pass it any options that fit your needs.
- * When your component renders, `useGetTableStateQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useGetTableStateQuery({
- *   variables: {
- *      b64Image: // value for 'b64Image'
- *      tableSize: // value for 'tableSize'
- *      useHomography: // value for 'useHomography'
- *   },
- * });
- */
-export function useGetTableStateQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    GetTableStateQuery,
-    GetTableStateQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<GetTableStateQuery, GetTableStateQueryVariables>(
-    GetTableStateDocument,
-    options,
-  );
-}
-export function useGetTableStateLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    GetTableStateQuery,
-    GetTableStateQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<GetTableStateQuery, GetTableStateQueryVariables>(
-    GetTableStateDocument,
-    options,
-  );
-}
-export function useGetTableStateSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    GetTableStateQuery,
-    GetTableStateQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    GetTableStateQuery,
-    GetTableStateQueryVariables
-  >(GetTableStateDocument, options);
-}
-export type GetTableStateQueryHookResult = ReturnType<
-  typeof useGetTableStateQuery
->;
-export type GetTableStateLazyQueryHookResult = ReturnType<
-  typeof useGetTableStateLazyQuery
->;
-export type GetTableStateSuspenseQueryHookResult = ReturnType<
-  typeof useGetTableStateSuspenseQuery
->;
-export type GetTableStateQueryResult = Apollo.QueryResult<
-  GetTableStateQuery,
-  GetTableStateQueryVariables
->;
-export const SimulateShotDocument = gql`
-  query SimulateShot($simulationInput: SimulateShotInputGQL!) {
-    simulateShot(simulationInput: $simulationInput) {
-      trajectories {
-        ballId
-        points {
-          time
-          position
-        }
-      }
-      events {
-        eventType
-        time
-        ballIds
-        position
-      }
-      finalState {
-        ballId
-        position
-      }
-      pottedBallIds
-    }
-  }
-`;
-
-/**
- * __useSimulateShotQuery__
- *
- * To run a query within a React component, call `useSimulateShotQuery` and pass it any options that fit your needs.
- * When your component renders, `useSimulateShotQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useSimulateShotQuery({
- *   variables: {
- *      simulationInput: // value for 'simulationInput'
- *   },
- * });
- */
-export function useSimulateShotQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    SimulateShotQuery,
-    SimulateShotQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<SimulateShotQuery, SimulateShotQueryVariables>(
-    SimulateShotDocument,
-    options,
-  );
-}
-export function useSimulateShotLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    SimulateShotQuery,
-    SimulateShotQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<SimulateShotQuery, SimulateShotQueryVariables>(
-    SimulateShotDocument,
-    options,
-  );
-}
-export function useSimulateShotSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    SimulateShotQuery,
-    SimulateShotQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<SimulateShotQuery, SimulateShotQueryVariables>(
-    SimulateShotDocument,
-    options,
-  );
-}
-export type SimulateShotQueryHookResult = ReturnType<
-  typeof useSimulateShotQuery
->;
-export type SimulateShotLazyQueryHookResult = ReturnType<
-  typeof useSimulateShotLazyQuery
->;
-export type SimulateShotSuspenseQueryHookResult = ReturnType<
-  typeof useSimulateShotSuspenseQuery
->;
-export type SimulateShotQueryResult = Apollo.QueryResult<
-  SimulateShotQuery,
-  SimulateShotQueryVariables
->;
-export const ComputePotAimDocument = gql`
-  query ComputePotAim(
-    $simulationInput: SimulateShotInputGQL!
-    $targetBallId: Int!
-    $pocket: PocketIdentifier!
-  ) {
-    computePotAim(
-      simulationInput: $simulationInput
-      targetBallId: $targetBallId
-      pocket: $pocket
-    ) {
-      phi
-      geometricPhi
-      cutAngle
-      requiredPrecision
-      feasible
-      potted
-      converged
-      occludingBallIds
-    }
-  }
-`;
-
-/**
- * __useComputePotAimQuery__
- *
- * To run a query within a React component, call `useComputePotAimQuery` and pass it any options that fit your needs.
- * When your component renders, `useComputePotAimQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useComputePotAimQuery({
- *   variables: {
- *      simulationInput: // value for 'simulationInput'
- *      targetBallId: // value for 'targetBallId'
- *      pocket: // value for 'pocket'
- *   },
- * });
- */
-export function useComputePotAimQuery(
-  baseOptions: Apollo.QueryHookOptions<
-    ComputePotAimQuery,
-    ComputePotAimQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useQuery<ComputePotAimQuery, ComputePotAimQueryVariables>(
-    ComputePotAimDocument,
-    options,
-  );
-}
-export function useComputePotAimLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<
-    ComputePotAimQuery,
-    ComputePotAimQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useLazyQuery<ComputePotAimQuery, ComputePotAimQueryVariables>(
-    ComputePotAimDocument,
-    options,
-  );
-}
-export function useComputePotAimSuspenseQuery(
-  baseOptions?: Apollo.SuspenseQueryHookOptions<
-    ComputePotAimQuery,
-    ComputePotAimQueryVariables
-  >,
-) {
-  const options = { ...defaultOptions, ...baseOptions };
-  return Apollo.useSuspenseQuery<
-    ComputePotAimQuery,
-    ComputePotAimQueryVariables
-  >(ComputePotAimDocument, options);
-}
-export type ComputePotAimQueryHookResult = ReturnType<
-  typeof useComputePotAimQuery
->;
-export type ComputePotAimLazyQueryHookResult = ReturnType<
-  typeof useComputePotAimLazyQuery
->;
-export type ComputePotAimSuspenseQueryHookResult = ReturnType<
-  typeof useComputePotAimSuspenseQuery
->;
-export type ComputePotAimQueryResult = Apollo.QueryResult<
-  ComputePotAimQuery,
-  ComputePotAimQueryVariables
->;
 export const GetSerializedShotPathsDocument = gql`
   query GetSerializedShotPaths($filterInput: FilterInput!) {
     getShots(filterInput: $filterInput) {
@@ -15934,6 +15795,13 @@ export const GetUploadLinkDocument = gql`
                 }
               }
             }
+            ... on StorageLimitExceededErr {
+              reason
+              tierName
+              retainedStorageUsedBytes
+              retainedStorageLimitBytes
+              remainingStorageBytes
+            }
           }
         }
       }

src/operations/config.gql

@@ -7,6 +7,7 @@ query getDeployedConfig {
     minimumAllowedAppVersion
     subscriptionGatingEnabled
     quotaEnforcementEnabled
+    storageLimitEnforcementEnabled
     bannerMessages {
       color
       dismissible

src/operations/payments.gql

@@ -67,6 +67,37 @@ query GetSubscriptionStatus {
   }
 }
 
+query GetResolvedTier {
+  getResolvedTier {
+    tierName
+    tierDisplayName
+    hasActiveSubscription
+    entitlementSource
+    entitlementStatus
+    entitlementStartsAt
+    entitlementEndsAt
+    capabilities
+  }
+}
+
+query GetStorageStatus {
+  getStorageStatus {
+    userId
+    tierName
+    retainedStorageUsedBytes
+    retainedStorageLimitBytes
+    isUnlimited
+    policyConfigured
+    remainingStorageBytes
+    storageUsageRatio
+    isNearLimit
+    isOverLimit
+    usageCalculated
+    usageSource
+    lastCalculatedAt
+  }
+}
+
 query GetAppleAppAccountToken {
   getAppleAppAccountToken
 }

src/operations/shot_simulation.gql

@@ -1,57 +0,0 @@
-query GetTableState(
-  $b64Image: String!
-  $tableSize: Float
-  $useHomography: HomographyInputGQL
-) {
-  getTableState(
-    b64Image: $b64Image
-    tableSize: $tableSize
-    useHomography: $useHomography
-  ) {
-    identifierToPosition
-  }
-}
-
-query SimulateShot($simulationInput: SimulateShotInputGQL!) {
-  simulateShot(simulationInput: $simulationInput) {
-    trajectories {
-      ballId
-      points {
-        time
-        position
-      }
-    }
-    events {
-      eventType
-      time
-      ballIds
-      position
-    }
-    finalState {
-      ballId
-      position
-    }
-    pottedBallIds
-  }
-}
-
-query ComputePotAim(
-  $simulationInput: SimulateShotInputGQL!
-  $targetBallId: Int!
-  $pocket: PocketIdentifier!
-) {
-  computePotAim(
-    simulationInput: $simulationInput
-    targetBallId: $targetBallId
-    pocket: $pocket
-  ) {
-    phi
-    geometricPhi
-    cutAngle
-    requiredPrecision
-    feasible
-    potted
-    converged
-    occludingBallIds
-  }
-}

src/operations/video_upload.gql

@@ -37,6 +37,13 @@ mutation GetUploadLink($videoId: Int!, $segmentIndex: Int!) {
               }
             }
           }
+          ... on StorageLimitExceededErr {
+            reason
+            tierName
+            retainedStorageUsedBytes
+            retainedStorageLimitBytes
+            remainingStorageBytes
+          }
         }
       }
     }

src/schema.gql

@@ -67,11 +67,6 @@ type Query {
     useHomography: HomographyInputGQL = null
   ): TableStateGQL!
   simulateShot(simulationInput: SimulateShotInputGQL!): ShotProjectionGQL!
-  computePotAim(
-    simulationInput: SimulateShotInputGQL!
-    targetBallId: Int!
-    pocket: PocketIdentifier!
-  ): PotAimGQL!
   getOrderedShots(
     filterInput: FilterInput!
     ids: [Int!] = null
@@ -1035,17 +1030,6 @@ input SimulationBallStateInputGQL {
   position: [Float!]!
 }
 
-type PotAimGQL {
-  phi: Float!
-  geometricPhi: Float!
-  cutAngle: Float!
-  requiredPrecision: Float!
-  feasible: Boolean!
-  potted: Boolean!
-  converged: Boolean!
-  occludingBallIds: [Int!]!
-}
-
 type GetShotsResult {
   shots: [ShotGQL!]!
   count: Int