carddb 0.2.2 → 0.3.0

data/lib/carddb/query_builder.rb

@@ -253,8 +253,8 @@ module CardDB
       end
 
       # Builds a myDecks query
-      def list_my_decks(first: nil, after: nil)
-        args = build_args({ first: first, after: after })
+      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]} {
@@ -265,6 +265,51 @@ module CardDB
         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
@@ -276,6 +321,16 @@ module CardDB
         GRAPHQL
       end
 
+      def deck
+        <<~GRAPHQL
+          query Deck($id: UUID!) {
+            deck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a myDeck query
       def my_deck
         <<~GRAPHQL
@@ -298,6 +353,16 @@ module CardDB
         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
@@ -309,6 +374,16 @@ module CardDB
         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
@@ -344,6 +419,94 @@ module CardDB
         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
@@ -366,6 +529,81 @@ module CardDB
         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(game_id:, include_archived: nil, first: nil, after: nil)
+        args = build_args(
+          { gameId: game_id, includeArchived: include_archived, first: first, after: after },
+          required: [:gameId]
+        )
+
+        <<~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!) {
+            deckImportFormat(id: $id) {
+              #{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
@@ -388,12 +626,196 @@ module CardDB
         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_version_fields}
+              #{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
@@ -433,11 +855,99 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenRevoke mutation
-      def revoke_deck_preview_token
+      # 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 DeckPreviewTokenRevoke($id: UUID!) {
-            deckPreviewTokenRevoke(id: $id)
+          mutation DeckApiApplicationAccessRevoke($deckId: UUID!, $apiApplicationId: UUID!) {
+            deckApiApplicationAccessRevoke(deckId: $deckId, apiApplicationId: $apiApplicationId)
           }
         GRAPHQL
       end
@@ -480,7 +990,7 @@ module CardDB
 
       private
 
-      def build_args(params, required: [])
+      def build_args(params, required: [], type_overrides: {})
         # Filter out nil values
         params = params.compact
 
@@ -497,8 +1007,12 @@ module CardDB
           resolveLinks: '[String!]',
           first: 'Int',
           after: 'String',
+          includeArchived: 'Boolean',
           externalRef: 'String',
           deckId: 'UUID!',
+          gameId: 'UUID',
+          rulesetKey: 'String',
+          rulesetVersionId: 'UUID',
           validateSchema: 'Boolean',
           purpose: 'DatasetPurpose',
           id: 'UUID!',
@@ -506,7 +1020,7 @@ module CardDB
         }
 
         definitions = params.keys.map do |k|
-          base_type = type_map[k] || 'String'
+          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}"
@@ -766,9 +1280,109 @@ module CardDB
         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 +1392,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 +1422,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 +1491,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 +1599,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 +1827,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