@carddb/core 0.4.2 → 0.4.6

package/dist/index.js

@@ -250,6 +250,47 @@ function resolveFilter(input) {
 }
 
 // src/query-builder.ts
+var DECK_JSON_OBJECT_KEYS = /* @__PURE__ */ new Set(["metadata", "annotations"]);
+function normalizeDeckJsonInput(input) {
+  return normalizeDeckJsonValue(input, "input");
+}
+function normalizeDeckJsonValue(value, path) {
+  if (!isRecord(value)) {
+    return value;
+  }
+  const normalized = {};
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = `${path}.${key}`;
+    if (DECK_JSON_OBJECT_KEYS.has(key)) {
+      normalized[key] = normalizeJsonObject(child, childPath);
+    } else if (key === "entries" && Array.isArray(child)) {
+      normalized[key] = child.map(
+        (entry, index) => normalizeDeckJsonValue(entry, `${childPath}[${index}]`)
+      );
+    } else {
+      normalized[key] = child;
+    }
+  }
+  return normalized;
+}
+function normalizeJsonObject(value, path) {
+  if (value == null || isRecord(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  throw new ValidationError(`${path} must be a JSON object`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 var FILE_FIELDS = `
   id
   createdAt
@@ -539,6 +580,103 @@ var DECK_VALIDATION_FIELDS = `
   }
   checkedAt
 `;
+var RULESET_VERSION_FIELDS = `
+  id
+  rulesetId
+  versionLabel
+  status
+  rules
+  sectionDefinitions {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+  cardDatasetId
+  cardDatasetVersionId
+  sourceDatasetId
+  sourceDatasetVersionId
+  sourceDatasetRecordId
+  sourceRecordIdentifier
+  rulesFingerprint
+  effectiveAt
+  changelog
+  createdByAccountId
+  publishedByAccountId
+  publishedAt
+  supersededAt
+  createdAt
+  updatedAt
+`;
+var RULESET_FIELDS = `
+  id
+  gameId
+  game {
+    id
+    key
+    name
+  }
+  key
+  name
+  description
+  tags
+  sortOrder
+  currentVersionId
+  currentVersion {
+    ${RULESET_VERSION_FIELDS}
+  }
+  archivedAt
+  isArchived
+  createdAt
+  updatedAt
+`;
+var DECK_VALIDATION_RULES_FIELDS = `
+  rulesetId
+  rulesetVersionId
+  rulesetKey
+  rulesetVersionLabel
+  rules
+  sections {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+`;
+var RULESET_VALIDATION_IMPACT_DECK_FIELDS = `
+  deckId
+  title
+  slug
+  state
+  hasUnpublishedChanges
+  valid
+  blockerCount
+  warningCount
+  affectedEntryCount
+  issues {
+    ${DECK_VALIDATION_ISSUE_FIELDS}
+  }
+`;
+var RULESET_VALIDATION_IMPACT_FIELDS = `
+  rulesetId
+  rulesetVersionId
+  checkedAt
+  affectedDeckCount
+  invalidDeckCount
+  blockerCount
+  warningCount
+  results {
+    ${RULESET_VALIDATION_IMPACT_DECK_FIELDS}
+  }
+`;
+var RULESET_VERSION_DRAFT_IMPORT_PREVIEW_FIELDS = `
+  sourceDatasetId
+  sourceDatasetVersionId
+  sourceDatasetRecordId
+  sourceRecordIdentifier
+  rules
+  sectionDefinitions {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+  rulesFingerprint
+  summary
+  sectionCount
+  copyLimitCount
+`;
 var DECK_DIFF_FIELDS = `
   deckId
   fromVersionId
@@ -590,36 +728,12 @@ var DECK_COLLABORATOR_FIELDS = `
   createdAt
   updatedAt
 `;
-var DECK_PREVIEW_TOKEN_FIELDS = `
+var DECK_TOKEN_ISSUER_FIELDS = `
   id
-  deckId
-  label
-  expiresAt
-  revokedAt
-  lastUsedAt
-  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
+  allowedScopes
+  allowedRepresentations
   maxTokenLifetimeSeconds
   directSigningAlg
   directSigningKeyId
@@ -629,13 +743,15 @@ var DECK_ACCESS_TOKEN_ISSUER_FIELDS = `
   createdAt
   updatedAt
 `;
-var DECK_ACCESS_TOKEN_FIELDS = `
+var DECK_TOKEN_FIELDS = `
   id
-  deckId
   apiApplicationId
   issuerId
-  readMode
+  deckId
+  gameId
   externalSubject
+  scopes
+  representation
   expiresAt
   revokedAt
   lastUsedAt
@@ -2616,6 +2732,261 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
+  // Rulesets
+  rulesets(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 Rulesets(${defs.join(", ")}) {
+          rulesets(${args.join(", ")}) {
+            ${connectionFields(RULESET_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  publicRulesets(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: 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 PublicRulesets(${defs.join(", ")}) {
+          publicRulesets(${args.join(", ")}) {
+            ${connectionFields(RULESET_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  ruleset(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.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.key !== void 0) {
+      defs.push("$key: String");
+      args.push("key: $key");
+      variables["key"] = params.key;
+    }
+    return {
+      query: `
+        query Ruleset(${defs.join(", ")}) {
+          ruleset(${args.join(", ")}) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  rulesetVersions(params) {
+    const variables = { rulesetId: params.rulesetId };
+    const args = ["rulesetId: $rulesetId"];
+    const defs = ["$rulesetId: UUID!"];
+    if (params.status !== void 0) {
+      defs.push("$status: RulesetVersionStatus");
+      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 RulesetVersions(${defs.join(", ")}) {
+          rulesetVersions(${args.join(", ")}) {
+            ${connectionFields(RULESET_VERSION_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  rulesetVersion() {
+    return {
+      query: `
+        query RulesetVersion($id: UUID!) {
+          rulesetVersion(id: $id) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetValidationRules() {
+    return {
+      query: `
+        query RulesetValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+          rulesetValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId)
+        }
+      `
+    };
+  },
+  deckValidationRules() {
+    return {
+      query: `
+        query DeckValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+          deckValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId) {
+            ${DECK_VALIDATION_RULES_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetVersionDraftImportPreview() {
+    return {
+      query: `
+        query RulesetVersionDraftImportPreview($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+          rulesetVersionDraftImportPreview(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_DRAFT_IMPORT_PREVIEW_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetValidationImpact(params) {
+    const variables = { rulesetVersionId: params.rulesetVersionId };
+    const args = ["rulesetVersionId: $rulesetVersionId"];
+    const defs = ["$rulesetVersionId: UUID!"];
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    return {
+      query: `
+        query RulesetValidationImpact(${defs.join(", ")}) {
+          rulesetValidationImpact(${args.join(", ")}) {
+            ${RULESET_VALIDATION_IMPACT_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  createRuleset() {
+    return {
+      query: `
+        mutation RulesetCreate($input: RulesetCreateInput!) {
+          rulesetCreate(input: $input) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateRuleset() {
+    return {
+      query: `
+        mutation RulesetUpdate($id: UUID!, $input: RulesetUpdateInput!) {
+          rulesetUpdate(id: $id, input: $input) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  createRulesetVersionDraft() {
+    return {
+      query: `
+        mutation RulesetVersionDraftCreate($rulesetId: UUID!, $input: RulesetVersionDraftCreateInput!) {
+          rulesetVersionDraftCreate(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importRulesetVersionDraftFromDatasetRecord() {
+    return {
+      query: `
+        mutation RulesetVersionDraftImportFromDatasetRecord($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+          rulesetVersionDraftImportFromDatasetRecord(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateRulesetVersionDraft() {
+    return {
+      query: `
+        mutation RulesetVersionDraftUpdate($id: UUID!, $input: RulesetVersionDraftUpdateInput!) {
+          rulesetVersionDraftUpdate(id: $id, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  publishRulesetVersion() {
+    return {
+      query: `
+        mutation RulesetVersionPublish($id: UUID!, $input: RulesetVersionPublishInput) {
+          rulesetVersionPublish(id: $id, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  activateRulesetVersion() {
+    return {
+      query: `
+        mutation RulesetVersionActivate($id: UUID!) {
+          rulesetVersionActivate(id: $id) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
   // Decks
   listMyDecks(params = {}) {
     const variables = {};
@@ -2759,8 +3130,8 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
   deckById() {
     return {
       query: `
-        query Deck($id: UUID!) {
-          deck(id: $id) {
+        query Deck($id: UUID!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+          deck(id: $id, readState: $readState, version: $version) {
             ${DECK_FIELDS}
           }
         }
@@ -2814,8 +3185,8 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
   deckByExternalRef() {
     return {
       query: `
-        query DeckByExternalRef($externalRef: String!) {
-          deckByExternalRef(externalRef: $externalRef) {
+        query DeckByExternalRef($externalRef: String!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+          deckByExternalRef(externalRef: $externalRef, readState: $readState, version: $version) {
             ${DECK_FIELDS}
           }
         }
@@ -2858,39 +3229,6 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       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: `
@@ -2999,28 +3337,6 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
-  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: `
@@ -3107,17 +3423,6 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
-  deckPreviewTokens() {
-    return {
-      query: `
-        query DeckPreviewTokens($deckId: UUID!) {
-          deckPreviewTokens(deckId: $deckId) {
-            ${DECK_PREVIEW_TOKEN_FIELDS}
-          }
-        }
-      `
-    };
-  },
   createDeck() {
     return {
       query: `
@@ -3382,120 +3687,58 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
-  createDeckPreviewToken() {
-    return {
-      query: `
-        mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
-          deckPreviewTokenCreate(input: $input) {
-            token
-            previewToken {
-              ${DECK_PREVIEW_TOKEN_FIELDS}
-            }
-          }
-        }
-      `
-    };
-  },
-  revokeDeckPreviewToken() {
-    return {
-      query: `
-        mutation DeckPreviewTokenRevoke($id: UUID!) {
-          deckPreviewTokenRevoke(id: $id)
-        }
-      `
-    };
-  },
-  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() {
+  createDeckTokenIssuer() {
     return {
       query: `
-        mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
-          deckAccessTokenIssuerCreate(input: $input) {
-            ${DECK_ACCESS_TOKEN_ISSUER_FIELDS}
+        mutation DeckTokenIssuerCreate($input: DeckTokenIssuerCreateInput!) {
+          deckTokenIssuerCreate(input: $input) {
+            ${DECK_TOKEN_ISSUER_FIELDS}
           }
         }
       `
     };
   },
-  revokeDeckAccessTokenIssuer() {
+  revokeDeckTokenIssuer() {
     return {
       query: `
-        mutation DeckAccessTokenIssuerRevoke($id: UUID!) {
-          deckAccessTokenIssuerRevoke(id: $id)
+        mutation DeckTokenIssuerRevoke($id: UUID!) {
+          deckTokenIssuerRevoke(id: $id)
         }
       `
     };
   },
-  revokeDeckAccessTokenIssuerSigningKey() {
+  revokeDeckTokenIssuerSigningKey() {
     return {
       query: `
-        mutation DeckAccessTokenIssuerSigningKeyRevoke($id: UUID!) {
-          deckAccessTokenIssuerSigningKeyRevoke(id: $id) {
-            ${DECK_ACCESS_TOKEN_ISSUER_FIELDS}
+        mutation DeckTokenIssuerSigningKeyRevoke($id: UUID!) {
+          deckTokenIssuerSigningKeyRevoke(id: $id) {
+            ${DECK_TOKEN_ISSUER_FIELDS}
           }
         }
       `
     };
   },
-  exchangeDeckAccessToken() {
+  exchangeDeckToken() {
     return {
       query: `
-        mutation DeckAccessTokenExchange($input: DeckAccessTokenExchangeInput!) {
-          deckAccessTokenExchange(input: $input) {
+        mutation DeckTokenExchange($input: DeckTokenExchangeInput!) {
+          deckTokenExchange(input: $input) {
             token
-            accessToken {
-              ${DECK_ACCESS_TOKEN_FIELDS}
+            deckToken {
+              ${DECK_TOKEN_FIELDS}
             }
           }
         }
       `
     };
   },
-  exchangeDeckSessionToken() {
+  revokeDeckToken() {
     return {
       query: `
-			mutation DeckSessionTokenExchange($input: DeckSessionTokenExchangeInput!) {
-				deckSessionTokenExchange(input: $input) {
-					token
-					sessionToken {
-						id
-						accountId
-						apiApplicationId
-						gameId
-						environment
-						externalSubject
-						scopes
-						expiresAt
-						revokedAt
-						lastUsedAt
-						createdAt
-						updatedAt
-					}
-				}
-			}
-		`
+        mutation DeckTokenRevoke($id: UUID!) {
+          deckTokenRevoke(id: $id)
+        }
+      `
     };
   },
   grantDeckApiApplicationAccess() {
@@ -3518,26 +3761,41 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
-  revokeDeckAccessToken() {
-    return {
-      query: `
-        mutation DeckAccessTokenRevoke($id: UUID!) {
-          deckAccessTokenRevoke(id: $id)
-        }
-      `
-    };
+  rulesetValidationRulesVariables(gameId, rulesetKey, rulesetVersionId) {
+    return rulesetVersionId === void 0 ? { gameId, rulesetKey } : { gameId, rulesetKey, rulesetVersionId };
   },
-  deckCreateVariables(input) {
+  rulesetVersionDraftImportPreviewVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetCreateVariables(input) {
     return { input };
   },
-  deckUpdateVariables(id, input) {
+  rulesetUpdateVariables(id, input) {
     return { id, input };
   },
+  rulesetVersionDraftCreateVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetVersionDraftImportFromDatasetRecordVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetVersionDraftUpdateVariables(id, input) {
+    return { id, input };
+  },
+  rulesetVersionPublishVariables(id, input) {
+    return input === void 0 ? { id } : { id, input };
+  },
+  deckCreateVariables(input) {
+    return { input: normalizeDeckJsonInput(input) };
+  },
+  deckUpdateVariables(id, input) {
+    return { id, input: normalizeDeckJsonInput(input) };
+  },
   deckEntryAddVariables(input) {
-    return { input };
+    return { input: normalizeDeckJsonInput(input) };
   },
   deckEntryUpdateVariables(id, input) {
-    return { id, input };
+    return { id, input: normalizeDeckJsonInput(input) };
   },
   deckEntryRemoveVariables(id, expectedDraftRevision) {
     return { id, expectedDraftRevision };
@@ -3546,7 +3804,7 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return { deckId, input };
   },
   deckEntriesReplaceVariables(deckId, input) {
-    return { deckId, input };
+    return { deckId, input: normalizeDeckJsonInput(input) };
   },
   deckImportVariables(input) {
     return { input };
@@ -3561,7 +3819,13 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return { input };
   },
   deckUpsertByExternalRefVariables(input) {
-    return { input };
+    return { input: normalizeDeckJsonInput(input) };
+  },
+  deckReadVariables(id, readState, version) {
+    return { id, readState, version };
+  },
+  deckExternalRefReadVariables(externalRef, readState, version) {
+    return { externalRef, readState, version };
   },
   deckClaimVariables(id, input) {
     return { id, input };
@@ -3582,7 +3846,7 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return { id, input };
   },
   deckHydrateEntriesVariables(input) {
-    return { input };
+    return { input: normalizeDeckJsonInput(input) };
   },
   deckExportVariables(id, format) {
     return { id, format };
@@ -3593,19 +3857,10 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
   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) {
+  deckTokenIssuerCreateVariables(input) {
     return { input };
   },
-  deckSessionTokenExchangeVariables(input) {
+  deckTokenExchangeVariables(input) {
     return { input };
   },
   deckApiApplicationAccessesVariables(deckId, includeRevoked) {