@carddb/core 0.1.5 → 0.2.5

package/dist/index.cjs

@@ -303,6 +303,27 @@ function resolveFilter(input) {
 }
 
 // src/query-builder.ts
+var FILE_FIELDS = `
+  id
+  createdAt
+  updatedAt
+  key
+  filename
+  contentType
+  size
+  status
+  isPublic
+  entityType
+  entityId
+  url
+`;
+var PRESIGNED_UPLOAD_FIELDS = `
+  file {
+    ${FILE_FIELDS}
+  }
+  uploadUrl
+  expiresAt
+`;
 var PUBLISHER_FIELDS = `
   id
   name
@@ -327,6 +348,8 @@ var GAME_FIELDS = `
   key
   name
   description
+  metafyGameUuid
+  metafyGameSlug
   website
   visibility
   isArchived
@@ -354,8 +377,13 @@ var DATASET_FIELDS = `
   name
   description
   purpose
+  activeVersionId
   tcgplayerProductIdFieldKey
   visibility
+  posX
+  posY
+  sortOrder
+  archivedAt
   isArchived
   createdAt
   updatedAt
@@ -385,10 +413,28 @@ function fieldInfoFields(depth) {
       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
       ${nestedFields}
   `;
 }
@@ -405,9 +451,48 @@ var SCHEMA_FIELDS = `
       targetDatasetKey
       targetDatasetName
       targetDatasetId
+      targetFieldKey
+      linkAlias
+      linkDirection
+      isArray
     }
   }
 `;
+var OBJECT_FIELD_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
+`;
 var TCGPLAYER_PRICING_FIELDS = `
   pricing {
     productId
@@ -439,6 +524,82 @@ function recordFields(options = {}) {
   `;
 }
 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
+  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
   deckId
@@ -454,21 +615,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 = `
@@ -490,8 +653,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
@@ -501,13 +812,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
@@ -515,17 +842,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 = `
@@ -540,37 +959,336 @@ var RESOLVED_LINKS_FIELDS = `
     }
   }
 `;
-function connectionFields(nodeFields) {
-  return `
-    totalCount
-    pageInfo {
-      hasNextPage
-      hasPreviousPage
-      startCursor
-      endCursor
+var BULK_RECORD_ERROR_FIELDS = `
+  datasetKey
+  index
+  errors {
+    field
+    message
+    details
+  }
+`;
+var IMPORT_STATS_FIELDS = `
+  total
+  inserted
+  updated
+  skipped
+  failed
+`;
+var BULK_IMPORT_RESULT_FIELDS = `
+  inserted {
+    ${RECORD_FIELDS}
+  }
+  updated {
+    ${RECORD_FIELDS}
+  }
+  skipped
+  errors {
+    ${BULK_RECORD_ERROR_FIELDS}
+  }
+  createdFields {
+    ${OBJECT_FIELD_FIELDS}
+  }
+  stats {
+    ${IMPORT_STATS_FIELDS}
+  }
+`;
+var IMPORT_JOB_ASSET_FIELDS = `
+  fileId
+  filename
+  file {
+    ${FILE_FIELDS}
+  }
+`;
+var IMPORT_JOB_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
+`;
+var IMPORT_JOB_LOG_FIELDS = `
+  id
+  importJobId
+  level
+  message
+  datasetKey
+  recordIndex
+  fieldKey
+  details
+  createdAt
+`;
+var DATASET_RECORDS_UPSERT_PAYLOAD_FIELDS = `
+  job {
+    ${IMPORT_JOB_FIELDS}
+  }
+  dryRunResult {
+    ${BULK_IMPORT_RESULT_FIELDS}
+  }
+`;
+var DELETE_JOB_RESULT_FIELDS = `
+  target
+  recordId
+  identifier
+  status
+  message
+`;
+var DATASET_RECORD_DELETE_JOB_FIELDS = `
+  id
+  publisherId
+  publisher {
+    ${PUBLISHER_FIELDS}
+  }
+  datasetId
+  dataset {
+    ${DATASET_FIELDS}
+  }
+  accountId
+  status
+  targetType
+  dryRun
+  targets
+  progress
+  totalTargets
+  processedTargets
+  matchedCount
+  deletedCount
+  missingCount
+  blockedCount
+  failedCount
+  results {
+    ${DELETE_JOB_RESULT_FIELDS}
+  }
+  errorMessage
+  startedAt
+  completedAt
+  createdAt
+  updatedAt
+`;
+var FIELD_MAPPING_FIELDS = `
+  sourceField
+  targetField
+  targetFieldLabel
+  inferredType
+  inferredItemType
+  inferredChildren {
+    key
+    label
+    type
+    required
+    itemType
+    children {
+      key
+      label
+      type
+      required
+      itemType
     }
-    edges {
-      cursor
-      node {
-        ${nodeFields}
-      }
+  }
+  inferredLinkDataset
+  inferredLinkFieldKey
+  inferredLinkDirection
+  targetFieldType
+  sampleValues
+  status
+`;
+var IMPORT_WARNING_FIELDS = `
+  datasetKey
+  field
+  message
+  severity
+`;
+var DATASET_IMPORT_PREVIEW_FIELDS = `
+  datasetKey
+  datasetName
+  datasetId
+  exists
+  recordCount
+  fieldMappings {
+    ${FIELD_MAPPING_FIELDS}
+  }
+  warnings {
+    ${IMPORT_WARNING_FIELDS}
+  }
+  canProceed
+  sampleRecords
+  availableDatasets {
+    ${DATASET_FIELDS}
+    ${SCHEMA_FIELDS}
+  }
+`;
+var GAME_IMPORT_PREVIEW_FIELDS = `
+  datasets {
+    datasetKey
+    datasetName
+    datasetId
+    exists
+    recordCount
+    fieldMappings {
+      ${FIELD_MAPPING_FIELDS}
     }
-  `;
-}
-var QueryBuilder = {
-  // Publishers
-  searchPublishers(params = {}) {
-    const variables = {};
-    const args = [];
-    const defs = [];
-    if (params.search !== void 0) {
-      defs.push("$search: String");
-      args.push("search: $search");
-      variables["search"] = params.search;
+    warnings {
+      ${IMPORT_WARNING_FIELDS}
     }
-    if (params.first !== void 0) {
-      defs.push("$first: Int");
-      args.push("first: $first");
+    sampleRecords
+  }
+  importOrder
+  warnings {
+    ${IMPORT_WARNING_FIELDS}
+  }
+  canProceed
+`;
+var GAME_IMPORT_DATASET_STATUS_FIELDS = `
+  datasetKey
+  datasetId
+  datasetName
+  status
+  recordCount
+  insertedCount
+  updatedCount
+  skippedCount
+  failedCount
+  errorMessage
+`;
+var GAME_IMPORT_JOB_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
+`;
+var EXPORT_JOB_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
+`;
+function connectionFields(nodeFields) {
+  return `
+    totalCount
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+    edges {
+      cursor
+      node {
+        ${nodeFields}
+      }
+    }
+  `;
+}
+var QueryBuilder = {
+  // Publishers
+  searchPublishers(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.search !== void 0) {
+      defs.push("$search: String");
+      args.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
       variables["first"] = params.first;
     }
     if (params.after !== void 0) {
@@ -695,6 +1413,98 @@ var QueryBuilder = {
       `
     };
   },
+  listGames(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    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;
+    }
+    if (params.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    return {
+      query: `
+        query Games(${defs.join(", ")}) {
+          games(${args.join(", ")}) {
+            ${connectionFields(GAME_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  game(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    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.gameSlug !== void 0) {
+      defs.push("$gameSlug: String");
+      args.push("gameSlug: $gameSlug");
+      variables["gameSlug"] = params.gameSlug;
+    }
+    return {
+      query: `
+        query Game(${defs.join(", ")}) {
+          game(${args.join(", ")}) {
+            ${GAME_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  createGame() {
+    return {
+      query: `
+        mutation GameCreate($input: GameCreateInput!) {
+          gameCreate(input: $input) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateGame() {
+    return {
+      query: `
+        mutation GameUpdate($id: UUID!, $input: GameUpdateInput!) {
+          gameUpdate(id: $id, input: $input) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
   // Datasets
   searchDatasets(params = {}) {
     const variables = {};
@@ -778,6 +1588,83 @@ var QueryBuilder = {
       `
     };
   },
+  listDatasets(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    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;
+    }
+    if (params.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    if (params.purpose !== void 0) {
+      defs.push("$purpose: DatasetPurpose");
+      args.push("purpose: $purpose");
+      variables["purpose"] = params.purpose;
+    }
+    return {
+      query: `
+        query Datasets(${defs.join(", ")}) {
+          datasets(${args.join(", ")}) {
+            ${connectionFields(`${DATASET_FIELDS}
+${SCHEMA_FIELDS}`)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  dataset(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      args.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    return {
+      query: `
+        query Dataset(${defs.join(", ")}) {
+          dataset(${args.join(", ")}) {
+            ${DATASET_FIELDS}
+            ${SCHEMA_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
   // Records
   searchRecords(params) {
     const variables = {
@@ -885,11 +1772,20 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
-  // Decks
-  listMyDecks(params = {}) {
-    const variables = {};
-    const args = [];
-    const defs = [];
+  listDatasetRecords(params) {
+    const variables = { datasetId: params.datasetId };
+    const args = ["datasetId: $datasetId"];
+    const defs = ["$datasetId: UUID!"];
+    if (params.filter !== void 0) {
+      defs.push("$filter: JSON");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.orderBy !== void 0) {
+      defs.push("$orderBy: DatasetRecordOrderByInput");
+      args.push("orderBy: $orderBy");
+      variables["orderBy"] = params.orderBy;
+    }
     if (params.first !== void 0) {
       defs.push("$first: Int");
       args.push("first: $first");
@@ -900,159 +1796,1257 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       args.push("after: $after");
       variables["after"] = params.after;
     }
-    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
-    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    if (params.last !== void 0) {
+      defs.push("$last: Int");
+      args.push("last: $last");
+      variables["last"] = params.last;
+    }
+    if (params.before !== void 0) {
+      defs.push("$before: String");
+      args.push("before: $before");
+      variables["before"] = params.before;
+    }
+    if (params.validateSchema !== void 0) {
+      defs.push("$validateSchema: Boolean");
+      args.push("validateSchema: $validateSchema");
+      variables["validateSchema"] = params.validateSchema;
+    }
     return {
       query: `
-        query MyDecks${defStr} {
-          myDecks${argStr} {
-            ${connectionFields(DECK_FIELDS)}
+        query DatasetRecords(${defs.join(", ")}) {
+          datasetRecords(${args.join(", ")}) {
+            ${connectionFields(RECORD_FIELDS)}
           }
         }
       `,
       variables
     };
   },
-  fetchDeckById() {
+  datasetRecord(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.identifier !== void 0) {
+      defs.push("$identifier: String");
+      args.push("identifier: $identifier");
+      variables["identifier"] = params.identifier;
+    }
+    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.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      args.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    if (params.recordId !== void 0) {
+      defs.push("$recordId: UUID");
+      args.push("recordId: $recordId");
+      variables["recordId"] = params.recordId;
+    }
+    if (params.resolveLinks !== void 0) {
+      defs.push("$resolveLinks: [String!]");
+      args.push("resolveLinks: $resolveLinks");
+      variables["resolveLinks"] = params.resolveLinks;
+    }
+    if (params.validateSchema !== void 0) {
+      defs.push("$validateSchema: Boolean");
+      args.push("validateSchema: $validateSchema");
+      variables["validateSchema"] = params.validateSchema;
+    }
+    const includeResolvedLinks = params.resolveLinks && params.resolveLinks.length > 0;
+    const selectedRecordFields = recordFields({ includePricing: params.includePricing });
+    const fields = includeResolvedLinks ? `${selectedRecordFields}
+${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return {
       query: `
-        query FetchDeck($id: UUID!) {
-          fetchDeck(id: $id) {
-            ${DECK_FIELDS}
+        query DatasetRecord(${defs.join(", ")}) {
+          datasetRecord(${args.join(", ")}) {
+            ${fields}
           }
         }
-      `
+      `,
+      variables
     };
   },
-  myDeck() {
+  upsertDatasetRecords() {
     return {
       query: `
-        query MyDeck($id: UUID!) {
-          myDeck(id: $id) {
-            ${DECK_FIELDS}
+        mutation DatasetRecordsUpsert($input: DatasetRecordsUpsertInput!) {
+          datasetRecordsUpsert(input: $input) {
+            ${DATASET_RECORDS_UPSERT_PAYLOAD_FIELDS}
           }
         }
       `
     };
   },
-  fetchDeckBySlug() {
+  deleteDatasetRecords() {
     return {
       query: `
-        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}
           }
         }
       `
     };
   },
-  fetchDeckByExternalRef() {
+  datasetRecordDeleteJob() {
     return {
       query: `
-        query FetchDeckByExternalRef($externalRef: String!) {
-          fetchDeckByExternalRef(externalRef: $externalRef) {
-            ${DECK_FIELDS}
+        query DatasetRecordDeleteJob($id: UUID!) {
+          datasetRecordDeleteJob(id: $id) {
+            ${DATASET_RECORD_DELETE_JOB_FIELDS}
           }
         }
       `
     };
   },
-  deckVersion() {
+  datasetRecordDeleteJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.status !== void 0) {
+      defs.push("$status: DatasetRecordDeleteJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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 DeckVersion($id: UUID!) {
-          deckVersion(id: $id) {
-            ${DECK_VERSION_FIELDS}
+        query DatasetRecordDeleteJobs(${defs.join(", ")}) {
+          datasetRecordDeleteJobs(${args.join(", ")}) {
+            ${connectionFields(DATASET_RECORD_DELETE_JOB_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  datasetImportPreview() {
+    return {
+      query: `
+        query DatasetImportPreview($input: DatasetImportPreviewInput!) {
+          datasetImportPreview(input: $input) {
+            ${DATASET_IMPORT_PREVIEW_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportValidate() {
+    return {
+      query: `
+        query DatasetImportValidate($input: DatasetImportValidateInput!) {
+          datasetImportValidate(input: $input) {
+            ${BULK_IMPORT_RESULT_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromFile() {
+    return {
+      query: `
+        mutation DatasetImportFromFile($input: DatasetImportFromFileInput!) {
+          datasetImportFromFile(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromPayload() {
+    return {
+      query: `
+        mutation DatasetImportFromPayload($input: DatasetImportFromPayloadInput!) {
+          datasetImportFromPayload(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromUrl() {
+    return {
+      query: `
+        mutation DatasetImportFromUrl($input: DatasetImportFromUrlInput!) {
+          datasetImportFromUrl(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importJob() {
+    return {
+      query: `
+        query ImportJob($id: UUID!) {
+          importJob(id: $id) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.status !== void 0) {
+      defs.push("$status: ImportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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 ImportJobs(${defs.join(", ")}) {
+          importJobs(${args.join(", ")}) {
+            ${connectionFields(IMPORT_JOB_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  importJobCancel() {
+    return {
+      query: `
+        mutation ImportJobCancel($id: UUID!) {
+          importJobCancel(id: $id) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importJobLogs(params) {
+    const variables = { importJobId: params.importJobId };
+    const args = ["id: $importJobId"];
+    const logArgs = [];
+    const defs = ["$importJobId: UUID!"];
+    if (params.level !== void 0) {
+      defs.push("$level: ImportLogLevel");
+      logArgs.push("level: $level");
+      variables["level"] = params.level;
+    }
+    if (params.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      logArgs.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      logArgs.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      logArgs.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const logArgStr = logArgs.length > 0 ? `(${logArgs.join(", ")})` : "";
+    return {
+      query: `
+        query ImportJobLogs(${defs.join(", ")}) {
+          importJob(${args.join(", ")}) {
+            logs${logArgStr} {
+              ${connectionFields(IMPORT_JOB_LOG_FIELDS)}
+            }
+          }
+        }
+      `,
+      variables
+    };
+  },
+  gameImportPreview() {
+    return {
+      query: `
+        query GameImportPreview($input: GameImportPreviewInput!) {
+          gameImportPreview(input: $input) {
+            ${GAME_IMPORT_PREVIEW_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  gameImportFromFile() {
+    return {
+      query: `
+        mutation GameImportFromFile($input: GameImportFromFileInput!) {
+          gameImportFromFile(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  gameImportFromPayload() {
+    return {
+      query: `
+        mutation GameImportFromPayload($input: GameImportFromPayloadInput!) {
+          gameImportFromPayload(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  gameImportFromUrl() {
+    return {
+      query: `
+        mutation GameImportFromUrl($input: GameImportFromUrlInput!) {
+          gameImportFromUrl(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  gameImportJob() {
+    return {
+      query: `
+        query GameImportJob($id: UUID!) {
+          gameImportJob(id: $id) {
+            ${GAME_IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  gameImportJobs(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: UUID!"];
+    if (params.status !== void 0) {
+      defs.push("$status: ImportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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 GameImportJobs(${defs.join(", ")}) {
+          gameImportJobs(${args.join(", ")}) {
+            ${connectionFields(GAME_IMPORT_JOB_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  gameImportJobCancel() {
+    return {
+      query: `
+        mutation GameImportJobCancel($id: UUID!) {
+          gameImportJobCancel(id: $id) {
+            ${GAME_IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  file() {
+    return {
+      query: `
+        query File($id: UUID!) {
+          file(id: $id) {
+            ${FILE_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fileUploadRequest() {
+    return {
+      query: `
+        mutation FileUploadRequest($input: FileUploadInput!) {
+          fileUploadRequest(input: $input) {
+            ${PRESIGNED_UPLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fileUploadConfirm() {
+    return {
+      query: `
+        mutation FileUploadConfirm($id: UUID!) {
+          fileUploadConfirm(id: $id) {
+            ${FILE_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fileDelete() {
+    return {
+      query: `
+        mutation FileDelete($id: UUID!) {
+          fileDelete(id: $id)
+        }
+      `
+    };
+  },
+  exportJob() {
+    return {
+      query: `
+        query ExportJob($id: UUID!) {
+          exportJob(id: $id) {
+            ${EXPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  exportJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.status !== void 0) {
+      defs.push("$status: ExportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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 ExportJobs(${defs.join(", ")}) {
+          exportJobs(${args.join(", ")}) {
+            ${connectionFields(EXPORT_JOB_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  datasetExport() {
+    return {
+      query: `
+        mutation DatasetExport($input: DatasetExportInput!) {
+          datasetExport(input: $input) {
+            ${EXPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  exportJobCancel() {
+    return {
+      query: `
+        mutation ExportJobCancel($id: UUID!) {
+          exportJobCancel(id: $id) {
+            ${EXPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  exportJobRefreshUrl() {
+    return {
+      query: `
+        mutation ExportJobRefreshUrl($id: UUID!) {
+          exportJobRefreshUrl(id: $id) {
+            ${EXPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  // Decks
+  listMyDecks(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    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;
+    }
+    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 {
+      query: `
+        query MyDecks${defStr} {
+          myDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  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 ViewerDecks${defStr} {
+          viewerDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  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 AppDecks${defStr} {
+          appDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  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 PublicDecks${defStr} {
+          publicDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchDeckById() {
+    return {
+      query: `
+        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}
+          }
+        }
+      `
+    };
+  },
+  deckVersion() {
+    return {
+      query: `
+        query DeckVersion($id: UUID!) {
+          deckVersion(id: $id) {
+            ${DECK_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckVersions(params = {}) {
+    const variables = {};
+    const args = ["deckId: $deckId"];
+    const defs = ["$deckId: UUID!"];
+    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 DeckVersions(${defs.join(", ")}) {
+          deckVersions(${args.join(", ")}) {
+            ${connectionFields(DECK_VERSION_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  deckPreview() {
+    return {
+      query: `
+        query DeckPreview($token: String!) {
+          deckPreview(token: $token) {
+            ${DECK_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: `
+        query DeckCollaborators($deckId: UUID!) {
+          deckCollaborators(deckId: $deckId) {
+            ${DECK_COLLABORATOR_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 = {};
+    const args = [];
+    const defs = [];
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    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;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query DeckImportFormats${defStr} {
+          deckImportFormats${argStr} {
+            ${connectionFields(DECK_IMPORT_FORMAT_DEFINITION_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  deckImportFormat() {
+    return {
+      query: `
+        query DeckImportFormat($id: UUID, $gameId: UUID, $key: String) {
+          deckImportFormat(id: $id, gameId: $gameId, key: $key) {
+            ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckImportFormatTest() {
+    return {
+      query: `
+        query DeckImportFormatTest($input: DeckImportFormatTestInput!) {
+          deckImportFormatTest(input: $input) {
+            ${DECK_IMPORT_FORMAT_TEST_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deckPreviewTokens() {
+    return {
+      query: `
+        query DeckPreviewTokens($deckId: UUID!) {
+          deckPreviewTokens(deckId: $deckId) {
+            ${DECK_PREVIEW_TOKEN_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  createDeck() {
+    return {
+      query: `
+        mutation DeckCreate($input: DeckCreateInput!) {
+          deckCreate(input: $input) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateDeck() {
+    return {
+      query: `
+        mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
+          deckUpdate(id: $id, input: $input) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deleteDeck() {
+    return {
+      query: `
+        mutation DeckDelete($id: UUID!) {
+          deckDelete(id: $id)
+        }
+      `
+    };
+  },
+  archiveDeck() {
+    return {
+      query: `
+        mutation DeckArchive($id: UUID!) {
+          deckArchive(id: $id) {
+            ${DECK_FIELDS}
           }
         }
       `
     };
   },
-  deckVersions(params = {}) {
-    const variables = {};
-    const args = ["deckId: $deckId"];
-    const defs = ["$deckId: UUID!"];
-    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;
-    }
+  restoreDeck() {
     return {
       query: `
-        query DeckVersions(${defs.join(", ")}) {
-          deckVersions(${args.join(", ")}) {
-            ${connectionFields(DECK_VERSION_FIELDS)}
+        mutation DeckRestore($id: UUID!) {
+          deckRestore(id: $id) {
+            ${DECK_FIELDS}
           }
         }
-      `,
-      variables
+      `
     };
   },
-  deckPreview() {
+  unpublishDeck() {
     return {
       query: `
-        query DeckPreview($token: String!) {
-          deckPreview(token: $token) {
+        mutation DeckUnpublish($id: UUID!) {
+          deckUnpublish(id: $id) {
             ${DECK_FIELDS}
           }
         }
       `
     };
   },
-  deckCollaborators() {
+  addDeckEntry() {
     return {
       query: `
-        query DeckCollaborators($deckId: UUID!) {
-          deckCollaborators(deckId: $deckId) {
-            ${DECK_COLLABORATOR_FIELDS}
+        mutation DeckEntryAdd($input: DeckEntryAddInput!) {
+          deckEntryAdd(input: $input) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
           }
         }
       `
     };
   },
-  deckPreviewTokens() {
+  updateDeckEntry() {
     return {
       query: `
-        query DeckPreviewTokens($deckId: UUID!) {
-          deckPreviewTokens(deckId: $deckId) {
-            ${DECK_PREVIEW_TOKEN_FIELDS}
+        mutation DeckEntryUpdate($id: UUID!, $input: DeckEntryUpdateInput!) {
+          deckEntryUpdate(id: $id, input: $input) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
           }
         }
       `
     };
   },
-  createDeck() {
+  removeDeckEntry() {
     return {
       query: `
-        mutation DeckCreate($input: DeckCreateInput!) {
-          deckCreate(input: $input) {
-            ${DECK_FIELDS}
+        mutation DeckEntryRemove($id: UUID!, $expectedDraftRevision: Int!) {
+          deckEntryRemove(id: $id, expectedDraftRevision: $expectedDraftRevision) {
+            ${DECK_ENTRY_MUTATION_PAYLOAD_FIELDS}
           }
         }
       `
     };
   },
-  updateDeck() {
+  reorderDeckEntries() {
     return {
       query: `
-        mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
-          deckUpdate(id: $id, input: $input) {
-            ${DECK_FIELDS}
+        mutation DeckEntryReorder($deckId: UUID!, $input: DeckEntryReorderInput!) {
+          deckEntryReorder(deckId: $deckId, input: $input) {
+            ${DECK_ENTRY_REORDER_PAYLOAD_FIELDS}
           }
         }
       `
     };
   },
-  deleteDeck() {
+  replaceDeckEntries() {
     return {
       query: `
-        mutation DeckDelete($id: UUID!) {
-          deckDelete(id: $id)
+        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}
+          }
         }
       `
     };
@@ -1062,7 +3056,18 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       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}
           }
         }
       `
@@ -1111,21 +3116,238 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
+  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 };
+  },
+  gameCreateVariables(input) {
+    return { input };
+  },
+  gameUpdateVariables(id, input) {
+    return { id, input };
+  },
+  datasetImportPreviewVariables(input) {
+    return { input };
+  },
+  datasetImportValidateVariables(input) {
+    return { input };
+  },
+  datasetImportFromFileVariables(input) {
+    return { input };
+  },
+  datasetImportFromPayloadVariables(input) {
+    return { input };
+  },
+  datasetImportFromUrlVariables(input) {
+    return { input };
+  },
+  gameImportPreviewVariables(input) {
+    return { input };
+  },
+  gameImportFromFileVariables(input) {
+    return { input };
+  },
+  gameImportFromPayloadVariables(input) {
+    return { input };
+  },
+  gameImportFromUrlVariables(input) {
+    return { input };
+  },
+  datasetRecordsUpsertVariables(input) {
+    return { input };
+  },
+  datasetRecordsDeleteVariables(input) {
+    return { input };
+  },
+  fileUploadRequestVariables(input) {
+    return { input };
+  },
+  datasetExportVariables(input) {
+    return { input };
+  },
   // API Key Info
   fetchMe() {
     return {