@carddb/client 0.1.5 → 0.2.0

package/dist/index.js

@@ -12,6 +12,11 @@ var DEFAULT_RETRY_BASE_DELAY = 1e3;
 var DEFAULT_RETRY_MAX_DELAY = 3e4;
 var Configuration = class _Configuration {
   apiKey;
+  publishableKey;
+  secretKey;
+  accessToken;
+  legacyApiKey;
+  environment;
   endpoint;
   timeout;
   openTimeout;
@@ -31,7 +36,12 @@ var Configuration = class _Configuration {
   cacheTtl;
   cacheTtls;
   constructor(config = {}) {
-    this.apiKey = config.apiKey;
+    this.legacyApiKey = config.apiKey;
+    this.publishableKey = config.publishableKey;
+    this.secretKey = config.secretKey;
+    this.accessToken = config.accessToken;
+    this.apiKey = config.apiKey ?? config.publishableKey ?? config.secretKey;
+    this.environment = config.environment;
     this.endpoint = config.endpoint ?? DEFAULT_ENDPOINT;
     this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
     this.openTimeout = config.openTimeout ?? DEFAULT_OPEN_TIMEOUT;
@@ -109,6 +119,27 @@ var Configuration = class _Configuration {
       }
     }
   }
+  /**
+   * Secret-key-only helpers are for server runtimes and trusted backend workflows.
+   */
+  requireSecretCredential(operation) {
+    if (!this.accessToken && (this.legacyApiKey || this.secretKey && !this.publishableKey)) return;
+    throw new RestrictedError(
+      `${operation} requires a server-side secretKey or legacy apiKey credential`
+    );
+  }
+  /**
+   * API key sent on requests when no OAuth bearer token is configured.
+   */
+  requestApiKey() {
+    return this.legacyApiKey ?? this.publishableKey ?? this.secretKey;
+  }
+  /**
+   * Explicit legacy apiKey supplied by the caller, excluding publishable/secret aliases.
+   */
+  configApiKey() {
+    return this.legacyApiKey;
+  }
   /**
    * Check if a log level should be logged
    */
@@ -126,7 +157,11 @@ var Configuration = class _Configuration {
    */
   merge(overrides) {
     return new _Configuration({
-      apiKey: overrides.apiKey ?? this.apiKey,
+      apiKey: overrides.apiKey ?? this.legacyApiKey,
+      publishableKey: overrides.publishableKey ?? this.publishableKey,
+      secretKey: overrides.secretKey ?? this.secretKey,
+      accessToken: overrides.accessToken ?? this.accessToken,
+      environment: overrides.environment ?? this.environment,
       endpoint: overrides.endpoint ?? this.endpoint,
       timeout: overrides.timeout ?? this.timeout,
       openTimeout: overrides.openTimeout ?? this.openTimeout,
@@ -271,6 +306,7 @@ var Connection = class {
   async fetch(query, variables) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    const apiKey = this.config.requestApiKey();
     try {
       const response = await fetch(this.config.endpoint, {
         method: "POST",
@@ -278,7 +314,8 @@ var Connection = class {
           "Content-Type": "application/json",
           Accept: "application/json",
           "User-Agent": getUserAgent(),
-          ...this.config.apiKey ? { "X-API-Key": this.config.apiKey } : {}
+          ...this.config.accessToken ? { Authorization: `Bearer ${this.config.accessToken}` } : {},
+          ...!this.config.accessToken && apiKey ? { "X-API-Key": apiKey } : {}
         },
         body: JSON.stringify({ query, variables }),
         signal: controller.signal
@@ -742,6 +779,17 @@ var DecksResource = class extends BaseResource {
       return result["fetchDeck"] ?? null;
     });
   }
+  /**
+   * Fetch a deck by UUID using the ownership-aware `deck` API.
+   */
+  async get(id, options = {}) {
+    const key = this.cacheKey("decks", "get", { id });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckById();
+      const result = await this.connection.execute(query, { id });
+      return result["deck"] ?? null;
+    });
+  }
   /**
    * Fetch one deck owned by the current account or API application.
    */
@@ -764,6 +812,17 @@ var DecksResource = class extends BaseResource {
       return result["fetchDeckBySlug"] ?? null;
     });
   }
+  /**
+   * Fetch by slug using the ownership-aware `deckBySlug` API.
+   */
+  async getBySlug(publisherSlug, gameKey, slug, options = {}) {
+    const key = this.cacheKey("decks", "getBySlug", { publisherSlug, gameKey, slug });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckBySlug();
+      const result = await this.connection.execute(query, { publisherSlug, gameKey, slug });
+      return result["deckBySlug"] ?? null;
+    });
+  }
   /**
    * Fetch a hosted deck by external reference for the current API application.
    */
@@ -775,13 +834,25 @@ var DecksResource = class extends BaseResource {
       return result["fetchDeckByExternalRef"] ?? null;
     });
   }
+  /**
+   * Fetch by external reference using the ownership-aware `deckByExternalRef` API.
+   */
+  async getByExternalRef(externalRef, options = {}) {
+    const key = this.cacheKey("decks", "getByExternalRef", { externalRef });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckByExternalRef();
+      const result = await this.connection.execute(query, { externalRef });
+      return result["deckByExternalRef"] ?? null;
+    });
+  }
   /**
    * List decks owned by the current account or API application.
    */
   async listMine(options = {}) {
     const { query, variables } = QueryBuilder.listMyDecks({
       first: options.first,
-      after: options.after
+      after: options.after,
+      includeArchived: options.includeArchived
     });
     const key = this.cacheKey("decks", "listMine", variables);
     const data = await this.withCache(key, "decks", options, async () => {
@@ -792,6 +863,61 @@ var DecksResource = class extends BaseResource {
       nextPageLoader: async (cursor) => this.listMine({ ...options, after: cursor })
     });
   }
+  /**
+   * List decks owned by the current account or OAuth grant.
+   */
+  async listViewer(options = {}) {
+    const { query, variables } = QueryBuilder.viewerDecks({
+      filter: options.filter,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("decks", "listViewer", variables);
+    const data = await this.withCache(key, "decks", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["viewerDecks"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listViewer({ ...options, after: cursor })
+    });
+  }
+  /**
+   * List app-owned decks for the current secret-key API application.
+   */
+  async listApp(options = {}) {
+    this.config.requireSecretCredential("decks.listApp");
+    const { query, variables } = QueryBuilder.appDecks({
+      filter: options.filter,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("decks", "listApp", variables);
+    const data = await this.withCache(key, "decks", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["appDecks"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listApp({ ...options, after: cursor })
+    });
+  }
+  /**
+   * List published live decks eligible for public discovery.
+   */
+  async listPublic(options = {}) {
+    const { query, variables } = QueryBuilder.publicDecks({
+      filter: options.filter,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("decks", "listPublic", variables);
+    const data = await this.withCache(key, "decks", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["publicDecks"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listPublic({ ...options, after: cursor })
+    });
+  }
   /**
    * Fetch one immutable published deck version.
    */
@@ -832,6 +958,104 @@ var DecksResource = class extends BaseResource {
       return result["deckPreview"] ?? null;
     });
   }
+  /**
+   * Fetch published embed data using a revocable embed token.
+   */
+  async embed(token, options = {}) {
+    const key = this.cacheKey("decks", "embed", { token });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckEmbed();
+      const result = await this.connection.execute(query, { token });
+      return result["deckEmbed"] ?? null;
+    });
+  }
+  /**
+   * Fetch token-authorized published data using an exchanged access token.
+   */
+  async access(token, options = {}) {
+    const key = this.cacheKey("decks", "access", { token });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckAccess();
+      const result = await this.connection.execute(query, { token });
+      return result["deckAccess"] ?? null;
+    });
+  }
+  /**
+   * Compare the current draft against the latest published version.
+   */
+  async draftDiff(id, options = {}) {
+    const key = this.cacheKey("decks", "draftDiff", { id });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckDraftDiff();
+      const result = await this.connection.execute(query, { id });
+      return result["deckDraftDiff"];
+    });
+  }
+  /**
+   * Compare any two readable immutable deck versions from the same deck.
+   */
+  async versionDiff(fromVersionId, toVersionId, options = {}) {
+    const variables = QueryBuilder.deckVersionDiffVariables(fromVersionId, toVersionId);
+    const key = this.cacheKey("decks", "versionDiff", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckVersionDiff();
+      const result = await this.connection.execute(query, variables);
+      return result["deckVersionDiff"];
+    });
+  }
+  /**
+   * Validate a draft against current or explicitly requested immutable rules/data.
+   */
+  async validate(id, input, options = {}) {
+    const variables = QueryBuilder.deckValidateVariables(id, input);
+    const key = this.cacheKey("decks", "validate", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckValidate();
+      const result = await this.connection.execute(query, variables);
+      return result["deckValidate"];
+    });
+  }
+  /**
+   * Hydrate unpersisted deck entries against a stored deck's game without mutating the deck.
+   */
+  async hydrateDeckEntries(input, options = {}) {
+    const variables = QueryBuilder.deckHydrateEntriesVariables(input);
+    const key = this.cacheKey("decks", "hydrateDeckEntries", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckHydrateEntries();
+      const result = await this.connection.execute(query, variables);
+      return result["deckHydrateEntries"];
+    });
+  }
+  /**
+   * Export a readable deck representation in a deterministic text format.
+   */
+  async exportDeck(id, format = "SIMPLE_TEXT", options = {}) {
+    const variables = QueryBuilder.deckExportVariables(id, format);
+    const key = this.cacheKey("decks", "exportDeck", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckExport();
+      const result = await this.connection.execute(query, variables);
+      return result["deckExport"];
+    });
+  }
+  /**
+   * Resolve current or historical ruleset section definitions.
+   */
+  async sectionDefinitions(options = {}) {
+    const { query, variables } = QueryBuilder.deckSectionDefinitions({
+      publisherSlug: options.publisherSlug,
+      gameKey: options.gameKey,
+      gameId: options.gameId,
+      rulesetKey: options.rulesetKey,
+      rulesetVersionId: options.rulesetVersionId
+    });
+    const key = this.cacheKey("decks", "sectionDefinitions", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["deckSectionDefinitions"];
+    });
+  }
   /**
    * List collaborators for a deck.
    */
@@ -854,6 +1078,55 @@ var DecksResource = class extends BaseResource {
       return result["deckPreviewTokens"];
     });
   }
+  /**
+   * List published embed tokens for a deck.
+   */
+  async listEmbedTokens(deckId, options = {}) {
+    const key = this.cacheKey("decks", "listEmbedTokens", { deckId });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckEmbedTokens();
+      const result = await this.connection.execute(query, { deckId });
+      return result["deckEmbedTokens"];
+    });
+  }
+  /**
+   * List trusted access token issuers for a deck.
+   */
+  async listAccessTokenIssuers(deckId, options = {}) {
+    const key = this.cacheKey("decks", "listAccessTokenIssuers", { deckId });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckAccessTokenIssuers();
+      const result = await this.connection.execute(query, { deckId });
+      return result["deckAccessTokenIssuers"];
+    });
+  }
+  /**
+   * List API applications with explicit access to one owned deck.
+   */
+  async listApiApplicationAccesses(deckId, options = {}) {
+    const variables = QueryBuilder.deckApiApplicationAccessesVariables(
+      deckId,
+      options.includeRevoked
+    );
+    const key = this.cacheKey("decks", "listApiApplicationAccesses", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckApiApplicationAccesses();
+      const result = await this.connection.execute(query, variables);
+      return result["deckApiApplicationAccesses"];
+    });
+  }
+  /**
+   * List selected-deck grants for the current account.
+   */
+  async listMyApiApplicationAccesses(options = {}) {
+    const variables = QueryBuilder.myDeckApiApplicationAccessesVariables(options.applicationId);
+    const key = this.cacheKey("decks", "listMyApiApplicationAccesses", variables);
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.myDeckApiApplicationAccesses();
+      const result = await this.connection.execute(query, variables);
+      return result["myDeckApiApplicationAccesses"];
+    });
+  }
   /**
    * Create a hosted deck.
    */
@@ -872,6 +1145,176 @@ var DecksResource = class extends BaseResource {
     const result = await this.connection.execute(query, variables);
     return result["deckUpdate"];
   }
+  /**
+   * Update deck-level metadata without mutating entries.
+   */
+  async updateMetadata(id, input) {
+    return this.update(id, input);
+  }
+  /**
+   * Create or replace a draft by API-application external reference.
+   */
+  async upsertByExternalRef(input) {
+    this.config.requireSecretCredential("decks.upsertByExternalRef");
+    const { query } = QueryBuilder.upsertDeckByExternalRef();
+    const variables = QueryBuilder.deckUpsertByExternalRefVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckUpsertByExternalRef"];
+  }
+  /**
+   * Claim an app-owned deck into the consenting OAuth user's account.
+   */
+  async claim(id, input) {
+    const { query } = QueryBuilder.claimDeck();
+    const variables = QueryBuilder.deckClaimVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckClaim"];
+  }
+  /**
+   * Transfer a deck to another account.
+   */
+  async transferOwnership(id, input) {
+    const { query } = QueryBuilder.transferDeckOwnership();
+    const variables = QueryBuilder.deckTransferOwnershipVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckTransferOwnership"];
+  }
+  /**
+   * Copy a deck into the current principal's ownership namespace.
+   */
+  async copy(id, input) {
+    const { query } = QueryBuilder.copyDeck();
+    const variables = QueryBuilder.deckCopyVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckCopy"];
+  }
+  /**
+   * Add one entry to a deck draft.
+   */
+  async addEntry(input) {
+    const { query } = QueryBuilder.addDeckEntry();
+    const variables = QueryBuilder.deckEntryAddVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntryAdd"];
+  }
+  /**
+   * Update one stable deck entry.
+   */
+  async updateEntry(id, input) {
+    const { query } = QueryBuilder.updateDeckEntry();
+    const variables = QueryBuilder.deckEntryUpdateVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntryUpdate"];
+  }
+  /**
+   * Remove one stable deck entry.
+   */
+  async removeEntry(id, expectedDraftRevision) {
+    const { query } = QueryBuilder.removeDeckEntry();
+    const variables = QueryBuilder.deckEntryRemoveVariables(id, expectedDraftRevision);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntryRemove"];
+  }
+  /**
+   * Reorder deck entries within or across sections.
+   */
+  async reorderEntries(deckId, input) {
+    const { query } = QueryBuilder.reorderDeckEntries();
+    const variables = QueryBuilder.deckEntryReorderVariables(deckId, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntryReorder"];
+  }
+  /**
+   * Explicitly replace all deck entries for import or repair flows.
+   */
+  async replaceEntries(deckId, input) {
+    const { query } = QueryBuilder.replaceDeckEntries();
+    const variables = QueryBuilder.deckEntriesReplaceVariables(deckId, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntriesReplace"];
+  }
+  /**
+   * Import a decklist into an existing deck or dry-run resolution.
+   */
+  async importDeck(input) {
+    const { query } = QueryBuilder.importDeck();
+    const variables = QueryBuilder.deckImportVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckImport"];
+  }
+  /**
+   * List publisher-managed configured import formats for a game.
+   */
+  async listImportFormats(gameId, options = {}) {
+    const { query, variables } = QueryBuilder.deckImportFormats({
+      gameId,
+      includeArchived: options.includeArchived,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("decks", "listImportFormats", variables);
+    const data = await this.withCache(key, "decks", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["deckImportFormats"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listImportFormats(gameId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Fetch one configured import format by UUID.
+   */
+  async fetchImportFormat(id, options = {}) {
+    const key = this.cacheKey("decks", "fetchImportFormat", { id });
+    return this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.deckImportFormat();
+      const result = await this.connection.execute(query, { id });
+      return result["deckImportFormat"] ?? null;
+    });
+  }
+  /**
+   * Preview configured import-format parsing and record resolution.
+   */
+  async testImportFormat(input) {
+    const { query } = QueryBuilder.deckImportFormatTest();
+    const variables = QueryBuilder.deckImportFormatTestVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckImportFormatTest"];
+  }
+  /**
+   * Create a publisher-managed configured import format.
+   */
+  async createImportFormat(input) {
+    const { query } = QueryBuilder.createDeckImportFormat();
+    const variables = QueryBuilder.deckImportFormatCreateVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckImportFormatCreate"];
+  }
+  /**
+   * Update a publisher-managed configured import format.
+   */
+  async updateImportFormat(id, input) {
+    const { query } = QueryBuilder.updateDeckImportFormat();
+    const variables = QueryBuilder.deckImportFormatUpdateVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckImportFormatUpdate"];
+  }
+  /**
+   * Archive a configured import format.
+   */
+  async archiveImportFormat(id) {
+    const { query } = QueryBuilder.archiveDeckImportFormat();
+    const result = await this.connection.execute(query, { id });
+    return result["deckImportFormatArchive"];
+  }
+  /**
+   * Restore an archived configured import format.
+   */
+  async unarchiveImportFormat(id) {
+    const { query } = QueryBuilder.unarchiveDeckImportFormat();
+    const result = await this.connection.execute(query, { id });
+    return result["deckImportFormatUnarchive"];
+  }
   /**
    * Delete a hosted deck.
    */
@@ -880,15 +1323,48 @@ var DecksResource = class extends BaseResource {
     const result = await this.connection.execute(query, { id });
     return Boolean(result["deckDelete"]);
   }
+  /**
+   * Recoverably hide a deck from normal owner and public lists.
+   */
+  async archive(id) {
+    const { query } = QueryBuilder.archiveDeck();
+    const result = await this.connection.execute(query, { id });
+    return result["deckArchive"];
+  }
+  /**
+   * Restore an archived deck to draft or published state.
+   */
+  async restore(id) {
+    const { query } = QueryBuilder.restoreDeck();
+    const result = await this.connection.execute(query, { id });
+    return result["deckRestore"];
+  }
+  /**
+   * Remove the current public published pointer while keeping version history.
+   */
+  async unpublish(id) {
+    const { query } = QueryBuilder.unpublishDeck();
+    const result = await this.connection.execute(query, { id });
+    return result["deckUnpublish"];
+  }
   /**
    * Publish the current draft as an immutable deck version.
    */
-  async publish(id, input = {}) {
+  async publish(id, input) {
     const { query } = QueryBuilder.publishDeck();
     const variables = QueryBuilder.deckPublishVariables(id, input);
     const result = await this.connection.execute(query, variables);
     return result["deckPublish"];
   }
+  /**
+   * Remove draft entries that fail card-reference validation.
+   */
+  async removeInvalidEntries(id, input) {
+    const { query } = QueryBuilder.removeInvalidDeckEntries();
+    const variables = QueryBuilder.deckRemoveInvalidEntriesVariables(id, input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckRemoveInvalidEntries"];
+  }
   /**
    * Create or update a deck collaborator.
    */
@@ -924,6 +1400,85 @@ var DecksResource = class extends BaseResource {
     const result = await this.connection.execute(query, { id });
     return Boolean(result["deckPreviewTokenRevoke"]);
   }
+  /**
+   * Create a revocable published embed token.
+   */
+  async createEmbedToken(input) {
+    const { query } = QueryBuilder.createDeckEmbedToken();
+    const variables = QueryBuilder.deckEmbedTokenCreateVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEmbedTokenCreate"];
+  }
+  /**
+   * Revoke a published embed token.
+   */
+  async revokeEmbedToken(id) {
+    const { query } = QueryBuilder.revokeDeckEmbedToken();
+    const result = await this.connection.execute(query, { id });
+    return Boolean(result["deckEmbedTokenRevoke"]);
+  }
+  /**
+   * Trust the current API application to exchange short-lived deck access tokens.
+   */
+  async createAccessTokenIssuer(input) {
+    const { query } = QueryBuilder.createDeckAccessTokenIssuer();
+    const variables = QueryBuilder.deckAccessTokenIssuerCreateVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckAccessTokenIssuerCreate"];
+  }
+  /**
+   * Revoke a trusted deck access token issuer.
+   */
+  async revokeAccessTokenIssuer(id) {
+    const { query } = QueryBuilder.revokeDeckAccessTokenIssuer();
+    const result = await this.connection.execute(query, { id });
+    return Boolean(result["deckAccessTokenIssuerRevoke"]);
+  }
+  /**
+   * Revoke only the direct signing key for a trusted deck access token issuer.
+   */
+  async revokeAccessTokenIssuerSigningKey(id) {
+    const { query } = QueryBuilder.revokeDeckAccessTokenIssuerSigningKey();
+    const result = await this.connection.execute(query, { id });
+    return result["deckAccessTokenIssuerSigningKeyRevoke"];
+  }
+  /**
+   * Grant or update one OAuth app's selected-deck access.
+   */
+  async grantApiApplicationAccess(input) {
+    const { query } = QueryBuilder.grantDeckApiApplicationAccess();
+    const variables = QueryBuilder.deckApiApplicationAccessGrantVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckApiApplicationAccessGrant"];
+  }
+  /**
+   * Revoke one OAuth app's selected-deck access.
+   */
+  async revokeApiApplicationAccess(deckId, apiApplicationId) {
+    const { query } = QueryBuilder.revokeDeckApiApplicationAccess();
+    const variables = QueryBuilder.deckApiApplicationAccessRevokeVariables(deckId, apiApplicationId);
+    const result = await this.connection.execute(query, variables);
+    return Boolean(result["deckApiApplicationAccessRevoke"]);
+  }
+  /**
+   * Exchange the current trusted API application credential for a deck access token.
+   */
+  async exchangeAccessToken(input) {
+    this.config.requireSecretCredential("decks.exchangeAccessToken");
+    const { query } = QueryBuilder.exchangeDeckAccessToken();
+    const variables = QueryBuilder.deckAccessTokenExchangeVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckAccessTokenExchange"];
+  }
+  /**
+   * Revoke an exchanged deck access token.
+   */
+  async revokeAccessToken(id) {
+    this.config.requireSecretCredential("decks.revokeAccessToken");
+    const { query } = QueryBuilder.revokeDeckAccessToken();
+    const result = await this.connection.execute(query, { id });
+    return Boolean(result["deckAccessTokenRevoke"]);
+  }
   /**
    * Hydrate third-party-owned deck entries without storing them in CardDB.
    */
@@ -1335,7 +1890,11 @@ var CardDBClient = class _CardDBClient {
   withConfig(overrides) {
     const mergedConfig = this.config.merge(overrides);
     return new _CardDBClient({
-      apiKey: mergedConfig.apiKey,
+      apiKey: mergedConfig.configApiKey(),
+      publishableKey: mergedConfig.publishableKey,
+      secretKey: mergedConfig.secretKey,
+      accessToken: mergedConfig.accessToken,
+      environment: mergedConfig.environment,
       endpoint: mergedConfig.endpoint,
       timeout: mergedConfig.timeout,
       openTimeout: mergedConfig.openTimeout,