diff --git a/src/index.tsx b/src/index.tsx index 05a02be..8401e87 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -2440,6 +2440,7 @@ export type Mutation = { reactToVideo: Scalars["Boolean"]["output"]; recalculateChallengeEntry: ChallengeEntry; reportContent: Scalars["Boolean"]["output"]; + requestVideoExport: VideoExportJobGql; respondToChallengeInvitation: ChallengeInvitation; retireTags: Scalars["Boolean"]["output"]; revokeManualEntitlement: UserSubscriptionStatusGql; @@ -2613,6 +2614,10 @@ export type MutationReportContentArgs = { videoId: Scalars["Int"]["input"]; }; +export type MutationRequestVideoExportArgs = { + input: RequestVideoExportInput; +}; + export type MutationRespondToChallengeInvitationArgs = { accept: Scalars["Boolean"]["input"]; invitationId: Scalars["ID"]["input"]; @@ -2706,6 +2711,7 @@ export enum NotificationTypeEnum { ChallengeInvite = "CHALLENGE_INVITE", Comment = "COMMENT", CommentReply = "COMMENT_REPLY", + ExportReady = "EXPORT_READY", Follow = "FOLLOW", Reaction = "REACTION", } @@ -2877,9 +2883,11 @@ export type Query = { myChallengeEntries: Array; myChallengeInvitations: Array; myDismissedChallenges: Array; + myVideoExports: Array; notifications: NotificationConnection; ruleSets: Array; unreadNotificationCount: Scalars["Int"]["output"]; + videoExportJob?: Maybe; videoPlayerClusters: Array; waitFor: Scalars["Float"]["output"]; }; @@ -3056,12 +3064,21 @@ export type QueryIsChallengeDismissedArgs = { challengeId: Scalars["ID"]["input"]; }; +export type QueryMyVideoExportsArgs = { + limit?: Scalars["Int"]["input"]; + offset?: Scalars["Int"]["input"]; +}; + export type QueryNotificationsArgs = { filters?: InputMaybe; limit?: Scalars["Int"]["input"]; offset?: Scalars["Int"]["input"]; }; +export type QueryVideoExportJobArgs = { + jobId: Scalars["Int"]["input"]; +}; + export type QueryVideoPlayerClustersArgs = { videoId: Scalars["Int"]["input"]; }; @@ -3121,6 +3138,13 @@ export enum ReportReasonEnum { Violence = "VIOLENCE", } +export type RequestVideoExportInput = { + mode: VideoExportModeEnum; + runId?: InputMaybe; + shotIds?: InputMaybe>; + videoId: Scalars["Int"]["input"]; +}; + export type RequestedMedalsGql = { __typename?: "RequestedMedalsGQL"; dailyMakes50?: Maybe; @@ -3648,6 +3672,35 @@ export type UserSubscriptionStatusGql = { validUntil?: Maybe; }; +export type VideoExportJobGql = { + __typename?: "VideoExportJobGQL"; + createdAt?: Maybe; + downloadUrl?: Maybe; + expiresAt?: Maybe; + fileSizeBytes?: Maybe; + id: Scalars["Int"]["output"]; + mode: VideoExportModeEnum; + runId?: Maybe; + shotIds?: Maybe>; + status: VideoExportStatusEnum; + videoId: Scalars["Int"]["output"]; +}; + +export enum VideoExportModeEnum { + FullSession = "FULL_SESSION", + Run = "RUN", + Shots = "SHOTS", +} + +export enum VideoExportStatusEnum { + Created = "CREATED", + Expired = "EXPIRED", + Failed = "FAILED", + Queued = "QUEUED", + Running = "RUNNING", + Succeeded = "SUCCEEDED", +} + export type VideoFeedInputGql = | { allUsers: Scalars["Boolean"]["input"]; @@ -7015,6 +7068,84 @@ export type HomographyInfoFragment = { }; }; +export type VideoExportJobFieldsFragment = { + __typename?: "VideoExportJobGQL"; + id: number; + videoId: number; + mode: VideoExportModeEnum; + status: VideoExportStatusEnum; + shotIds?: Array | null; + runId?: number | null; + downloadUrl?: string | null; + fileSizeBytes?: number | null; + expiresAt?: any | null; + createdAt?: any | null; +}; + +export type RequestVideoExportMutationVariables = Exact<{ + input: RequestVideoExportInput; +}>; + +export type RequestVideoExportMutation = { + __typename?: "Mutation"; + requestVideoExport: { + __typename?: "VideoExportJobGQL"; + id: number; + videoId: number; + mode: VideoExportModeEnum; + status: VideoExportStatusEnum; + shotIds?: Array | null; + runId?: number | null; + downloadUrl?: string | null; + fileSizeBytes?: number | null; + expiresAt?: any | null; + createdAt?: any | null; + }; +}; + +export type VideoExportJobQueryVariables = Exact<{ + jobId: Scalars["Int"]["input"]; +}>; + +export type VideoExportJobQuery = { + __typename?: "Query"; + videoExportJob?: { + __typename?: "VideoExportJobGQL"; + id: number; + videoId: number; + mode: VideoExportModeEnum; + status: VideoExportStatusEnum; + shotIds?: Array | null; + runId?: number | null; + downloadUrl?: string | null; + fileSizeBytes?: number | null; + expiresAt?: any | null; + createdAt?: any | null; + } | null; +}; + +export type MyVideoExportsQueryVariables = Exact<{ + limit?: InputMaybe; + offset?: InputMaybe; +}>; + +export type MyVideoExportsQuery = { + __typename?: "Query"; + myVideoExports: Array<{ + __typename?: "VideoExportJobGQL"; + id: number; + videoId: number; + mode: VideoExportModeEnum; + status: VideoExportStatusEnum; + shotIds?: Array | null; + runId?: number | null; + downloadUrl?: string | null; + fileSizeBytes?: number | null; + expiresAt?: any | null; + createdAt?: any | null; + }>; +}; + export type CreateUploadStreamMutationVariables = Exact<{ videoMetadataInput: VideoMetadataInput; expectedDurationSeconds?: InputMaybe; @@ -7580,6 +7711,20 @@ export const HomographyInfoFragmentDoc = gql` } } `; +export const VideoExportJobFieldsFragmentDoc = gql` + fragment VideoExportJobFields on VideoExportJobGQL { + id + videoId + mode + status + shotIds + runId + downloadUrl + fileSizeBytes + expiresAt + createdAt + } +`; export const UploadStreamWithDetailsFragmentDoc = gql` fragment UploadStreamWithDetails on VideoGQL { id @@ -14991,6 +15136,206 @@ export type FindPrerecordTableLayoutMutationOptions = FindPrerecordTableLayoutMutation, FindPrerecordTableLayoutMutationVariables >; +export const RequestVideoExportDocument = gql` + mutation RequestVideoExport($input: RequestVideoExportInput!) { + requestVideoExport(input: $input) { + ...VideoExportJobFields + } + } + ${VideoExportJobFieldsFragmentDoc} +`; +export type RequestVideoExportMutationFn = Apollo.MutationFunction< + RequestVideoExportMutation, + RequestVideoExportMutationVariables +>; + +/** + * __useRequestVideoExportMutation__ + * + * To run a mutation, you first call `useRequestVideoExportMutation` within a React component and pass it any options that fit your needs. + * When your component renders, `useRequestVideoExportMutation` 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 [requestVideoExportMutation, { data, loading, error }] = useRequestVideoExportMutation({ + * variables: { + * input: // value for 'input' + * }, + * }); + */ +export function useRequestVideoExportMutation( + baseOptions?: Apollo.MutationHookOptions< + RequestVideoExportMutation, + RequestVideoExportMutationVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useMutation< + RequestVideoExportMutation, + RequestVideoExportMutationVariables + >(RequestVideoExportDocument, options); +} +export type RequestVideoExportMutationHookResult = ReturnType< + typeof useRequestVideoExportMutation +>; +export type RequestVideoExportMutationResult = + Apollo.MutationResult; +export type RequestVideoExportMutationOptions = Apollo.BaseMutationOptions< + RequestVideoExportMutation, + RequestVideoExportMutationVariables +>; +export const VideoExportJobDocument = gql` + query VideoExportJob($jobId: Int!) { + videoExportJob(jobId: $jobId) { + ...VideoExportJobFields + } + } + ${VideoExportJobFieldsFragmentDoc} +`; + +/** + * __useVideoExportJobQuery__ + * + * To run a query within a React component, call `useVideoExportJobQuery` and pass it any options that fit your needs. + * When your component renders, `useVideoExportJobQuery` 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 } = useVideoExportJobQuery({ + * variables: { + * jobId: // value for 'jobId' + * }, + * }); + */ +export function useVideoExportJobQuery( + baseOptions: Apollo.QueryHookOptions< + VideoExportJobQuery, + VideoExportJobQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useQuery( + VideoExportJobDocument, + options, + ); +} +export function useVideoExportJobLazyQuery( + baseOptions?: Apollo.LazyQueryHookOptions< + VideoExportJobQuery, + VideoExportJobQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useLazyQuery( + VideoExportJobDocument, + options, + ); +} +export function useVideoExportJobSuspenseQuery( + baseOptions?: Apollo.SuspenseQueryHookOptions< + VideoExportJobQuery, + VideoExportJobQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useSuspenseQuery< + VideoExportJobQuery, + VideoExportJobQueryVariables + >(VideoExportJobDocument, options); +} +export type VideoExportJobQueryHookResult = ReturnType< + typeof useVideoExportJobQuery +>; +export type VideoExportJobLazyQueryHookResult = ReturnType< + typeof useVideoExportJobLazyQuery +>; +export type VideoExportJobSuspenseQueryHookResult = ReturnType< + typeof useVideoExportJobSuspenseQuery +>; +export type VideoExportJobQueryResult = Apollo.QueryResult< + VideoExportJobQuery, + VideoExportJobQueryVariables +>; +export const MyVideoExportsDocument = gql` + query MyVideoExports($limit: Int = 30, $offset: Int = 0) { + myVideoExports(limit: $limit, offset: $offset) { + ...VideoExportJobFields + } + } + ${VideoExportJobFieldsFragmentDoc} +`; + +/** + * __useMyVideoExportsQuery__ + * + * To run a query within a React component, call `useMyVideoExportsQuery` and pass it any options that fit your needs. + * When your component renders, `useMyVideoExportsQuery` 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 } = useMyVideoExportsQuery({ + * variables: { + * limit: // value for 'limit' + * offset: // value for 'offset' + * }, + * }); + */ +export function useMyVideoExportsQuery( + baseOptions?: Apollo.QueryHookOptions< + MyVideoExportsQuery, + MyVideoExportsQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useQuery( + MyVideoExportsDocument, + options, + ); +} +export function useMyVideoExportsLazyQuery( + baseOptions?: Apollo.LazyQueryHookOptions< + MyVideoExportsQuery, + MyVideoExportsQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useLazyQuery( + MyVideoExportsDocument, + options, + ); +} +export function useMyVideoExportsSuspenseQuery( + baseOptions?: Apollo.SuspenseQueryHookOptions< + MyVideoExportsQuery, + MyVideoExportsQueryVariables + >, +) { + const options = { ...defaultOptions, ...baseOptions }; + return Apollo.useSuspenseQuery< + MyVideoExportsQuery, + MyVideoExportsQueryVariables + >(MyVideoExportsDocument, options); +} +export type MyVideoExportsQueryHookResult = ReturnType< + typeof useMyVideoExportsQuery +>; +export type MyVideoExportsLazyQueryHookResult = ReturnType< + typeof useMyVideoExportsLazyQuery +>; +export type MyVideoExportsSuspenseQueryHookResult = ReturnType< + typeof useMyVideoExportsSuspenseQuery +>; +export type MyVideoExportsQueryResult = Apollo.QueryResult< + MyVideoExportsQuery, + MyVideoExportsQueryVariables +>; export const CreateUploadStreamDocument = gql` mutation CreateUploadStream( $videoMetadataInput: VideoMetadataInput! diff --git a/src/operations/video_export.gql b/src/operations/video_export.gql new file mode 100644 index 0000000..86a1fb2 --- /dev/null +++ b/src/operations/video_export.gql @@ -0,0 +1,30 @@ +fragment VideoExportJobFields on VideoExportJobGQL { + id + videoId + mode + status + shotIds + runId + downloadUrl + fileSizeBytes + expiresAt + createdAt +} + +mutation RequestVideoExport($input: RequestVideoExportInput!) { + requestVideoExport(input: $input) { + ...VideoExportJobFields + } +} + +query VideoExportJob($jobId: Int!) { + videoExportJob(jobId: $jobId) { + ...VideoExportJobFields + } +} + +query MyVideoExports($limit: Int = 30, $offset: Int = 0) { + myVideoExports(limit: $limit, offset: $offset) { + ...VideoExportJobFields + } +} diff --git a/src/schema.gql b/src/schema.gql index 5115084..f87bd38 100644 --- a/src/schema.gql +++ b/src/schema.gql @@ -121,6 +121,8 @@ type Query { ): VideoHistoryGQL! getUserTags(includeRetiredTags: Boolean = false): [TagGQL!]! getGameTypeTagMetrics(input: GameTypeTagMetricsInput!): [GameTypeTagMetric!]! + videoExportJob(jobId: Int!): VideoExportJobGQL + myVideoExports(limit: Int! = 30, offset: Int! = 0): [VideoExportJobGQL!]! getVideo(videoId: Int!, debuggingJson: JSON = null): VideoGQL! getVideos(videoIds: [Int!]!): [VideoGQL!]! } @@ -864,6 +866,7 @@ enum NotificationTypeEnum { REACTION FOLLOW CHALLENGE_INVITE + EXPORT_READY } input NotificationFilters { @@ -1164,6 +1167,34 @@ input GameTypeTagMetricsInput { includePrivate: IncludePrivateEnum! = MINE } +type VideoExportJobGQL { + id: Int! + videoId: Int! + mode: VideoExportModeEnum! + status: VideoExportStatusEnum! + shotIds: [Int!] + runId: Int + downloadUrl: String + fileSizeBytes: Int + expiresAt: DateTime + createdAt: DateTime +} + +enum VideoExportModeEnum { + FULL_SESSION + SHOTS + RUN +} + +enum VideoExportStatusEnum { + CREATED + QUEUED + RUNNING + SUCCEEDED + FAILED + EXPIRED +} + """ The `JSON` scalar type represents JSON values as specified by [ECMA-404](https://ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf). """ @@ -1265,6 +1296,7 @@ type Mutation { feedback: String = null metadata: CancellationFeedbackMetadataInput = null ): Boolean! + requestVideoExport(input: RequestVideoExportInput!): VideoExportJobGQL! findPrerecordTableLayout(b64Image: String!, videoId: Int!): HomographyInfoGQL createUploadStream( videoMetadata: VideoMetadataInput! @@ -1447,6 +1479,13 @@ input CancellationFeedbackMetadataInput { platform: String = null } +input RequestVideoExportInput { + videoId: Int! + mode: VideoExportModeEnum! + shotIds: [Int!] = null + runId: Int = null +} + type CreateUploadStreamReturn { videoId: Int! }