carddb 0.2.2 → 0.3.5

data/lib/carddb/query_builder.rb

@@ -109,6 +109,61 @@ module CardDB
         GRAPHQL
       end
 
+      def list_games(publisher_id:, first: nil, after: nil, include_archived: nil)
+        args = build_args(
+          { publisherId: publisher_id, first: first, after: after, includeArchived: include_archived },
+          required: [:publisherId]
+        )
+
+        <<~GRAPHQL
+          query Games#{args[:definition]} {
+            games#{args[:call]} {
+              #{game_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game(id: nil, publisher_id: nil, publisher_slug: nil, game_key: nil, game_slug: nil)
+        args = build_args(
+          {
+            id: id,
+            publisherId: publisher_id,
+            publisherSlug: publisher_slug,
+            gameKey: game_key,
+            gameSlug: game_slug
+          }
+        )
+
+        <<~GRAPHQL
+          query Game#{args[:definition]} {
+            game#{args[:call]} {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_game
+        <<~GRAPHQL
+          mutation GameCreate($input: GameCreateInput!) {
+            gameCreate(input: $input) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_game
+        <<~GRAPHQL
+          mutation GameUpdate($id: UUID!, $input: GameUpdateInput!) {
+            gameUpdate(id: $id, input: $input) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a searchDatasets query
       def search_datasets(publisher_slug: nil, game_key: nil, search: nil, purpose: nil, first: nil, after: nil)
         args = build_args({
@@ -164,6 +219,55 @@ module CardDB
         GRAPHQL
       end
 
+      def list_datasets(
+        publisher_id:,
+        game_id: nil,
+        purpose: nil,
+        first: nil,
+        after: nil,
+        include_archived: nil
+      )
+        args = build_args(
+          {
+            publisherId: publisher_id,
+            gameId: game_id,
+            purpose: purpose,
+            first: first,
+            after: after,
+            includeArchived: include_archived
+          },
+          required: [:publisherId]
+        )
+
+        <<~GRAPHQL
+          query Datasets#{args[:definition]} {
+            datasets#{args[:call]} {
+              #{dataset_connection_fields(include_schema: true)}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset(id: nil, publisher_id: nil, game_id: nil, dataset_key: nil)
+        args = build_args(
+          {
+            id: id,
+            publisherId: publisher_id,
+            gameId: game_id,
+            datasetKey: dataset_key
+          }
+        )
+
+        <<~GRAPHQL
+          query Dataset#{args[:definition]} {
+            dataset#{args[:call]} {
+              #{dataset_fields}
+              #{schema_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a searchRecords query
       # rubocop:disable Metrics/ParameterLists
       def search_records(
@@ -252,263 +356,1174 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a myDecks query
-      def list_my_decks(first: nil, after: nil)
-        args = build_args({ first: first, after: after })
+      def list_dataset_records(
+        dataset_id:,
+        filter: nil,
+        order_by: nil,
+        first: nil,
+        after: nil,
+        last: nil,
+        before: nil,
+        validate_schema: nil
+      )
+        args = build_args(
+          {
+            datasetId: dataset_id,
+            filter: filter,
+            orderBy: order_by,
+            first: first,
+            after: after,
+            last: last,
+            before: before,
+            validateSchema: validate_schema
+          },
+          required: [:datasetId],
+          type_overrides: { orderBy: 'DatasetRecordOrderByInput' }
+        )
 
         <<~GRAPHQL
-          query MyDecks#{args[:definition]} {
-            myDecks#{args[:call]} {
-              #{deck_connection_fields}
+          query DatasetRecords#{args[:definition]} {
+            datasetRecords#{args[:call]} {
+              #{record_connection_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a fetchDeck query
-      def fetch_deck
+      def dataset_record(**params)
+        args = build_args(
+          {
+            id: params[:id],
+            datasetId: params[:dataset_id],
+            identifier: params[:identifier],
+            publisherSlug: params[:publisher_slug],
+            gameKey: params[:game_key],
+            datasetKey: params[:dataset_key],
+            recordId: params[:record_id],
+            resolveLinks: params[:resolve_links],
+            validateSchema: params[:validate_schema]
+          }
+        )
+        include_links = params[:resolve_links]&.any?
+        links_fields = resolved_links_fields if include_links
+
         <<~GRAPHQL
-          query FetchDeck($id: UUID!) {
-            fetchDeck(id: $id) {
-              #{deck_fields}
+          query DatasetRecord#{args[:definition]} {
+            datasetRecord#{args[:call]} {
+              #{record_fields(include_pricing: params.fetch(:include_pricing, false))}
+              #{links_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a myDeck query
-      def my_deck
+      def upsert_dataset_records
         <<~GRAPHQL
-          query MyDeck($id: UUID!) {
-            myDeck(id: $id) {
-              #{deck_fields}
+          mutation DatasetRecordsUpsert($input: DatasetRecordsUpsertInput!) {
+            datasetRecordsUpsert(input: $input) {
+              #{dataset_records_upsert_payload_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a fetchDeckBySlug query
-      def fetch_deck_by_slug
+      def delete_dataset_records
         <<~GRAPHQL
-          query FetchDeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
-            fetchDeckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
-              #{deck_fields}
+          mutation DatasetRecordsDelete($input: DatasetRecordsDeleteInput!) {
+            datasetRecordsDelete(input: $input) {
+              #{dataset_record_delete_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a fetchDeckByExternalRef query
-      def fetch_deck_by_external_ref
+      def dataset_record_delete_job
         <<~GRAPHQL
-          query FetchDeckByExternalRef($externalRef: String!) {
-            fetchDeckByExternalRef(externalRef: $externalRef) {
-              #{deck_fields}
+          query DatasetRecordDeleteJob($id: UUID!) {
+            datasetRecordDeleteJob(id: $id) {
+              #{dataset_record_delete_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckVersion query
-      def deck_version
+      def dataset_record_delete_jobs(publisher_id:, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          { publisherId: publisher_id, datasetId: dataset_id, status: status, first: first, after: after },
+          required: [:publisherId],
+          type_overrides: { status: 'DatasetRecordDeleteJobStatus' }
+        )
+
         <<~GRAPHQL
-          query DeckVersion($id: UUID!) {
-            deckVersion(id: $id) {
-              #{deck_version_fields}
+          query DatasetRecordDeleteJobs#{args[:definition]} {
+            datasetRecordDeleteJobs#{args[:call]} {
+              #{dataset_record_delete_job_connection_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckVersions query
-      def deck_versions(first: nil, after: nil)
-        args = build_args({ deckId: true, first: first, after: after }, required: [:deckId])
+      def dataset_import_preview
+        <<~GRAPHQL
+          query DatasetImportPreview($input: DatasetImportPreviewInput!) {
+            datasetImportPreview(input: $input) {
+              #{dataset_import_preview_fields}
+            }
+          }
+        GRAPHQL
+      end
 
+      def dataset_import_validate
         <<~GRAPHQL
-          query DeckVersions#{args[:definition]} {
-            deckVersions#{args[:call]} {
-              #{deck_version_connection_fields}
+          query DatasetImportValidate($input: DatasetImportValidateInput!) {
+            datasetImportValidate(input: $input) {
+              #{bulk_import_result_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreview query
-      def deck_preview
+      def dataset_import_from_file
         <<~GRAPHQL
-          query DeckPreview($token: String!) {
-            deckPreview(token: $token) {
-              #{deck_fields}
+          mutation DatasetImportFromFile($input: DatasetImportFromFileInput!) {
+            datasetImportFromFile(input: $input) {
+              #{import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCollaborators query
-      def deck_collaborators
+      def dataset_import_from_payload
         <<~GRAPHQL
-          query DeckCollaborators($deckId: UUID!) {
-            deckCollaborators(deckId: $deckId) {
-              #{deck_collaborator_fields}
+          mutation DatasetImportFromPayload($input: DatasetImportFromPayloadInput!) {
+            datasetImportFromPayload(input: $input) {
+              #{import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokens query
-      def deck_preview_tokens
+      def dataset_import_from_url
         <<~GRAPHQL
-          query DeckPreviewTokens($deckId: UUID!) {
-            deckPreviewTokens(deckId: $deckId) {
-              #{deck_preview_token_fields}
+          mutation DatasetImportFromUrl($input: DatasetImportFromUrlInput!) {
+            datasetImportFromUrl(input: $input) {
+              #{import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCreate mutation
-      def create_deck
+      def import_job
         <<~GRAPHQL
-          mutation DeckCreate($input: DeckCreateInput!) {
-            deckCreate(input: $input) {
-              #{deck_fields}
+          query ImportJob($id: UUID!) {
+            importJob(id: $id) {
+              #{import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckUpdate mutation
-      def update_deck
+      def import_jobs(publisher_id:, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          { publisherId: publisher_id, datasetId: dataset_id, status: status, first: first, after: after },
+          required: [:publisherId],
+          type_overrides: { status: 'ImportJobStatus' }
+        )
+
         <<~GRAPHQL
-          mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
-            deckUpdate(id: $id, input: $input) {
-              #{deck_fields}
+          query ImportJobs#{args[:definition]} {
+            importJobs#{args[:call]} {
+              #{import_job_connection_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPublish mutation
-      def publish_deck
+      def import_job_cancel
         <<~GRAPHQL
-          mutation DeckPublish($id: UUID!, $input: DeckPublishInput!) {
-            deckPublish(id: $id, input: $input) {
-              #{deck_version_fields}
+          mutation ImportJobCancel($id: UUID!) {
+            importJobCancel(id: $id) {
+              #{import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCollaboratorUpsert mutation
-      def upsert_deck_collaborator
+      def import_job_logs(level: nil, dataset_key: nil, first: nil, after: nil)
+        log_args = build_args(
+          { level: level, datasetKey: dataset_key, first: first, after: after },
+          type_overrides: { level: 'ImportLogLevel' }
+        )
+
         <<~GRAPHQL
-          mutation DeckCollaboratorUpsert($deckId: UUID!, $accountId: UUID!, $role: DeckCollaboratorRole!) {
-            deckCollaboratorUpsert(deckId: $deckId, accountId: $accountId, role: $role) {
-              #{deck_collaborator_fields}
+          query ImportJobLogs($importJobId: UUID!#{log_args[:definition].sub('(', ', ').sub(')', '')}) {
+            importJob(id: $importJobId) {
+              logs#{log_args[:call]} {
+                #{import_job_log_connection_fields}
+              }
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCollaboratorRemove mutation
-      def remove_deck_collaborator
+      def game_import_preview
         <<~GRAPHQL
-          mutation DeckCollaboratorRemove($deckId: UUID!, $accountId: UUID!) {
-            deckCollaboratorRemove(deckId: $deckId, accountId: $accountId)
+          query GameImportPreview($input: GameImportPreviewInput!) {
+            gameImportPreview(input: $input) {
+              #{game_import_preview_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenCreate mutation
-      def create_deck_preview_token
+      def game_import_from_file
         <<~GRAPHQL
-          mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
-            deckPreviewTokenCreate(input: $input) {
-              token
-              previewToken {
-                #{deck_preview_token_fields}
-              }
+          mutation GameImportFromFile($input: GameImportFromFileInput!) {
+            gameImportFromFile(input: $input) {
+              #{game_import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenRevoke mutation
-      def revoke_deck_preview_token
+      def game_import_from_payload
         <<~GRAPHQL
-          mutation DeckPreviewTokenRevoke($id: UUID!) {
-            deckPreviewTokenRevoke(id: $id)
+          mutation GameImportFromPayload($input: GameImportFromPayloadInput!) {
+            gameImportFromPayload(input: $input) {
+              #{game_import_job_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a deckDelete mutation
-      def delete_deck
+      def game_import_from_url
         <<~GRAPHQL
-          mutation DeckDelete($id: UUID!) {
-            deckDelete(id: $id)
+          mutation GameImportFromUrl($input: GameImportFromUrlInput!) {
+            gameImportFromUrl(input: $input) {
+              #{game_import_job_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a fetchMe query
-      def fetch_me
+      def game_import_job
         <<~GRAPHQL
-          query FetchMe {
-            fetchMe {
-              application {
-                id
-                name
-                description
-                environment
-                apiKeyPrefix
-                allowedOrigins
-                allowedIps
-                createdAt
-                updatedAt
-                lastUsedAt
-              }
-              account {
-                id
-                displayName
-                createdAt
-              }
+          query GameImportJob($id: UUID!) {
+            gameImportJob(id: $id) {
+              #{game_import_job_fields}
             }
           }
         GRAPHQL
       end
 
-      private
+      def game_import_jobs(game_id:, status: nil, first: nil, after: nil)
+        args = build_args(
+          { gameId: game_id, status: status, first: first, after: after },
+          required: [:gameId],
+          type_overrides: { status: 'ImportJobStatus' }
+        )
 
-      def build_args(params, required: [])
-        # Filter out nil values
-        params = params.compact
+        <<~GRAPHQL
+          query GameImportJobs#{args[:definition]} {
+            gameImportJobs#{args[:call]} {
+              #{game_import_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
 
-        return { definition: '', call: '' } if params.empty?
+      def game_import_job_cancel
+        <<~GRAPHQL
+          mutation GameImportJobCancel($id: UUID!) {
+            gameImportJobCancel(id: $id) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
 
-        # Map Ruby types to GraphQL types (base types, without !)
-        type_map = {
-          publisherSlug: 'String',
-          gameKey: 'String',
-          datasetKey: 'String',
-          search: 'String',
-          orderBy: 'String',
-          filter: 'JSON',
-          resolveLinks: '[String!]',
-          first: 'Int',
-          after: 'String',
-          externalRef: 'String',
-          deckId: 'UUID!',
-          validateSchema: 'Boolean',
-          purpose: 'DatasetPurpose',
-          id: 'UUID!',
-          ids: '[UUID!]!'
-        }
+      def file
+        <<~GRAPHQL
+          query File($id: UUID!) {
+            file(id: $id) {
+              #{file_fields}
+            }
+          }
+        GRAPHQL
+      end
 
-        definitions = params.keys.map do |k|
-          base_type = type_map[k] || 'String'
-          # Add ! for required fields (unless already has !)
-          type = required.include?(k) && !base_type.end_with?('!') ? "#{base_type}!" : base_type
+      def file_upload_request
+        <<~GRAPHQL
+          mutation FileUploadRequest($input: FileUploadInput!) {
+            fileUploadRequest(input: $input) {
+              #{presigned_upload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file_upload_confirm
+        <<~GRAPHQL
+          mutation FileUploadConfirm($id: UUID!) {
+            fileUploadConfirm(id: $id) {
+              #{file_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file_delete
+        <<~GRAPHQL
+          mutation FileDelete($id: UUID!) {
+            fileDelete(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def export_job
+        <<~GRAPHQL
+          query ExportJob($id: UUID!) {
+            exportJob(id: $id) {
+              #{export_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def export_jobs(publisher_id:, game_id: nil, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          {
+            publisherId: publisher_id,
+            gameId: game_id,
+            datasetId: dataset_id,
+            status: status,
+            first: first,
+            after: after
+          },
+          required: [:publisherId],
+          type_overrides: { status: 'ExportJobStatus' }
+        )
+
+        <<~GRAPHQL
+          query ExportJobs#{args[:definition]} {
+            exportJobs#{args[:call]} {
+              #{export_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_export
+        <<~GRAPHQL
+          mutation DatasetExport($input: DatasetExportInput!) {
+            datasetExport(input: $input) {
+              #{export_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def export_job_cancel
+        <<~GRAPHQL
+          mutation ExportJobCancel($id: UUID!) {
+            exportJobCancel(id: $id) {
+              #{export_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def export_job_refresh_url
+        <<~GRAPHQL
+          mutation ExportJobRefreshUrl($id: UUID!) {
+            exportJobRefreshUrl(id: $id) {
+              #{export_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a myDecks query
+      def list_my_decks(first: nil, after: nil, include_archived: nil)
+        args = build_args({ first: first, after: after, includeArchived: include_archived })
+
+        <<~GRAPHQL
+          query MyDecks#{args[:definition]} {
+            myDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def viewer_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'ViewerDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query ViewerDecks#{args[:definition]} {
+            viewerDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def app_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'AppDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query AppDecks#{args[:definition]} {
+            appDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def public_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'PublicDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query PublicDecks#{args[:definition]} {
+            publicDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDeck query
+      def fetch_deck
+        <<~GRAPHQL
+          query FetchDeck($id: UUID!) {
+            fetchDeck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck
+        <<~GRAPHQL
+          query Deck($id: UUID!) {
+            deck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a myDeck query
+      def my_deck
+        <<~GRAPHQL
+          query MyDeck($id: UUID!) {
+            myDeck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDeckBySlug query
+      def fetch_deck_by_slug
+        <<~GRAPHQL
+          query FetchDeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
+            fetchDeckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_by_slug
+        <<~GRAPHQL
+          query DeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
+            deckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDeckByExternalRef query
+      def fetch_deck_by_external_ref
+        <<~GRAPHQL
+          query FetchDeckByExternalRef($externalRef: String!) {
+            fetchDeckByExternalRef(externalRef: $externalRef) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_by_external_ref
+        <<~GRAPHQL
+          query DeckByExternalRef($externalRef: String!) {
+            deckByExternalRef(externalRef: $externalRef) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckVersion query
+      def deck_version
+        <<~GRAPHQL
+          query DeckVersion($id: UUID!) {
+            deckVersion(id: $id) {
+              #{deck_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckVersions query
+      def deck_versions(first: nil, after: nil)
+        args = build_args({ deckId: true, first: first, after: after }, required: [:deckId])
+
+        <<~GRAPHQL
+          query DeckVersions#{args[:definition]} {
+            deckVersions#{args[:call]} {
+              #{deck_version_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreview query
+      def deck_preview
+        <<~GRAPHQL
+          query DeckPreview($token: String!) {
+            deckPreview(token: $token) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_embed
+        <<~GRAPHQL
+          query DeckEmbed($token: String!) {
+            deckEmbed(token: $token) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_access
+        <<~GRAPHQL
+          query DeckAccess($token: String!) {
+            deckAccess(token: $token) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_draft_diff
+        <<~GRAPHQL
+          query DeckDraftDiff($id: UUID!) {
+            deckDraftDiff(id: $id) {
+              #{deck_diff_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_version_diff
+        <<~GRAPHQL
+          query DeckVersionDiff($fromVersionId: UUID!, $toVersionId: UUID!) {
+            deckVersionDiff(fromVersionId: $fromVersionId, toVersionId: $toVersionId) {
+              #{deck_diff_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_hydrate_entries
+        <<~GRAPHQL
+          query DeckHydrateEntries($input: DeckHydrateEntriesInput!) {
+            deckHydrateEntries(input: $input) {
+              #{deck_hydrate_entries_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_export
+        <<~GRAPHQL
+          query DeckExport($id: UUID!, $format: DeckExportFormat!) {
+            deckExport(id: $id, format: $format) {
+              #{deck_export_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_validate
+        <<~GRAPHQL
+          query DeckValidate($id: UUID!, $input: DeckValidateInput) {
+            deckValidate(id: $id, input: $input) {
+              #{deck_validation_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_section_definitions(publisher_slug: nil, game_key: nil, game_id: nil, ruleset_key: nil, ruleset_version_id: nil)
+        args = build_args({
+                            publisherSlug: publisher_slug,
+                            gameKey: game_key,
+                            gameId: game_id,
+                            rulesetKey: ruleset_key,
+                            rulesetVersionId: ruleset_version_id
+                          })
+
+        <<~GRAPHQL
+          query DeckSectionDefinitions#{args[:definition]} {
+            deckSectionDefinitions#{args[:call]} {
+              #{deck_section_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaborators query
+      def deck_collaborators
+        <<~GRAPHQL
+          query DeckCollaborators($deckId: UUID!) {
+            deckCollaborators(deckId: $deckId) {
+              #{deck_collaborator_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreviewTokens query
+      def deck_preview_tokens
+        <<~GRAPHQL
+          query DeckPreviewTokens($deckId: UUID!) {
+            deckPreviewTokens(deckId: $deckId) {
+              #{deck_preview_token_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_embed_tokens
+        <<~GRAPHQL
+          query DeckEmbedTokens($deckId: UUID!) {
+            deckEmbedTokens(deckId: $deckId) {
+              #{deck_embed_token_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_access_token_issuers
+        <<~GRAPHQL
+          query DeckAccessTokenIssuers($deckId: UUID!) {
+            deckAccessTokenIssuers(deckId: $deckId) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_api_application_accesses
+        <<~GRAPHQL
+          query DeckApiApplicationAccesses($deckId: UUID!, $includeRevoked: Boolean) {
+            deckApiApplicationAccesses(deckId: $deckId, includeRevoked: $includeRevoked) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def my_deck_api_application_accesses
+        <<~GRAPHQL
+          query MyDeckApiApplicationAccesses($applicationId: UUID) {
+            myDeckApiApplicationAccesses(applicationId: $applicationId) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_formats(publisher_id: nil, game_id: nil, include_archived: nil, first: nil, after: nil)
+        args = build_args(
+          { publisherId: publisher_id, gameId: game_id, includeArchived: include_archived, first: first, after: after }
+        )
+
+        <<~GRAPHQL
+          query DeckImportFormats#{args[:definition]} {
+            deckImportFormats#{args[:call]} {
+              #{deck_import_format_definition_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_format
+        <<~GRAPHQL
+          query DeckImportFormat($id: UUID, $gameId: UUID, $key: String) {
+            deckImportFormat(id: $id, gameId: $gameId, key: $key) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_format_test
+        <<~GRAPHQL
+          query DeckImportFormatTest($input: DeckImportFormatTestInput!) {
+            deckImportFormatTest(input: $input) {
+              #{deck_import_format_test_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCreate mutation
+      def create_deck
+        <<~GRAPHQL
+          mutation DeckCreate($input: DeckCreateInput!) {
+            deckCreate(input: $input) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckUpdate mutation
+      def update_deck
+        <<~GRAPHQL
+          mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
+            deckUpdate(id: $id, input: $input) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def add_deck_entry
+        <<~GRAPHQL
+          mutation DeckEntryAdd($input: DeckEntryAddInput!) {
+            deckEntryAdd(input: $input) {
+              #{deck_entry_mutation_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_deck_entry
+        <<~GRAPHQL
+          mutation DeckEntryUpdate($id: UUID!, $input: DeckEntryUpdateInput!) {
+            deckEntryUpdate(id: $id, input: $input) {
+              #{deck_entry_mutation_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def remove_deck_entry
+        <<~GRAPHQL
+          mutation DeckEntryRemove($id: UUID!, $expectedDraftRevision: Int!) {
+            deckEntryRemove(id: $id, expectedDraftRevision: $expectedDraftRevision) {
+              #{deck_entry_mutation_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def reorder_deck_entries
+        <<~GRAPHQL
+          mutation DeckEntryReorder($deckId: UUID!, $input: DeckEntryReorderInput!) {
+            deckEntryReorder(deckId: $deckId, input: $input) {
+              #{deck_entry_reorder_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def replace_deck_entries
+        <<~GRAPHQL
+          mutation DeckEntriesReplace($deckId: UUID!, $input: DeckEntriesReplaceInput!) {
+            deckEntriesReplace(deckId: $deckId, input: $input) {
+              #{deck_entry_reorder_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_deck
+        <<~GRAPHQL
+          mutation DeckImport($input: DeckImportInput!) {
+            deckImport(input: $input) {
+              #{deck_import_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatCreate($input: DeckImportFormatCreateInput!) {
+            deckImportFormatCreate(input: $input) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatUpdate($id: UUID!, $input: DeckImportFormatUpdateInput!) {
+            deckImportFormatUpdate(id: $id, input: $input) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def archive_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatArchive($id: UUID!) {
+            deckImportFormatArchive(id: $id) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def unarchive_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatUnarchive($id: UUID!) {
+            deckImportFormatUnarchive(id: $id) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def upsert_deck_by_external_ref
+        <<~GRAPHQL
+          mutation DeckUpsertByExternalRef($input: DeckUpsertByExternalRefInput!) {
+            deckUpsertByExternalRef(input: $input) {
+              deck {
+                #{deck_fields}
+              }
+              created
+              idempotentReplay
+            }
+          }
+        GRAPHQL
+      end
+
+      def claim_deck
+        <<~GRAPHQL
+          mutation DeckClaim($id: UUID!, $input: DeckClaimInput!) {
+            deckClaim(id: $id, input: $input) {
+              #{deck_ownership_transfer_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def transfer_deck_ownership
+        <<~GRAPHQL
+          mutation DeckTransferOwnership($id: UUID!, $input: DeckTransferOwnershipInput!) {
+            deckTransferOwnership(id: $id, input: $input) {
+              #{deck_ownership_transfer_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def copy_deck
+        <<~GRAPHQL
+          mutation DeckCopy($id: UUID!, $input: DeckCopyInput!) {
+            deckCopy(id: $id, input: $input) {
+              #{deck_copy_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def archive_deck
+        <<~GRAPHQL
+          mutation DeckArchive($id: UUID!) {
+            deckArchive(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def restore_deck
+        <<~GRAPHQL
+          mutation DeckRestore($id: UUID!) {
+            deckRestore(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def unpublish_deck
+        <<~GRAPHQL
+          mutation DeckUnpublish($id: UUID!) {
+            deckUnpublish(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPublish mutation
+      def publish_deck
+        <<~GRAPHQL
+          mutation DeckPublish($id: UUID!, $input: DeckPublishInput!) {
+            deckPublish(id: $id, input: $input) {
+              #{deck_publish_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def remove_invalid_deck_entries
+        <<~GRAPHQL
+          mutation DeckRemoveInvalidEntries($id: UUID!, $input: DeckRemoveInvalidEntriesInput!) {
+            deckRemoveInvalidEntries(id: $id, input: $input) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaboratorUpsert mutation
+      def upsert_deck_collaborator
+        <<~GRAPHQL
+          mutation DeckCollaboratorUpsert($deckId: UUID!, $accountId: UUID!, $role: DeckCollaboratorRole!) {
+            deckCollaboratorUpsert(deckId: $deckId, accountId: $accountId, role: $role) {
+              #{deck_collaborator_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaboratorRemove mutation
+      def remove_deck_collaborator
+        <<~GRAPHQL
+          mutation DeckCollaboratorRemove($deckId: UUID!, $accountId: UUID!) {
+            deckCollaboratorRemove(deckId: $deckId, accountId: $accountId)
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreviewTokenCreate mutation
+      def create_deck_preview_token
+        <<~GRAPHQL
+          mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
+            deckPreviewTokenCreate(input: $input) {
+              token
+              previewToken {
+                #{deck_preview_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreviewTokenRevoke mutation
+      def revoke_deck_preview_token
+        <<~GRAPHQL
+          mutation DeckPreviewTokenRevoke($id: UUID!) {
+            deckPreviewTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def create_deck_embed_token
+        <<~GRAPHQL
+          mutation DeckEmbedTokenCreate($input: DeckEmbedTokenCreateInput!) {
+            deckEmbedTokenCreate(input: $input) {
+              token
+              embedToken {
+                #{deck_embed_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_embed_token
+        <<~GRAPHQL
+          mutation DeckEmbedTokenRevoke($id: UUID!) {
+            deckEmbedTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def create_deck_access_token_issuer
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
+            deckAccessTokenIssuerCreate(input: $input) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token_issuer
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerRevoke($id: UUID!) {
+            deckAccessTokenIssuerRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token_issuer_signing_key
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerSigningKeyRevoke($id: UUID!) {
+            deckAccessTokenIssuerSigningKeyRevoke(id: $id) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def exchange_deck_access_token
+        <<~GRAPHQL
+          mutation DeckAccessTokenExchange($input: DeckAccessTokenExchangeInput!) {
+            deckAccessTokenExchange(input: $input) {
+              token
+              accessToken {
+                #{deck_access_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token
+        <<~GRAPHQL
+          mutation DeckAccessTokenRevoke($id: UUID!) {
+            deckAccessTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def grant_deck_api_application_access
+        <<~GRAPHQL
+          mutation DeckApiApplicationAccessGrant($input: DeckAPIApplicationAccessGrantInput!) {
+            deckApiApplicationAccessGrant(input: $input) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_api_application_access
+        <<~GRAPHQL
+          mutation DeckApiApplicationAccessRevoke($deckId: UUID!, $apiApplicationId: UUID!) {
+            deckApiApplicationAccessRevoke(deckId: $deckId, apiApplicationId: $apiApplicationId)
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckDelete mutation
+      def delete_deck
+        <<~GRAPHQL
+          mutation DeckDelete($id: UUID!) {
+            deckDelete(id: $id)
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchMe query
+      def fetch_me
+        <<~GRAPHQL
+          query FetchMe {
+            fetchMe {
+              application {
+                id
+                name
+                description
+                environment
+                apiKeyPrefix
+                allowedOrigins
+                allowedIps
+                createdAt
+                updatedAt
+                lastUsedAt
+              }
+              account {
+                id
+                displayName
+                createdAt
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def build_args(params, required: [], type_overrides: {})
+        # Filter out nil values
+        params = params.compact
+
+        return { definition: '', call: '' } if params.empty?
+
+        # Map Ruby types to GraphQL types (base types, without !)
+        type_map = {
+          publisherSlug: 'String',
+          publisherId: 'UUID',
+          gameKey: 'String',
+          gameSlug: 'String',
+          datasetKey: 'String',
+          datasetId: 'UUID',
+          recordId: 'UUID',
+          identifier: 'String',
+          search: 'String',
+          orderBy: 'String',
+          filter: 'JSON',
+          resolveLinks: '[String!]',
+          first: 'Int',
+          after: 'String',
+          last: 'Int',
+          before: 'String',
+          includeArchived: 'Boolean',
+          externalRef: 'String',
+          deckId: 'UUID!',
+          gameId: 'UUID',
+          rulesetKey: 'String',
+          rulesetVersionId: 'UUID',
+          validateSchema: 'Boolean',
+          purpose: 'DatasetPurpose',
+          status: 'String',
+          level: 'String',
+          key: 'String',
+          id: 'UUID!',
+          ids: '[UUID!]!'
+        }
+
+        definitions = params.keys.map do |k|
+          base_type = type_overrides[k] || type_map[k] || 'String'
+          # Add ! for required fields (unless already has !)
+          type = required.include?(k) && !base_type.end_with?('!') ? "#{base_type}!" : base_type
           "$#{k}: #{type}"
         end
         calls = params.keys.map { |k| "#{k}: $#{k}" }
@@ -518,6 +1533,34 @@ module CardDB
           call: "(#{calls.join(', ')})"
         }
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def file_fields
+        <<~FIELDS
+          id
+          createdAt
+          updatedAt
+          key
+          filename
+          contentType
+          size
+          status
+          isPublic
+          entityType
+          entityId
+          url
+        FIELDS
+      end
+
+      def presigned_upload_fields
+        <<~FIELDS
+          file {
+            #{file_fields}
+          }
+          uploadUrl
+          expiresAt
+        FIELDS
+      end
 
       def publisher_fields
         <<~FIELDS
@@ -565,8 +1608,11 @@ module CardDB
           key
           name
           description
+          metafyGameUuid
+          metafyGameSlug
           website
           visibility
+          archivedAt
           isArchived
           createdAt
           updatedAt
@@ -613,8 +1659,13 @@ module CardDB
           name
           description
           purpose
+          activeVersionId
           tcgplayerProductIdFieldKey
           visibility
+          posX
+          posY
+          sortOrder
+          archivedAt
           isArchived
           createdAt
           updatedAt
@@ -645,11 +1696,16 @@ module CardDB
               targetDatasetKey
               targetDatasetName
               targetDatasetId
+              targetFieldKey
+              linkAlias
+              linkDirection
+              isArray
             }
           }
         FIELDS
       end
 
+      # rubocop:disable Metrics/MethodLength
       def field_info_fields(depth:)
         nested_fields = if depth.positive?
                           <<~FIELDS
@@ -668,15 +1724,36 @@ module CardDB
           filterable
           searchable
           isIdentifier
+          sortOrder
           itemType
+          linkDatasetId
+          linkDatasetKey
+          linkDatasetName
+          linkFieldKey
+          linkAlias
+          linkDirection
           displayFormat
           semanticType
+          placeholder
+          isHidden
+          isComputed
+          isSystemField
+          defaultValue
           allowedValues
+          minLength
+          maxLength
+          minValue
+          maxValue
+          pattern
+          isUnique
           #{nested_fields}
         FIELDS
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def dataset_connection_fields(include_schema: false)
+        node_fields = include_schema ? "#{dataset_fields}\n#{schema_fields}" : dataset_fields
 
-      def dataset_connection_fields
         <<~FIELDS
           totalCount
           pageInfo {
@@ -688,7 +1765,7 @@ module CardDB
           edges {
             cursor
             node {
-              #{dataset_fields}
+              #{node_fields}
             }
           }
         FIELDS
@@ -730,24 +1807,448 @@ module CardDB
         FIELDS
       end
 
-      def record_connection_fields(include_resolved_links: false, include_pricing: false)
-        resolved_links_field = if include_resolved_links
-                                 <<~FIELDS
-                                   resolvedLinks {
-                                     field
-                                     linkFieldKey
-                                     values
-                                     records {
-                                       id
-                                       datasetId
-                                       data
-                                     }
-                                   }
-                                 FIELDS
-                               else
-                                 ''
-                               end
+      def record_connection_fields(include_resolved_links: false, include_pricing: false)
+        resolved_links_field = include_resolved_links ? resolved_links_fields : ''
+
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{record_fields(include_pricing: include_pricing)}
+              #{resolved_links_field}
+            }
+          }
+        FIELDS
+      end
+
+      def resolved_links_fields
+        <<~FIELDS
+          resolvedLinks {
+            field
+            linkFieldKey
+            values
+            records {
+              id
+              datasetId
+              data
+            }
+          }
+        FIELDS
+      end
+
+      def object_field_fields
+        <<~FIELDS
+          id
+          objectTypeId
+          key
+          label
+          dataType
+          isRequired
+          isFilterable
+          isSearchable
+          isIdentifier
+          sortOrder
+          description
+          placeholder
+          displayFormat
+          semanticType
+          isHidden
+          isComputed
+          isSystemField
+          defaultValue
+          allowedValues
+          minLength
+          maxLength
+          minValue
+          maxValue
+          pattern
+          isUnique
+          itemType
+          linkDatasetId
+          linkFieldKey
+          linkAlias
+          linkDirection
+          parentFieldId
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def bulk_record_error_fields
+        <<~FIELDS
+          datasetKey
+          index
+          errors {
+            field
+            message
+            details
+          }
+        FIELDS
+      end
+
+      def import_stats_fields
+        <<~FIELDS
+          total
+          inserted
+          updated
+          skipped
+          failed
+        FIELDS
+      end
+
+      def bulk_import_result_fields
+        <<~FIELDS
+          inserted {
+            #{record_fields}
+          }
+          updated {
+            #{record_fields}
+          }
+          skipped
+          errors {
+            #{bulk_record_error_fields}
+          }
+          createdFields {
+            #{object_field_fields}
+          }
+          stats {
+            #{import_stats_fields}
+          }
+        FIELDS
+      end
+
+      def import_job_asset_fields
+        <<~FIELDS
+          fileId
+          filename
+          file {
+            #{file_fields}
+          }
+        FIELDS
+      end
+
+      def import_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+            #{schema_fields}
+          }
+          accountId
+          status
+          mode
+          onConflict
+          format
+          fileId
+          progress
+          totalRecords
+          processedRecords
+          insertedCount
+          updatedCount
+          skippedCount
+          failedCount
+          createdFields {
+            #{object_field_fields}
+          }
+          errors {
+            #{bulk_record_error_fields}
+          }
+          errorMessage
+          assets {
+            #{import_job_asset_fields}
+          }
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          lastCheckpointIndex
+          isResumed
+          imagesPending
+          imagesCompleted
+          imagesFailed
+        FIELDS
+      end
+
+      def import_job_log_fields
+        <<~FIELDS
+          id
+          importJobId
+          level
+          message
+          datasetKey
+          recordIndex
+          fieldKey
+          details
+          createdAt
+        FIELDS
+      end
+
+      def dataset_records_upsert_payload_fields
+        <<~FIELDS
+          job {
+            #{import_job_fields}
+          }
+          dryRunResult {
+            #{bulk_import_result_fields}
+          }
+        FIELDS
+      end
+
+      def dataset_record_delete_job_result_fields
+        <<~FIELDS
+          target
+          recordId
+          identifier
+          status
+          message
+        FIELDS
+      end
+
+      def dataset_record_delete_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+          }
+          accountId
+          status
+          targetType
+          dryRun
+          targets
+          progress
+          totalTargets
+          processedTargets
+          matchedCount
+          deletedCount
+          missingCount
+          blockedCount
+          failedCount
+          results {
+            #{dataset_record_delete_job_result_fields}
+          }
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def field_mapping_fields
+        <<~FIELDS
+          sourceField
+          targetField
+          targetFieldLabel
+          inferredType
+          inferredItemType
+          inferredChildren {
+            key
+            label
+            type
+            required
+            itemType
+            children {
+              key
+              label
+              type
+              required
+              itemType
+            }
+          }
+          inferredLinkDataset
+          inferredLinkFieldKey
+          inferredLinkDirection
+          targetFieldType
+          sampleValues
+          status
+        FIELDS
+      end
+
+      def import_warning_fields
+        <<~FIELDS
+          datasetKey
+          field
+          message
+          severity
+        FIELDS
+      end
+
+      def dataset_import_preview_fields
+        <<~FIELDS
+          datasetKey
+          datasetName
+          datasetId
+          exists
+          recordCount
+          fieldMappings {
+            #{field_mapping_fields}
+          }
+          warnings {
+            #{import_warning_fields}
+          }
+          canProceed
+          sampleRecords
+          availableDatasets {
+            #{dataset_fields}
+            #{schema_fields}
+          }
+        FIELDS
+      end
+
+      def game_import_preview_fields
+        <<~FIELDS
+          datasets {
+            datasetKey
+            datasetName
+            datasetId
+            exists
+            recordCount
+            fieldMappings {
+              #{field_mapping_fields}
+            }
+            warnings {
+              #{import_warning_fields}
+            }
+            sampleRecords
+          }
+          importOrder
+          warnings {
+            #{import_warning_fields}
+          }
+          canProceed
+        FIELDS
+      end
+
+      def game_import_dataset_status_fields
+        <<~FIELDS
+          datasetKey
+          datasetId
+          datasetName
+          status
+          recordCount
+          insertedCount
+          updatedCount
+          skippedCount
+          failedCount
+          errorMessage
+        FIELDS
+      end
+
+      def game_import_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          gameId
+          game {
+            #{game_fields}
+          }
+          accountId
+          status
+          mode
+          onConflict
+          fileId
+          assets {
+            #{import_job_asset_fields}
+          }
+          totalDatasets
+          completedDatasets
+          progress
+          importOrder
+          datasetStatuses {
+            #{game_import_dataset_status_fields}
+          }
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          completedDatasetKeys
+          currentDatasetKey
+          lastCheckpointIndex
+          isResumed
+          imagesPending
+          imagesCompleted
+          imagesFailed
+          phase
+          linkBuildingDataset
+          linkBuildingTotalDatasets
+          linkBuildingCompletedDatasets
+          linkBuildingProcessedRecords
+          linkBuildingTotalRecords
+        FIELDS
+      end
+
+      def export_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+          }
+          accountId
+          status
+          format
+          filter
+          totalRecords
+          processedRecords
+          progress
+          fileId
+          downloadUrl
+          downloadExpiresAt
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          lastCheckpointIndex
+        FIELDS
+      end
+
+      def import_job_connection_fields
+        connection_fields(import_job_fields)
+      end
+
+      def import_job_log_connection_fields
+        connection_fields(import_job_log_fields)
+      end
+
+      def game_import_job_connection_fields
+        connection_fields(game_import_job_fields)
+      end
+
+      def dataset_record_delete_job_connection_fields
+        connection_fields(dataset_record_delete_job_fields)
+      end
+
+      def export_job_connection_fields
+        connection_fields(export_job_fields)
+      end
 
+      def connection_fields(node_fields)
         <<~FIELDS
           totalCount
           pageInfo {
@@ -759,16 +2260,115 @@ module CardDB
           edges {
             cursor
             node {
-              #{record_fields(include_pricing: include_pricing)}
-              #{resolved_links_field}
+              #{node_fields}
             }
           }
         FIELDS
       end
 
+      def deck_section_definition_fields
+        <<~FIELDS
+          key
+          label
+          description
+          order
+          default
+          aliases
+          minCards
+          maxCards
+          excludedFromDeckSize
+          legalCardTypes
+          metadata
+        FIELDS
+      end
+
+      def deck_entry_fields
+        <<~FIELDS
+          id
+          datasetId
+          recordId
+          identifier
+          quantity
+          section
+          sortOrder
+          annotations
+          display
+          record {
+            #{record_fields}
+          }
+        FIELDS
+      end
+
+      def deck_validated_against_fields
+        <<~FIELDS
+          rulesetId
+          rulesetVersionId
+          rulesetVersionLabel
+          cardDatasetId
+          cardDatasetVersionId
+          validatedAt
+          validationResultSummary
+        FIELDS
+      end
+
+      def deck_validation_issue_fields
+        <<~FIELDS
+          code
+          severity
+          message
+          entryIds
+          section
+          datasetId
+          identifier
+          metadata
+        FIELDS
+      end
+
+      def deck_validation_fields
+        <<~FIELDS
+          deckId
+          valid
+          blockers {
+            #{deck_validation_issue_fields}
+          }
+          warnings {
+            #{deck_validation_issue_fields}
+          }
+          affectedEntries {
+            entryId
+            datasetId
+            recordId
+            identifier
+            section
+            quantity
+          }
+          validatedAgainst {
+            #{deck_validated_against_fields}
+          }
+          checkedAt
+        FIELDS
+      end
+
+      def deck_diff_fields
+        <<~FIELDS
+          deckId
+          fromVersionId
+          toVersionId
+          toDraftRevision
+          hasChanges
+          diff
+        FIELDS
+      end
+
       def deck_fields
         <<~FIELDS
           id
+          ownerType
+          ownerAccountId
+          ownerApiApplicationId
+          environment
+          createdByAccountId
+          createdByApiApplicationId
           accountId
           apiApplicationId
           gameId
@@ -778,13 +2378,29 @@ module CardDB
           description
           formatKey
           visibility
+          accessMode
+          discoverability
+          state
+          archivedAt
+          deletedAt
+          unpublishedAt
+          externalRefApiApplicationId
           externalRef
+          externalSubjectRef
+          rulesetId
           sourceUrl
           metadata
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
           latestPublishedVersion {
             #{deck_version_fields}
           }
           publishedAt
+          draftRevision
+          draftUpdatedAt
+          draftUpdatedByAccountId
+          draftUpdatedByApiApplicationId
           hasUnpublishedChanges
           createdAt
           updatedAt
@@ -792,18 +2408,58 @@ module CardDB
             #{game_fields}
           }
           entries {
-            id
-            datasetId
-            recordId
-            identifier
-            quantity
-            section
-            sortOrder
-            annotations
-            record {
-              #{record_fields}
-            }
+            #{deck_entry_fields}
+          }
+        FIELDS
+      end
+
+      def deck_ownership_transfer_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          retainedAppAccess
+        FIELDS
+      end
+
+      def deck_copy_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          copiedFromDeckId
+          retainedAppAccess
+        FIELDS
+      end
+
+      def deck_access_application_fields
+        <<~FIELDS
+          id
+          name
+          description
+          revokedAt
+        FIELDS
+      end
+
+      def deck_api_application_access_fields
+        <<~FIELDS
+          id
+          deckId
+          deck {
+            #{deck_fields}
+          }
+          apiApplicationId
+          apiApplication {
+            #{deck_access_application_fields}
           }
+          role
+          grantSource
+          externalRef
+          createdByAccountId
+          createdByApiApplicationId
+          revokedAt
+          createdAt
+          updatedAt
         FIELDS
       end
 
@@ -821,23 +2477,67 @@ module CardDB
           externalRef
           sourceUrl
           metadata
+          entries {
+            #{deck_entry_fields}
+          }
           publishNote
           computedDiff
+          rulesetId
+          rulesetVersionId
+          cardDatasetId
+          cardDatasetVersionId
+          validatedAt
+          validationSummary
+          validatedAgainst {
+            #{deck_validated_against_fields}
+          }
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
           publishedByAccountId
           publishedByApiApplicationId
           createdAt
+        FIELDS
+      end
+
+      def deck_publish_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          version {
+            #{deck_version_fields}
+          }
+          validation {
+            #{deck_validation_fields}
+          }
+          blockers {
+            #{deck_validation_issue_fields}
+          }
+          warnings {
+            #{deck_validation_issue_fields}
+          }
+        FIELDS
+      end
+
+      def deck_entry_mutation_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          entry {
+            #{deck_entry_fields}
+          }
+        FIELDS
+      end
+
+      def deck_entry_reorder_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
           entries {
-            id
-            datasetId
-            recordId
-            identifier
-            quantity
-            section
-            sortOrder
-            annotations
-            record {
-              #{record_fields}
-            }
+            #{deck_entry_fields}
           }
         FIELDS
       end
@@ -885,6 +2585,217 @@ module CardDB
         FIELDS
       end
 
+      def deck_embed_token_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          label
+          readMode
+          allowedOrigins
+          externalSubject
+          expiresAt
+          revokedAt
+          lastUsedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_access_token_issuer_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          label
+          readModes
+          maxTokenLifetimeSeconds
+          directSigningAlg
+          directSigningKeyId
+          directSigningPublicKey
+          directSigningKeyRevokedAt
+          revokedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_access_token_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          issuerId
+          readMode
+          externalSubject
+          expiresAt
+          revokedAt
+          lastUsedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_import_entry_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          datasetId
+          recordId
+          identifier
+          quantity
+          section
+          sortOrder
+          display
+          record {
+            #{record_fields}
+          }
+        FIELDS
+      end
+
+      def deck_import_issue_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          code
+          message
+        FIELDS
+      end
+
+      def deck_import_unmatched_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          identifier
+          quantity
+          section
+          code
+          message
+        FIELDS
+      end
+
+      def deck_import_ambiguous_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          identifier
+          quantity
+          section
+          candidates {
+            recordId
+            identifier
+            display
+          }
+        FIELDS
+      end
+
+      def deck_import_format_definition_fields
+        <<~FIELDS
+          id
+          gameId
+          key
+          name
+          description
+          enabled
+          priority
+          datasetKey
+          config
+          archivedAt
+          isArchived
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_import_format_detection_fields
+        <<~FIELDS
+          formatId
+          key
+          name
+          confidence
+          reason
+        FIELDS
+      end
+
+      def deck_import_format_test_payload_fields
+        <<~FIELDS
+          detection {
+            #{deck_import_format_detection_fields}
+          }
+          entries {
+            #{deck_import_entry_fields}
+          }
+          parseErrors {
+            #{deck_import_issue_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+        FIELDS
+      end
+
+      def deck_hydrate_entries_payload_fields
+        <<~FIELDS
+          entries {
+            #{deck_import_entry_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+        FIELDS
+      end
+
+      def deck_import_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          applied
+          dryRun
+          replace
+          format
+          importFormat {
+            #{deck_import_format_definition_fields}
+          }
+          detection {
+            #{deck_import_format_detection_fields}
+          }
+          entries {
+            #{deck_import_entry_fields}
+          }
+          parseErrors {
+            #{deck_import_issue_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+          validation {
+            #{deck_validation_fields}
+          }
+        FIELDS
+      end
+
+      def deck_export_payload_fields
+        <<~FIELDS
+          deckId
+          format
+          text
+          entryCount
+        FIELDS
+      end
+
       def deck_connection_fields
         <<~FIELDS
           totalCount
@@ -902,6 +2813,24 @@ module CardDB
           }
         FIELDS
       end
+
+      def deck_import_format_definition_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        FIELDS
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end