@carddb/client 0.1.5 → 0.2.5

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
@@ -575,6 +612,73 @@ var GamesResource = class extends BaseResource {
   constructor(connection, config) {
     super(connection, config);
   }
+  /**
+   * List games for a publisher-management context.
+   */
+  async list(publisherId, options = {}) {
+    const { query, variables } = QueryBuilder.listGames({
+      publisherId,
+      first: options.first,
+      after: options.after,
+      includeArchived: options.includeArchived
+    });
+    const key = this.cacheKey("games", "list", variables);
+    const data = await this.withCache(key, "games", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["games"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.list(publisherId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Get a publisher-managed game by stable key.
+   */
+  async getByKey(options) {
+    const key = this.cacheKey("games", "getByKey", {
+      publisherId: options.publisherId,
+      publisherSlug: options.publisherSlug,
+      gameKey: options.gameKey
+    });
+    return this.withCache(key, "games", options, async () => {
+      const { query, variables } = QueryBuilder.game(options);
+      const result = await this.connection.execute(query, variables);
+      return result["game"] ?? null;
+    });
+  }
+  /**
+   * Get a publisher-managed game by slug.
+   */
+  async getBySlug(options) {
+    const key = this.cacheKey("games", "getBySlug", {
+      publisherId: options.publisherId,
+      publisherSlug: options.publisherSlug,
+      gameSlug: options.gameSlug
+    });
+    return this.withCache(key, "games", options, async () => {
+      const { query, variables } = QueryBuilder.game(options);
+      const result = await this.connection.execute(query, variables);
+      return result["game"] ?? null;
+    });
+  }
+  /**
+   * Create a publisher-managed game. Requires a server-side secret credential.
+   */
+  async create(input) {
+    this.config.requireSecretCredential("games.create");
+    const { query } = QueryBuilder.createGame();
+    const result = await this.connection.execute(query, QueryBuilder.gameCreateVariables(input));
+    return result["gameCreate"];
+  }
+  /**
+   * Update a publisher-managed game. Requires a server-side secret credential.
+   */
+  async update(id, input) {
+    this.config.requireSecretCredential("games.update");
+    const { query } = QueryBuilder.updateGame();
+    const result = await this.connection.execute(query, QueryBuilder.gameUpdateVariables(id, input));
+    return result["gameUpdate"];
+  }
   /**
    * Search for games
    *
@@ -650,6 +754,58 @@ var DatasetsResource = class extends BaseResource {
   constructor(connection, config) {
     super(connection, config);
   }
+  /**
+   * List datasets for a publisher-management context.
+   */
+  async list(publisherId, options = {}) {
+    const { query, variables } = QueryBuilder.listDatasets({
+      publisherId,
+      gameId: options.gameId,
+      includeArchived: options.includeArchived,
+      purpose: options.purpose,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("datasets", "list", variables);
+    const data = await this.withCache(key, "datasets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["datasets"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.list(publisherId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Get a dataset by game ID and stable dataset key.
+   */
+  async getByKey(options) {
+    const key = this.cacheKey("datasets", "getByKey", {
+      publisherId: options.publisherId,
+      gameId: options.gameId,
+      datasetKey: options.datasetKey
+    });
+    return this.withCache(key, "datasets", options, async () => {
+      const { query, variables } = QueryBuilder.dataset(options);
+      const result = await this.connection.execute(query, variables);
+      return result["dataset"] ?? null;
+    });
+  }
+  /**
+   * Fetch only the schema portion for a dataset.
+   */
+  async getSchema(idOrOptions) {
+    const dataset = typeof idOrOptions === "string" ? await this.withCache(
+      this.cacheKey("datasets", "getSchema", { id: idOrOptions }),
+      "datasets",
+      {},
+      async () => {
+        const { query, variables } = QueryBuilder.dataset({ id: idOrOptions });
+        const result = await this.connection.execute(query, variables);
+        return result["dataset"] ?? null;
+      }
+    ) : await this.getByKey(idOrOptions);
+    return dataset?.schema ?? null;
+  }
   /**
    * Search for datasets
    *
@@ -742,6 +898,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 +931,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 +953,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 +982,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 +1077,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 +1197,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.
    */
@@ -873,91 +1265,373 @@ var DecksResource = class extends BaseResource {
     return result["deckUpdate"];
   }
   /**
-   * Delete a hosted deck.
+   * Update deck-level metadata without mutating entries.
    */
-  async delete(id) {
-    const { query } = QueryBuilder.deleteDeck();
-    const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckDelete"]);
+  async updateMetadata(id, input) {
+    return this.update(id, input);
   }
   /**
-   * Publish the current draft as an immutable deck version.
+   * Create or replace a draft by API-application external reference.
    */
-  async publish(id, input = {}) {
-    const { query } = QueryBuilder.publishDeck();
-    const variables = QueryBuilder.deckPublishVariables(id, input);
+  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["deckPublish"];
+    return result["deckUpsertByExternalRef"];
   }
   /**
-   * Create or update a deck collaborator.
+   * Claim an app-owned deck into the consenting OAuth user's account.
    */
-  async upsertCollaborator(deckId, accountId, role) {
-    const { query } = QueryBuilder.upsertDeckCollaborator();
-    const variables = QueryBuilder.deckCollaboratorVariables(deckId, accountId, role);
+  async claim(id, input) {
+    const { query } = QueryBuilder.claimDeck();
+    const variables = QueryBuilder.deckClaimVariables(id, input);
     const result = await this.connection.execute(query, variables);
-    return result["deckCollaboratorUpsert"];
+    return result["deckClaim"];
   }
   /**
-   * Remove a deck collaborator.
+   * Transfer a deck to another account.
    */
-  async removeCollaborator(deckId, accountId) {
-    const { query } = QueryBuilder.removeDeckCollaborator();
-    const variables = QueryBuilder.deckCollaboratorVariables(deckId, accountId);
+  async transferOwnership(id, input) {
+    const { query } = QueryBuilder.transferDeckOwnership();
+    const variables = QueryBuilder.deckTransferOwnershipVariables(id, input);
     const result = await this.connection.execute(query, variables);
-    return Boolean(result["deckCollaboratorRemove"]);
+    return result["deckTransferOwnership"];
   }
   /**
-   * Create a revocable draft preview token.
+   * Copy a deck into the current principal's ownership namespace.
    */
-  async createPreviewToken(input) {
-    const { query } = QueryBuilder.createDeckPreviewToken();
-    const variables = QueryBuilder.deckPreviewTokenCreateVariables(input);
+  async copy(id, input) {
+    const { query } = QueryBuilder.copyDeck();
+    const variables = QueryBuilder.deckCopyVariables(id, input);
     const result = await this.connection.execute(query, variables);
-    return result["deckPreviewTokenCreate"];
+    return result["deckCopy"];
   }
   /**
-   * Revoke a draft preview token.
+   * Add one entry to a deck draft.
    */
-  async revokePreviewToken(id) {
-    const { query } = QueryBuilder.revokeDeckPreviewToken();
-    const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckPreviewTokenRevoke"]);
+  async addEntry(input) {
+    const { query } = QueryBuilder.addDeckEntry();
+    const variables = QueryBuilder.deckEntryAddVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckEntryAdd"];
   }
   /**
-   * Hydrate third-party-owned deck entries without storing them in CardDB.
+   * Update one stable deck entry.
    */
-  async hydrateEntries(options) {
-    if (options.entries.length === 0) return [];
-    const publisherSlug = this.resolvePublisher(options.publisherSlug);
-    const gameKey = this.resolveGame(options.gameKey);
-    this.validateAccess(publisherSlug, gameKey);
-    const identifiers = options.entries.map((entry) => entry.identifier);
-    const key = this.cacheKey("decks", "hydrateEntries", {
-      publisherSlug,
-      gameKey,
-      datasetKey: options.datasetKey,
-      identifiers
-    });
-    const records = await this.withCache(key, "decks", options, async () => {
-      const { query } = QueryBuilder.fetchRecordsByIdentifier();
-      const result = await this.connection.execute(query, {
-        publisherSlug,
-        gameKey,
-        datasetKey: options.datasetKey,
-        identifiers
-      });
-      return result["fetchRecordsByIdentifier"];
-    });
-    const recordsByIdentifier = recordsByDeckIdentifier(
-      records,
-      identifiers,
-      options.identifierField
-    );
-    return options.entries.map((entry) => ({
-      ...entry,
-      record: recordsByIdentifier.get(entry.identifier) ?? null
-    }));
+  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.
+   */
+  async delete(id) {
+    const { query } = QueryBuilder.deleteDeck();
+    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) {
+    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.
+   */
+  async upsertCollaborator(deckId, accountId, role) {
+    const { query } = QueryBuilder.upsertDeckCollaborator();
+    const variables = QueryBuilder.deckCollaboratorVariables(deckId, accountId, role);
+    const result = await this.connection.execute(query, variables);
+    return result["deckCollaboratorUpsert"];
+  }
+  /**
+   * Remove a deck collaborator.
+   */
+  async removeCollaborator(deckId, accountId) {
+    const { query } = QueryBuilder.removeDeckCollaborator();
+    const variables = QueryBuilder.deckCollaboratorVariables(deckId, accountId);
+    const result = await this.connection.execute(query, variables);
+    return Boolean(result["deckCollaboratorRemove"]);
+  }
+  /**
+   * Create a revocable draft preview token.
+   */
+  async createPreviewToken(input) {
+    const { query } = QueryBuilder.createDeckPreviewToken();
+    const variables = QueryBuilder.deckPreviewTokenCreateVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckPreviewTokenCreate"];
+  }
+  /**
+   * Revoke a draft preview token.
+   */
+  async revokePreviewToken(id) {
+    const { query } = QueryBuilder.revokeDeckPreviewToken();
+    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.
+   */
+  async hydrateEntries(options) {
+    if (options.entries.length === 0) return [];
+    const publisherSlug = this.resolvePublisher(options.publisherSlug);
+    const gameKey = this.resolveGame(options.gameKey);
+    this.validateAccess(publisherSlug, gameKey);
+    const identifiers = options.entries.map((entry) => entry.identifier);
+    const key = this.cacheKey("decks", "hydrateEntries", {
+      publisherSlug,
+      gameKey,
+      datasetKey: options.datasetKey,
+      identifiers
+    });
+    const records = await this.withCache(key, "decks", options, async () => {
+      const { query } = QueryBuilder.fetchRecordsByIdentifier();
+      const result = await this.connection.execute(query, {
+        publisherSlug,
+        gameKey,
+        datasetKey: options.datasetKey,
+        identifiers
+      });
+      return result["fetchRecordsByIdentifier"];
+    });
+    const recordsByIdentifier = recordsByDeckIdentifier(
+      records,
+      identifiers,
+      options.identifierField
+    );
+    return options.entries.map((entry) => ({
+      ...entry,
+      record: recordsByIdentifier.get(entry.identifier) ?? null
+    }));
   }
 };
 function recordsByDeckIdentifier(records, identifiers, identifierField) {
@@ -977,6 +1651,121 @@ var RecordsResource = class extends BaseResource {
   constructor(connection, config) {
     super(connection, config);
   }
+  /**
+   * List records in a publisher-accessible dataset by dataset ID.
+   */
+  async list(options) {
+    const filter = resolveFilter(options.filter);
+    const { query, variables } = QueryBuilder.listDatasetRecords({
+      datasetId: options.datasetId,
+      filter,
+      orderBy: options.orderBy,
+      first: options.first,
+      after: options.after,
+      last: options.last,
+      before: options.before,
+      validateSchema: options.validateSchema
+    });
+    const key = this.cacheKey("records", "list", variables);
+    const data = await this.withCache(key, "records", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["datasetRecords"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.list({ ...options, after: cursor })
+    });
+  }
+  /**
+   * Get a publisher-accessible record by dataset ID and identifier value.
+   */
+  async getByDatasetIdentifier(options) {
+    const key = this.cacheKey("records", "getByDatasetIdentifier", {
+      datasetId: options.datasetId,
+      identifier: options.identifier,
+      includePricing: options.includePricing ?? false
+    });
+    return this.withCache(key, "records", options, async () => {
+      const { query, variables } = QueryBuilder.datasetRecord({
+        datasetId: options.datasetId,
+        identifier: options.identifier,
+        includePricing: options.includePricing
+      });
+      const result = await this.connection.execute(query, variables);
+      return result["datasetRecord"] ?? null;
+    });
+  }
+  /**
+   * Start an import-backed batch upsert, or return a dry-run result. Requires a secret credential.
+   */
+  async upsertBatch(input) {
+    this.config.requireSecretCredential("records.upsertBatch");
+    const { query } = QueryBuilder.upsertDatasetRecords();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.datasetRecordsUpsertVariables(input)
+    );
+    return result["datasetRecordsUpsert"];
+  }
+  /**
+   * Create a dry-run or destructive bulk delete/reconciliation job. Requires a secret credential.
+   */
+  async deleteBatch(input) {
+    this.config.requireSecretCredential("records.deleteBatch");
+    const { query } = QueryBuilder.deleteDatasetRecords();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.datasetRecordsDeleteVariables(input)
+    );
+    return result["datasetRecordsDelete"];
+  }
+  /**
+   * Get one bulk delete/reconciliation job.
+   */
+  async getDeleteJob(id, options = {}) {
+    const key = this.cacheKey("records", "getDeleteJob", { id });
+    return this.withCache(key, "records", options, async () => {
+      const { query } = QueryBuilder.datasetRecordDeleteJob();
+      const result = await this.connection.execute(query, { id });
+      return result["datasetRecordDeleteJob"] ?? null;
+    });
+  }
+  /**
+   * List bulk delete/reconciliation jobs for a publisher.
+   */
+  async listDeleteJobs(publisherId, options = {}) {
+    const { query, variables } = QueryBuilder.datasetRecordDeleteJobs({
+      publisherId,
+      datasetId: options.datasetId,
+      status: options.status,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("records", "listDeleteJobs", variables);
+    const data = await this.withCache(key, "records", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["datasetRecordDeleteJobs"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listDeleteJobs(publisherId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Poll a delete job until it reaches a terminal state.
+   */
+  async waitForDeleteJob(id, options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const startedAt = Date.now();
+    while (true) {
+      const job = await this.getDeleteJob(id, { cache: false });
+      if (!job) throw new Error(`Delete job '${id}' was not found`);
+      if (job.status === "COMPLETED" || job.status === "FAILED") return job;
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for delete job '${id}'`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
   /**
    * Search for records in a dataset with filtering, search, and pagination
    *
@@ -1258,6 +2047,482 @@ var RulesResource = class extends BaseResource {
     });
   }
 };
+var ImportFormatsResource = class extends BaseResource {
+  constructor(connection, config) {
+    super(connection, config);
+  }
+  /**
+   * List publisher-managed import formats by publisher or game scope.
+   */
+  async list(options) {
+    const { query, variables } = QueryBuilder.deckImportFormats({
+      publisherId: options.publisherId,
+      gameId: options.gameId,
+      includeArchived: options.includeArchived,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("importFormats", "list", variables);
+    const data = await this.withCache(key, "importFormats", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["deckImportFormats"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.list({ ...options, after: cursor })
+    });
+  }
+  /**
+   * Get one import format by UUID.
+   */
+  async get(id, options = {}) {
+    const key = this.cacheKey("importFormats", "get", { id });
+    return this.withCache(key, "importFormats", options, async () => {
+      const { query } = QueryBuilder.deckImportFormat();
+      const result = await this.connection.execute(query, { id });
+      return result["deckImportFormat"] ?? null;
+    });
+  }
+  /**
+   * Get one import format by game ID and stable key.
+   */
+  async getByKey(options) {
+    const key = this.cacheKey("importFormats", "getByKey", {
+      gameId: options.gameId,
+      formatKey: options.key
+    });
+    return this.withCache(key, "importFormats", options, async () => {
+      const { query } = QueryBuilder.deckImportFormat();
+      const result = await this.connection.execute(query, {
+        gameId: options.gameId,
+        key: options.key
+      });
+      return result["deckImportFormat"] ?? null;
+    });
+  }
+  /**
+   * Preview parsing and record resolution for a configured import format.
+   */
+  async test(input) {
+    const { query } = QueryBuilder.deckImportFormatTest();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.deckImportFormatTestVariables(input)
+    );
+    return result["deckImportFormatTest"];
+  }
+  /**
+   * Create an import format. Requires a server-side secret credential.
+   */
+  async create(input) {
+    this.config.requireSecretCredential("importFormats.create");
+    const { query } = QueryBuilder.createDeckImportFormat();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.deckImportFormatCreateVariables(input)
+    );
+    return result["deckImportFormatCreate"];
+  }
+  /**
+   * Update an import format. Requires a server-side secret credential.
+   */
+  async update(id, input) {
+    this.config.requireSecretCredential("importFormats.update");
+    const { query } = QueryBuilder.updateDeckImportFormat();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.deckImportFormatUpdateVariables(id, input)
+    );
+    return result["deckImportFormatUpdate"];
+  }
+  /**
+   * Archive an import format. Requires a server-side secret credential.
+   */
+  async archive(id) {
+    this.config.requireSecretCredential("importFormats.archive");
+    const { query } = QueryBuilder.archiveDeckImportFormat();
+    const result = await this.connection.execute(query, { id });
+    return result["deckImportFormatArchive"];
+  }
+  /**
+   * Restore an archived import format. Requires a server-side secret credential.
+   */
+  async unarchive(id) {
+    this.config.requireSecretCredential("importFormats.unarchive");
+    const { query } = QueryBuilder.unarchiveDeckImportFormat();
+    const result = await this.connection.execute(query, { id });
+    return result["deckImportFormatUnarchive"];
+  }
+};
+var ImportsResource = class extends BaseResource {
+  constructor(connection, config) {
+    super(connection, config);
+  }
+  /**
+   * Preview a single-dataset import source without writing records or schema.
+   */
+  async preview(input) {
+    const { query } = QueryBuilder.datasetImportPreview();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.datasetImportPreviewVariables(input)
+    );
+    return result["datasetImportPreview"];
+  }
+  /**
+   * Validate a single-dataset import source with dry-run enforced.
+   */
+  async validate(input) {
+    const { query } = QueryBuilder.datasetImportValidate();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.datasetImportValidateVariables(input)
+    );
+    return result["datasetImportValidate"];
+  }
+  /**
+   * Start an async single-dataset import from `fileId`, `data`, or `sourceUrl`.
+   */
+  async run(input) {
+    this.config.requireSecretCredential("imports.run");
+    if ("fileId" in input && input.fileId) {
+      const { query: query2 } = QueryBuilder.datasetImportFromFile();
+      const result2 = await this.connection.execute(
+        query2,
+        QueryBuilder.datasetImportFromFileVariables(input)
+      );
+      return result2["datasetImportFromFile"];
+    }
+    if ("sourceUrl" in input && input.sourceUrl) {
+      const { query: query2 } = QueryBuilder.datasetImportFromUrl();
+      const result2 = await this.connection.execute(
+        query2,
+        QueryBuilder.datasetImportFromUrlVariables(input)
+      );
+      return result2["datasetImportFromUrl"];
+    }
+    const { query } = QueryBuilder.datasetImportFromPayload();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.datasetImportFromPayloadVariables(input)
+    );
+    return result["datasetImportFromPayload"];
+  }
+  /**
+   * Fetch one single-dataset import job.
+   */
+  async getJob(id, options = {}) {
+    const key = this.cacheKey("imports", "getJob", { id });
+    return this.withCache(key, "imports", options, async () => {
+      const { query } = QueryBuilder.importJob();
+      const result = await this.connection.execute(query, { id });
+      return result["importJob"] ?? null;
+    });
+  }
+  /**
+   * List single-dataset import jobs for a publisher.
+   */
+  async listJobs(publisherId, options = {}) {
+    const { query, variables } = QueryBuilder.importJobs({
+      publisherId,
+      datasetId: options.datasetId,
+      status: options.status,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("imports", "listJobs", variables);
+    const data = await this.withCache(key, "imports", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["importJobs"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listJobs(publisherId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Cancel a pending or processing single-dataset import job.
+   */
+  async cancelJob(id) {
+    this.config.requireSecretCredential("imports.cancelJob");
+    const { query } = QueryBuilder.importJobCancel();
+    const result = await this.connection.execute(query, { id });
+    return result["importJobCancel"];
+  }
+  /**
+   * List structured logs for one single-dataset import job.
+   */
+  async listJobLogs(importJobId, options = {}) {
+    const { query, variables } = QueryBuilder.importJobLogs({
+      importJobId,
+      level: options.level,
+      datasetKey: options.datasetKey,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("imports", "listJobLogs", variables);
+    const data = await this.withCache(key, "imports", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      const job = result["importJob"];
+      return job?.logs ?? emptyConnection();
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listJobLogs(importJobId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Poll a single-dataset import job until completion or failure.
+   */
+  async waitForJob(id, options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const startedAt = Date.now();
+    while (true) {
+      const job = await this.getJob(id, { cache: false });
+      if (!job) throw new Error(`Import job '${id}' was not found`);
+      if (job.status === "COMPLETED" || job.status === "FAILED") return job;
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for import job '${id}'`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+  /**
+   * Preview an advanced game-level import source without writing records or schema.
+   */
+  async previewGame(input) {
+    const { query } = QueryBuilder.gameImportPreview();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.gameImportPreviewVariables(input)
+    );
+    return result["gameImportPreview"];
+  }
+  /**
+   * Start an async advanced game-level import from `fileId`, `data`, or `sourceUrl`.
+   */
+  async runGame(input) {
+    this.config.requireSecretCredential("imports.runGame");
+    if ("fileId" in input && input.fileId) {
+      const { query: query2 } = QueryBuilder.gameImportFromFile();
+      const result2 = await this.connection.execute(
+        query2,
+        QueryBuilder.gameImportFromFileVariables(input)
+      );
+      return result2["gameImportFromFile"];
+    }
+    if ("sourceUrl" in input && input.sourceUrl) {
+      const { query: query2 } = QueryBuilder.gameImportFromUrl();
+      const result2 = await this.connection.execute(
+        query2,
+        QueryBuilder.gameImportFromUrlVariables(input)
+      );
+      return result2["gameImportFromUrl"];
+    }
+    const { query } = QueryBuilder.gameImportFromPayload();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.gameImportFromPayloadVariables(input)
+    );
+    return result["gameImportFromPayload"];
+  }
+  /**
+   * Fetch one advanced game-level import job.
+   */
+  async getGameJob(id, options = {}) {
+    const key = this.cacheKey("imports", "getGameJob", { id });
+    return this.withCache(key, "imports", options, async () => {
+      const { query } = QueryBuilder.gameImportJob();
+      const result = await this.connection.execute(query, { id });
+      return result["gameImportJob"] ?? null;
+    });
+  }
+  /**
+   * List advanced game-level import jobs.
+   */
+  async listGameJobs(gameId, options = {}) {
+    const { query, variables } = QueryBuilder.gameImportJobs({
+      gameId,
+      status: options.status,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("imports", "listGameJobs", variables);
+    const data = await this.withCache(key, "imports", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["gameImportJobs"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listGameJobs(gameId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Cancel a pending or processing advanced game-level import job.
+   */
+  async cancelGameJob(id) {
+    this.config.requireSecretCredential("imports.cancelGameJob");
+    const { query } = QueryBuilder.gameImportJobCancel();
+    const result = await this.connection.execute(query, { id });
+    return result["gameImportJobCancel"];
+  }
+  /**
+   * Poll an advanced game-level import job until completion or failure.
+   */
+  async waitForGameJob(id, options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const startedAt = Date.now();
+    while (true) {
+      const job = await this.getGameJob(id, { cache: false });
+      if (!job) throw new Error(`Game import job '${id}' was not found`);
+      if (job.status === "COMPLETED" || job.status === "FAILED") return job;
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for game import job '${id}'`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+};
+function emptyConnection() {
+  return {
+    totalCount: 0,
+    pageInfo: {
+      hasNextPage: false,
+      hasPreviousPage: false,
+      startCursor: null,
+      endCursor: null
+    },
+    edges: []
+  };
+}
+var ExportsResource = class extends BaseResource {
+  constructor(connection, config) {
+    super(connection, config);
+  }
+  /**
+   * Start an async dataset export. Requires a server-side secret credential.
+   */
+  async run(input) {
+    this.config.requireSecretCredential("exports.run");
+    const { query } = QueryBuilder.datasetExport();
+    const result = await this.connection.execute(query, QueryBuilder.datasetExportVariables(input));
+    return result["datasetExport"];
+  }
+  /** Alias for `run`. */
+  async create(input) {
+    return this.run(input);
+  }
+  /**
+   * Fetch one export job.
+   */
+  async getJob(id, options = {}) {
+    const key = this.cacheKey("exports", "getJob", { id });
+    return this.withCache(key, "exports", options, async () => {
+      const { query } = QueryBuilder.exportJob();
+      const result = await this.connection.execute(query, { id });
+      return result["exportJob"] ?? null;
+    });
+  }
+  /**
+   * List export jobs for a publisher, optionally filtered by game, dataset, or status.
+   */
+  async listJobs(publisherId, options = {}) {
+    const { query, variables } = QueryBuilder.exportJobs({
+      publisherId,
+      gameId: options.gameId,
+      datasetId: options.datasetId,
+      status: options.status,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("exports", "listJobs", variables);
+    const data = await this.withCache(key, "exports", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["exportJobs"];
+    });
+    return new Collection(data, {
+      nextPageLoader: async (cursor) => this.listJobs(publisherId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Refresh the signed download URL for a completed export job.
+   */
+  async refreshUrl(id) {
+    const { query } = QueryBuilder.exportJobRefreshUrl();
+    const result = await this.connection.execute(query, { id });
+    return result["exportJobRefreshUrl"];
+  }
+  /**
+   * Cancel a pending or processing export job. Requires a server-side secret credential.
+   */
+  async cancel(id) {
+    this.config.requireSecretCredential("exports.cancel");
+    const { query } = QueryBuilder.exportJobCancel();
+    const result = await this.connection.execute(query, { id });
+    return result["exportJobCancel"];
+  }
+  /**
+   * Poll an export job until completion or failure.
+   */
+  async waitForJob(id, options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const startedAt = Date.now();
+    while (true) {
+      const job = await this.getJob(id, { cache: false });
+      if (!job) throw new Error(`Export job '${id}' was not found`);
+      if (job.status === "COMPLETED" || job.status === "FAILED") return job;
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for export job '${id}'`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+};
+var FilesResource = class extends BaseResource {
+  constructor(connection, config) {
+    super(connection, config);
+  }
+  /**
+   * Get one file by ID.
+   */
+  async get(id, options = {}) {
+    const key = this.cacheKey("files", "get", { id });
+    return this.withCache(key, "files", options, async () => {
+      const { query } = QueryBuilder.file();
+      const result = await this.connection.execute(query, { id });
+      return result["file"] ?? null;
+    });
+  }
+  /**
+   * Request a presigned URL for direct upload. Requires a server-side secret credential.
+   */
+  async requestUpload(input) {
+    this.config.requireSecretCredential("files.requestUpload");
+    const { query } = QueryBuilder.fileUploadRequest();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.fileUploadRequestVariables(input)
+    );
+    return result["fileUploadRequest"];
+  }
+  /**
+   * Confirm that a presigned upload completed.
+   */
+  async confirmUpload(id) {
+    this.config.requireSecretCredential("files.confirmUpload");
+    const { query } = QueryBuilder.fileUploadConfirm();
+    const result = await this.connection.execute(query, { id });
+    return result["fileUploadConfirm"];
+  }
+  /**
+   * Delete a file. Requires a server-side secret credential.
+   */
+  async delete(id) {
+    this.config.requireSecretCredential("files.delete");
+    const { query } = QueryBuilder.fileDelete();
+    const result = await this.connection.execute(query, { id });
+    return Boolean(result["fileDelete"]);
+  }
+};
 
 // src/client.ts
 var CardDBClient = class _CardDBClient {
@@ -1275,6 +2540,14 @@ var CardDBClient = class _CardDBClient {
   decks;
   /** Rules resource for game rules and deck formats */
   rules;
+  /** Publisher-managed import format resource */
+  importFormats;
+  /** Publisher import job resource */
+  imports;
+  /** Publisher dataset export job resource */
+  exports;
+  /** File upload helper resource */
+  files;
   /**
    * Create a new CardDB client
    *
@@ -1289,6 +2562,10 @@ var CardDBClient = class _CardDBClient {
     this.records = new RecordsResource(this.connection, this.config);
     this.decks = new DecksResource(this.connection, this.config);
     this.rules = new RulesResource(this.connection, this.config);
+    this.importFormats = new ImportFormatsResource(this.connection, this.config);
+    this.imports = new ImportsResource(this.connection, this.config);
+    this.exports = new ExportsResource(this.connection, this.config);
+    this.files = new FilesResource(this.connection, this.config);
   }
   /**
    * Get information about the current API key
@@ -1335,7 +2612,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,
@@ -1358,6 +2639,6 @@ var CardDBClient = class _CardDBClient {
   }
 };
 
-export { BaseResource, CardDBClient, Configuration, Connection, DEFAULT_CACHE_TTL, DEFAULT_ENDPOINT, DEFAULT_MAX_NETWORK_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_OPEN_TIMEOUT, DEFAULT_RETRY_BASE_DELAY, DEFAULT_RETRY_MAX_DELAY, DEFAULT_TIMEOUT, DatasetsResource, DecksResource, GamesResource, PublishersResource, RecordsResource, RulesResource, cacheKey, getRateLimitInfo, getSDKVersion, getUserAgent, readCache, writeCache };
+export { BaseResource, CardDBClient, Configuration, Connection, DEFAULT_CACHE_TTL, DEFAULT_ENDPOINT, DEFAULT_MAX_NETWORK_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_OPEN_TIMEOUT, DEFAULT_RETRY_BASE_DELAY, DEFAULT_RETRY_MAX_DELAY, DEFAULT_TIMEOUT, DatasetsResource, DecksResource, ExportsResource, FilesResource, GamesResource, ImportFormatsResource, ImportsResource, PublishersResource, RecordsResource, RulesResource, cacheKey, getRateLimitInfo, getSDKVersion, getUserAgent, readCache, writeCache };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map