@carddb/core 0.1.4 → 0.2.0

package/dist/index.js

@@ -301,6 +301,7 @@ var DATASET_FIELDS = `
   name
   description
   purpose
+  tcgplayerProductIdFieldKey
   visibility
   isArchived
   createdAt
@@ -354,19 +355,112 @@ var SCHEMA_FIELDS = `
     }
   }
 `;
-var RECORD_FIELDS = `
+var TCGPLAYER_PRICING_FIELDS = `
+  pricing {
+    productId
+    prices {
+      subTypeName
+      lowPrice
+      midPrice
+      highPrice
+      marketPrice
+      directLowPrice
+    }
+  }
+`;
+function recordFields(options = {}) {
+  return `
+    id
+    datasetId
+    data
+    ${options.includePricing ? TCGPLAYER_PRICING_FIELDS : ""}
+    createdAt
+    updatedAt
+    dataset {
+      id
+      key
+      name
+      gameId
+      publisherId
+    }
+  `;
+}
+var RECORD_FIELDS = recordFields();
+var DECK_SECTION_DEFINITION_FIELDS = `
+  key
+  label
+  description
+  order
+  default
+  aliases
+  minCards
+  maxCards
+  excludedFromDeckSize
+  legalCardTypes
+  metadata
+`;
+var DECK_ENTRY_FIELDS = `
   id
   datasetId
-  data
-  createdAt
-  updatedAt
-  dataset {
-    id
-    key
-    name
-    gameId
-    publisherId
+  recordId
+  identifier
+  quantity
+  section
+  sortOrder
+  annotations
+  display
+  record {
+    ${RECORD_FIELDS}
+  }
+`;
+var DECK_VALIDATED_AGAINST_FIELDS = `
+  rulesetId
+  rulesetVersionId
+  rulesetVersionLabel
+  cardDatasetId
+  cardDatasetVersionId
+  validatedAt
+  validationResultSummary
+`;
+var DECK_VALIDATION_ISSUE_FIELDS = `
+  code
+  severity
+  message
+  entryIds
+  section
+  datasetId
+  identifier
+  metadata
+`;
+var DECK_VALIDATION_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
+`;
+var DECK_DIFF_FIELDS = `
+  deckId
+  fromVersionId
+  toVersionId
+  toDraftRevision
+  hasChanges
+  diff
 `;
 var DECK_VERSION_FIELDS = `
   id
@@ -383,21 +477,23 @@ var DECK_VERSION_FIELDS = `
   metadata
   publishNote
   computedDiff
+  rulesetId
+  rulesetVersionId
+  cardDatasetId
+  cardDatasetVersionId
+  validatedAt
+  validationSummary
+  validatedAgainst {
+    ${DECK_VALIDATED_AGAINST_FIELDS}
+  }
+  sectionDefinitions {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
   publishedByAccountId
   publishedByApiApplicationId
   createdAt
   entries {
-    id
-    datasetId
-    recordId
-    identifier
-    quantity
-    section
-    sortOrder
-    annotations
-    record {
-      ${RECORD_FIELDS}
-    }
+    ${DECK_ENTRY_FIELDS}
   }
 `;
 var DECK_COLLABORATOR_FIELDS = `
@@ -419,8 +515,156 @@ var DECK_PREVIEW_TOKEN_FIELDS = `
   createdAt
   updatedAt
 `;
+var DECK_EMBED_TOKEN_FIELDS = `
+  id
+  deckId
+  apiApplicationId
+  label
+  readMode
+  allowedOrigins
+  externalSubject
+  expiresAt
+  revokedAt
+  lastUsedAt
+  createdAt
+  updatedAt
+`;
+var DECK_ACCESS_TOKEN_ISSUER_FIELDS = `
+  id
+  deckId
+  apiApplicationId
+  label
+  readModes
+  maxTokenLifetimeSeconds
+  directSigningAlg
+  directSigningKeyId
+  directSigningPublicKey
+  directSigningKeyRevokedAt
+  revokedAt
+  createdAt
+  updatedAt
+`;
+var DECK_ACCESS_TOKEN_FIELDS = `
+  id
+  deckId
+  apiApplicationId
+  issuerId
+  readMode
+  externalSubject
+  expiresAt
+  revokedAt
+  lastUsedAt
+  createdAt
+  updatedAt
+`;
+var DECK_IMPORT_ENTRY_FIELDS = `
+  lineNumber
+  raw
+  datasetKey
+  datasetId
+  recordId
+  identifier
+  quantity
+  section
+  sortOrder
+  display
+  record {
+    ${RECORD_FIELDS}
+  }
+`;
+var DECK_IMPORT_ISSUE_FIELDS = `
+  lineNumber
+  raw
+  code
+  message
+`;
+var DECK_IMPORT_UNMATCHED_FIELDS = `
+  lineNumber
+  raw
+  datasetKey
+  identifier
+  quantity
+  section
+  code
+  message
+`;
+var DECK_IMPORT_AMBIGUOUS_FIELDS = `
+  lineNumber
+  raw
+  datasetKey
+  identifier
+  quantity
+  section
+  candidates {
+    recordId
+    identifier
+    display
+  }
+`;
+var DECK_IMPORT_FORMAT_DEFINITION_FIELDS = `
+  id
+  gameId
+  key
+  name
+  description
+  enabled
+  priority
+  datasetKey
+  config
+  archivedAt
+  isArchived
+  createdAt
+  updatedAt
+`;
+var DECK_IMPORT_FORMAT_DETECTION_FIELDS = `
+  formatId
+  key
+  name
+  confidence
+  reason
+`;
+var DECK_IMPORT_FORMAT_TEST_PAYLOAD_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}
+  }
+`;
+var DECK_HYDRATE_ENTRIES_PAYLOAD_FIELDS = `
+  entries {
+    ${DECK_IMPORT_ENTRY_FIELDS}
+  }
+  unmatched {
+    ${DECK_IMPORT_UNMATCHED_FIELDS}
+  }
+  ambiguous {
+    ${DECK_IMPORT_AMBIGUOUS_FIELDS}
+  }
+`;
+var DECK_EXPORT_PAYLOAD_FIELDS = `
+  deckId
+  format
+  text
+  entryCount
+`;
 var DECK_FIELDS = `
   id
+  ownerType
+  ownerAccountId
+  ownerApiApplicationId
+  environment
+  createdByAccountId
+  createdByApiApplicationId
   accountId
   apiApplicationId
   gameId
@@ -430,13 +674,29 @@ var DECK_FIELDS = `
   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
@@ -444,17 +704,109 @@ var DECK_FIELDS = `
     ${GAME_FIELDS}
   }
   entries {
-    id
-    datasetId
-    recordId
-    identifier
-    quantity
-    section
-    sortOrder
-    annotations
-    record {
-      ${RECORD_FIELDS}
-    }
+    ${DECK_ENTRY_FIELDS}
+  }
+`;
+var DECK_OWNERSHIP_TRANSFER_PAYLOAD_FIELDS = `
+  deck {
+    ${DECK_FIELDS}
+  }
+  retainedAppAccess
+`;
+var DECK_COPY_PAYLOAD_FIELDS = `
+  deck {
+    ${DECK_FIELDS}
+  }
+  copiedFromDeckId
+  retainedAppAccess
+`;
+var DECK_ACCESS_APPLICATION_FIELDS = `
+  id
+  name
+  description
+  revokedAt
+`;
+var DECK_API_APPLICATION_ACCESS_FIELDS = `
+  id
+  deckId
+  deck {
+    ${DECK_FIELDS}
+  }
+  apiApplicationId
+  apiApplication {
+    ${DECK_ACCESS_APPLICATION_FIELDS}
+  }
+  role
+  grantSource
+  externalRef
+  createdByAccountId
+  createdByApiApplicationId
+  revokedAt
+  createdAt
+  updatedAt
+`;
+var DECK_PUBLISH_PAYLOAD_FIELDS = `
+  deck {
+    ${DECK_FIELDS}
+  }
+  version {
+    ${DECK_VERSION_FIELDS}
+  }
+  validation {
+    ${DECK_VALIDATION_FIELDS}
+  }
+  blockers {
+    ${DECK_VALIDATION_ISSUE_FIELDS}
+  }
+  warnings {
+    ${DECK_VALIDATION_ISSUE_FIELDS}
+  }
+`;
+var DECK_ENTRY_MUTATION_PAYLOAD_FIELDS = `
+  deck {
+    ${DECK_FIELDS}
+  }
+  entry {
+    ${DECK_ENTRY_FIELDS}
+  }
+`;
+var DECK_ENTRY_REORDER_PAYLOAD_FIELDS = `
+  deck {
+    ${DECK_FIELDS}
+  }
+  entries {
+    ${DECK_ENTRY_FIELDS}
+  }
+`;
+var DECK_ENTRIES_REPLACE_PAYLOAD_FIELDS = DECK_ENTRY_REORDER_PAYLOAD_FIELDS;
+var DECK_IMPORT_PAYLOAD_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}
   }
 `;
 var RESOLVED_LINKS_FIELDS = `
@@ -756,8 +1108,9 @@ var QueryBuilder = {
       variables["validateSchema"] = params.validateSchema;
     }
     const includeResolvedLinks = params.resolveLinks && params.resolveLinks.length > 0;
-    const nodeFields = includeResolvedLinks ? `${RECORD_FIELDS}
-${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
+    const selectedRecordFields = recordFields({ includePricing: params.includePricing });
+    const nodeFields = includeResolvedLinks ? `${selectedRecordFields}
+${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return {
       query: `
         query SearchRecords(${defs.join(", ")}) {
@@ -769,45 +1122,45 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       variables
     };
   },
-  fetchRecordById() {
+  fetchRecordById(params = {}) {
     return {
       query: `
         query FetchRecord($id: UUID!) {
           fetchRecord(id: $id) {
-            ${RECORD_FIELDS}
+            ${recordFields(params)}
           }
         }
       `
     };
   },
-  fetchRecordByIdentifier() {
+  fetchRecordByIdentifier(params = {}) {
     return {
       query: `
         query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
           fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
-            ${RECORD_FIELDS}
+            ${recordFields(params)}
           }
         }
       `
     };
   },
-  fetchRecordsByIdentifier() {
+  fetchRecordsByIdentifier(params = {}) {
     return {
       query: `
         query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
           fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
-            ${RECORD_FIELDS}
+            ${recordFields(params)}
           }
         }
       `
     };
   },
-  fetchRecords() {
+  fetchRecords(params = {}) {
     return {
       query: `
         query FetchRecords($ids: [UUID!]!) {
           fetchRecords(ids: $ids) {
-            ${RECORD_FIELDS}
+            ${recordFields(params)}
           }
         }
       `
@@ -828,6 +1181,11 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       args.push("after: $after");
       variables["after"] = params.after;
     }
+    if (params.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
     const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
     const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
     return {
@@ -841,44 +1199,173 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       variables
     };
   },
-  fetchDeckById() {
+  viewerDecks(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.filter !== void 0) {
+      defs.push("$filter: ViewerDecksFilterInput");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
     return {
       query: `
-        query FetchDeck($id: UUID!) {
-          fetchDeck(id: $id) {
-            ${DECK_FIELDS}
+        query ViewerDecks${defStr} {
+          viewerDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
           }
         }
-      `
+      `,
+      variables
     };
   },
-  myDeck() {
+  appDecks(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.filter !== void 0) {
+      defs.push("$filter: AppDecksFilterInput");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
     return {
       query: `
-        query MyDeck($id: UUID!) {
-          myDeck(id: $id) {
-            ${DECK_FIELDS}
+        query AppDecks${defStr} {
+          appDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
           }
         }
-      `
+      `,
+      variables
     };
   },
-  fetchDeckBySlug() {
+  publicDecks(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.filter !== void 0) {
+      defs.push("$filter: PublicDecksFilterInput");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
     return {
       query: `
-        query FetchDeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
-          fetchDeckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
-            ${DECK_FIELDS}
+        query PublicDecks${defStr} {
+          publicDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
           }
         }
-      `
+      `,
+      variables
     };
   },
-  fetchDeckByExternalRef() {
+  fetchDeckById() {
     return {
       query: `
-        query FetchDeckByExternalRef($externalRef: String!) {
-          fetchDeckByExternalRef(externalRef: $externalRef) {
+        query FetchDeck($id: UUID!) {
+          fetchDeck(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckById() {
+    return {
+      query: `
+        query Deck($id: UUID!) {
+          deck(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  myDeck() {
+    return {
+      query: `
+        query MyDeck($id: UUID!) {
+          myDeck(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchDeckBySlug() {
+    return {
+      query: `
+        query FetchDeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
+          fetchDeckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckBySlug() {
+    return {
+      query: `
+        query DeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
+          deckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchDeckByExternalRef() {
+    return {
+      query: `
+        query FetchDeckByExternalRef($externalRef: String!) {
+          fetchDeckByExternalRef(externalRef: $externalRef) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckByExternalRef() {
+    return {
+      query: `
+        query DeckByExternalRef($externalRef: String!) {
+          deckByExternalRef(externalRef: $externalRef) {
             ${DECK_FIELDS}
           }
         }
@@ -932,6 +1419,125 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       `
     };
   },
+  deckEmbed() {
+    return {
+      query: `
+        query DeckEmbed($token: String!) {
+          deckEmbed(token: $token) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckAccess() {
+    return {
+      query: `
+        query DeckAccess($token: String!) {
+          deckAccess(token: $token) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckDraftDiff() {
+    return {
+      query: `
+        query DeckDraftDiff($id: UUID!) {
+          deckDraftDiff(id: $id) {
+            ${DECK_DIFF_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckVersionDiff() {
+    return {
+      query: `
+        query DeckVersionDiff($fromVersionId: UUID!, $toVersionId: UUID!) {
+          deckVersionDiff(fromVersionId: $fromVersionId, toVersionId: $toVersionId) {
+            ${DECK_DIFF_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckHydrateEntries() {
+    return {
+      query: `
+        query DeckHydrateEntries($input: DeckHydrateEntriesInput!) {
+          deckHydrateEntries(input: $input) {
+            ${DECK_HYDRATE_ENTRIES_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckExport() {
+    return {
+      query: `
+        query DeckExport($id: UUID!, $format: DeckExportFormat!) {
+          deckExport(id: $id, format: $format) {
+            ${DECK_EXPORT_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckValidate() {
+    return {
+      query: `
+        query DeckValidate($id: UUID!, $input: DeckValidateInput) {
+          deckValidate(id: $id, input: $input) {
+            ${DECK_VALIDATION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckSectionDefinitions(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.publisherSlug !== void 0) {
+      defs.push("$publisherSlug: String");
+      args.push("publisherSlug: $publisherSlug");
+      variables["publisherSlug"] = params.publisherSlug;
+    }
+    if (params.gameKey !== void 0) {
+      defs.push("$gameKey: String");
+      args.push("gameKey: $gameKey");
+      variables["gameKey"] = params.gameKey;
+    }
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.rulesetKey !== void 0) {
+      defs.push("$rulesetKey: String");
+      args.push("rulesetKey: $rulesetKey");
+      variables["rulesetKey"] = params.rulesetKey;
+    }
+    if (params.rulesetVersionId !== void 0) {
+      defs.push("$rulesetVersionId: UUID");
+      args.push("rulesetVersionId: $rulesetVersionId");
+      variables["rulesetVersionId"] = params.rulesetVersionId;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query DeckSectionDefinitions${defStr} {
+          deckSectionDefinitions${argStr} {
+            ${DECK_SECTION_DEFINITION_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
   deckCollaborators() {
     return {
       query: `
@@ -943,6 +1549,102 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       `
     };
   },
+  deckEmbedTokens() {
+    return {
+      query: `
+        query DeckEmbedTokens($deckId: UUID!) {
+          deckEmbedTokens(deckId: $deckId) {
+            ${DECK_EMBED_TOKEN_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckAccessTokenIssuers() {
+    return {
+      query: `
+        query DeckAccessTokenIssuers($deckId: UUID!) {
+          deckAccessTokenIssuers(deckId: $deckId) {
+            ${DECK_ACCESS_TOKEN_ISSUER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckApiApplicationAccesses() {
+    return {
+      query: `
+        query DeckApiApplicationAccesses($deckId: UUID!, $includeRevoked: Boolean) {
+          deckApiApplicationAccesses(deckId: $deckId, includeRevoked: $includeRevoked) {
+            ${DECK_API_APPLICATION_ACCESS_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  myDeckApiApplicationAccesses() {
+    return {
+      query: `
+        query MyDeckApiApplicationAccesses($applicationId: UUID) {
+          myDeckApiApplicationAccesses(applicationId: $applicationId) {
+            ${DECK_API_APPLICATION_ACCESS_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckImportFormats(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: UUID!"];
+    if (params.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    return {
+      query: `
+        query DeckImportFormats(${defs.join(", ")}) {
+          deckImportFormats(${args.join(", ")}) {
+            ${connectionFields(DECK_IMPORT_FORMAT_DEFINITION_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  deckImportFormat() {
+    return {
+      query: `
+        query DeckImportFormat($id: UUID!) {
+          deckImportFormat(id: $id) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckImportFormatTest() {
+    return {
+      query: `
+        query DeckImportFormatTest($input: DeckImportFormatTestInput!) {
+          deckImportFormatTest(input: $input) {
+            ${DECK_IMPORT_FORMAT_TEST_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
   deckPreviewTokens() {
     return {
       query: `
@@ -985,12 +1687,214 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       `
     };
   },
+  archiveDeck() {
+    return {
+      query: `
+        mutation DeckArchive($id: UUID!) {
+          deckArchive(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  restoreDeck() {
+    return {
+      query: `
+        mutation DeckRestore($id: UUID!) {
+          deckRestore(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  unpublishDeck() {
+    return {
+      query: `
+        mutation DeckUnpublish($id: UUID!) {
+          deckUnpublish(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  addDeckEntry() {
+    return {
+      query: `
+        mutation DeckEntryAdd($input: DeckEntryAddInput!) {
+          deckEntryAdd(input: $input) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateDeckEntry() {
+    return {
+      query: `
+        mutation DeckEntryUpdate($id: UUID!, $input: DeckEntryUpdateInput!) {
+          deckEntryUpdate(id: $id, input: $input) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  removeDeckEntry() {
+    return {
+      query: `
+        mutation DeckEntryRemove($id: UUID!, $expectedDraftRevision: Int!) {
+          deckEntryRemove(id: $id, expectedDraftRevision: $expectedDraftRevision) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  reorderDeckEntries() {
+    return {
+      query: `
+        mutation DeckEntryReorder($deckId: UUID!, $input: DeckEntryReorderInput!) {
+          deckEntryReorder(deckId: $deckId, input: $input) {
+            ${DECK_ENTRY_REORDER_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  replaceDeckEntries() {
+    return {
+      query: `
+        mutation DeckEntriesReplace($deckId: UUID!, $input: DeckEntriesReplaceInput!) {
+          deckEntriesReplace(deckId: $deckId, input: $input) {
+            ${DECK_ENTRIES_REPLACE_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importDeck() {
+    return {
+      query: `
+        mutation DeckImport($input: DeckImportInput!) {
+          deckImport(input: $input) {
+            ${DECK_IMPORT_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  createDeckImportFormat() {
+    return {
+      query: `
+        mutation DeckImportFormatCreate($input: DeckImportFormatCreateInput!) {
+          deckImportFormatCreate(input: $input) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateDeckImportFormat() {
+    return {
+      query: `
+        mutation DeckImportFormatUpdate($id: UUID!, $input: DeckImportFormatUpdateInput!) {
+          deckImportFormatUpdate(id: $id, input: $input) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  archiveDeckImportFormat() {
+    return {
+      query: `
+        mutation DeckImportFormatArchive($id: UUID!) {
+          deckImportFormatArchive(id: $id) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  unarchiveDeckImportFormat() {
+    return {
+      query: `
+        mutation DeckImportFormatUnarchive($id: UUID!) {
+          deckImportFormatUnarchive(id: $id) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  upsertDeckByExternalRef() {
+    return {
+      query: `
+        mutation DeckUpsertByExternalRef($input: DeckUpsertByExternalRefInput!) {
+          deckUpsertByExternalRef(input: $input) {
+            deck {
+              ${DECK_FIELDS}
+            }
+            created
+            idempotentReplay
+          }
+        }
+      `
+    };
+  },
+  claimDeck() {
+    return {
+      query: `
+        mutation DeckClaim($id: UUID!, $input: DeckClaimInput!) {
+          deckClaim(id: $id, input: $input) {
+            ${DECK_OWNERSHIP_TRANSFER_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  transferDeckOwnership() {
+    return {
+      query: `
+        mutation DeckTransferOwnership($id: UUID!, $input: DeckTransferOwnershipInput!) {
+          deckTransferOwnership(id: $id, input: $input) {
+            ${DECK_OWNERSHIP_TRANSFER_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  copyDeck() {
+    return {
+      query: `
+        mutation DeckCopy($id: UUID!, $input: DeckCopyInput!) {
+          deckCopy(id: $id, input: $input) {
+            ${DECK_COPY_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
   publishDeck() {
     return {
       query: `
         mutation DeckPublish($id: UUID!, $input: DeckPublishInput!) {
           deckPublish(id: $id, input: $input) {
-            ${DECK_VERSION_FIELDS}
+            ${DECK_PUBLISH_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  removeInvalidDeckEntries() {
+    return {
+      query: `
+        mutation DeckRemoveInvalidEntries($id: UUID!, $input: DeckRemoveInvalidEntriesInput!) {
+          deckRemoveInvalidEntries(id: $id, input: $input) {
+            ${DECK_FIELDS}
           }
         }
       `
@@ -1039,21 +1943,193 @@ ${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
       `
     };
   },
+  createDeckEmbedToken() {
+    return {
+      query: `
+        mutation DeckEmbedTokenCreate($input: DeckEmbedTokenCreateInput!) {
+          deckEmbedTokenCreate(input: $input) {
+            token
+            embedToken {
+              ${DECK_EMBED_TOKEN_FIELDS}
+            }
+          }
+        }
+      `
+    };
+  },
+  revokeDeckEmbedToken() {
+    return {
+      query: `
+        mutation DeckEmbedTokenRevoke($id: UUID!) {
+          deckEmbedTokenRevoke(id: $id)
+        }
+      `
+    };
+  },
+  createDeckAccessTokenIssuer() {
+    return {
+      query: `
+        mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
+          deckAccessTokenIssuerCreate(input: $input) {
+            ${DECK_ACCESS_TOKEN_ISSUER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  revokeDeckAccessTokenIssuer() {
+    return {
+      query: `
+        mutation DeckAccessTokenIssuerRevoke($id: UUID!) {
+          deckAccessTokenIssuerRevoke(id: $id)
+        }
+      `
+    };
+  },
+  revokeDeckAccessTokenIssuerSigningKey() {
+    return {
+      query: `
+        mutation DeckAccessTokenIssuerSigningKeyRevoke($id: UUID!) {
+          deckAccessTokenIssuerSigningKeyRevoke(id: $id) {
+            ${DECK_ACCESS_TOKEN_ISSUER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  exchangeDeckAccessToken() {
+    return {
+      query: `
+        mutation DeckAccessTokenExchange($input: DeckAccessTokenExchangeInput!) {
+          deckAccessTokenExchange(input: $input) {
+            token
+            accessToken {
+              ${DECK_ACCESS_TOKEN_FIELDS}
+            }
+          }
+        }
+      `
+    };
+  },
+  grantDeckApiApplicationAccess() {
+    return {
+      query: `
+        mutation DeckApiApplicationAccessGrant($input: DeckAPIApplicationAccessGrantInput!) {
+          deckApiApplicationAccessGrant(input: $input) {
+            ${DECK_API_APPLICATION_ACCESS_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  revokeDeckApiApplicationAccess() {
+    return {
+      query: `
+        mutation DeckApiApplicationAccessRevoke($deckId: UUID!, $apiApplicationId: UUID!) {
+          deckApiApplicationAccessRevoke(deckId: $deckId, apiApplicationId: $apiApplicationId)
+        }
+      `
+    };
+  },
+  revokeDeckAccessToken() {
+    return {
+      query: `
+        mutation DeckAccessTokenRevoke($id: UUID!) {
+          deckAccessTokenRevoke(id: $id)
+        }
+      `
+    };
+  },
   deckCreateVariables(input) {
     return { input };
   },
   deckUpdateVariables(id, input) {
     return { id, input };
   },
-  deckPublishVariables(id, input = {}) {
+  deckEntryAddVariables(input) {
+    return { input };
+  },
+  deckEntryUpdateVariables(id, input) {
     return { id, input };
   },
+  deckEntryRemoveVariables(id, expectedDraftRevision) {
+    return { id, expectedDraftRevision };
+  },
+  deckEntryReorderVariables(deckId, input) {
+    return { deckId, input };
+  },
+  deckEntriesReplaceVariables(deckId, input) {
+    return { deckId, input };
+  },
+  deckImportVariables(input) {
+    return { input };
+  },
+  deckImportFormatCreateVariables(input) {
+    return { input };
+  },
+  deckImportFormatUpdateVariables(id, input) {
+    return { id, input };
+  },
+  deckImportFormatTestVariables(input) {
+    return { input };
+  },
+  deckUpsertByExternalRefVariables(input) {
+    return { input };
+  },
+  deckClaimVariables(id, input) {
+    return { id, input };
+  },
+  deckTransferOwnershipVariables(id, input) {
+    return { id, input };
+  },
+  deckCopyVariables(id, input) {
+    return { id, input };
+  },
+  deckPublishVariables(id, input) {
+    return { id, input };
+  },
+  deckValidateVariables(id, input) {
+    return input === void 0 ? { id } : { id, input };
+  },
+  deckRemoveInvalidEntriesVariables(id, input) {
+    return { id, input };
+  },
+  deckHydrateEntriesVariables(input) {
+    return { input };
+  },
+  deckExportVariables(id, format) {
+    return { id, format };
+  },
+  deckVersionDiffVariables(fromVersionId, toVersionId) {
+    return { fromVersionId, toVersionId };
+  },
   deckCollaboratorVariables(deckId, accountId, role) {
     return role === void 0 ? { deckId, accountId } : { deckId, accountId, role };
   },
   deckPreviewTokenCreateVariables(input) {
     return { input };
   },
+  deckEmbedTokenCreateVariables(input) {
+    return { input };
+  },
+  deckAccessTokenIssuerCreateVariables(input) {
+    return { input };
+  },
+  deckAccessTokenExchangeVariables(input) {
+    return { input };
+  },
+  deckApiApplicationAccessesVariables(deckId, includeRevoked) {
+    return includeRevoked === void 0 ? { deckId } : { deckId, includeRevoked };
+  },
+  myDeckApiApplicationAccessesVariables(applicationId) {
+    return applicationId === void 0 ? {} : { applicationId };
+  },
+  deckApiApplicationAccessGrantVariables(input) {
+    return { input };
+  },
+  deckApiApplicationAccessRevokeVariables(deckId, apiApplicationId) {
+    return { deckId, apiApplicationId };
+  },
   // API Key Info
   fetchMe() {
     return {