@carddb/client 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -613,6 +613,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 } = core.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 core.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 } = core.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 } = core.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 } = core.QueryBuilder.createGame();
+    const result = await this.connection.execute(query, core.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 } = core.QueryBuilder.updateGame();
+    const result = await this.connection.execute(query, core.QueryBuilder.gameUpdateVariables(id, input));
+    return result["gameUpdate"];
+  }
   /**
    * Search for games
    *
@@ -688,6 +755,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 } = core.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 core.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 } = core.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 } = core.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
    *
@@ -1471,6 +1590,16 @@ var DecksResource = class extends BaseResource {
     const result = await this.connection.execute(query, variables);
     return result["deckAccessTokenExchange"];
   }
+  /**
+   * Exchange the current secret API application credential for an app-owned deck session token.
+   */
+  async exchangeSessionToken(input) {
+    this.config.requireSecretCredential("decks.exchangeSessionToken");
+    const { query } = core.QueryBuilder.exchangeDeckSessionToken();
+    const variables = core.QueryBuilder.deckSessionTokenExchangeVariables(input);
+    const result = await this.connection.execute(query, variables);
+    return result["deckSessionTokenExchange"];
+  }
   /**
    * Revoke an exchanged deck access token.
    */
@@ -1533,6 +1662,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 = core.resolveFilter(options.filter);
+    const { query, variables } = core.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 core.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 } = core.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 } = core.QueryBuilder.upsertDatasetRecords();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.QueryBuilder.deleteDatasetRecords();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.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 } = core.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 core.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
    *
@@ -1814,6 +2058,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 } = core.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 core.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 } = core.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 } = core.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 } = core.QueryBuilder.deckImportFormatTest();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.QueryBuilder.createDeckImportFormat();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.QueryBuilder.updateDeckImportFormat();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.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 } = core.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 } = core.QueryBuilder.datasetImportPreview();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.datasetImportPreviewVariables(input)
+    );
+    return result["datasetImportPreview"];
+  }
+  /**
+   * Validate a single-dataset import source with dry-run enforced.
+   */
+  async validate(input) {
+    const { query } = core.QueryBuilder.datasetImportValidate();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.QueryBuilder.datasetImportFromFile();
+      const result2 = await this.connection.execute(
+        query2,
+        core.QueryBuilder.datasetImportFromFileVariables(input)
+      );
+      return result2["datasetImportFromFile"];
+    }
+    if ("sourceUrl" in input && input.sourceUrl) {
+      const { query: query2 } = core.QueryBuilder.datasetImportFromUrl();
+      const result2 = await this.connection.execute(
+        query2,
+        core.QueryBuilder.datasetImportFromUrlVariables(input)
+      );
+      return result2["datasetImportFromUrl"];
+    }
+    const { query } = core.QueryBuilder.datasetImportFromPayload();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.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 } = core.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 core.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 } = core.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 } = core.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 core.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 } = core.QueryBuilder.gameImportPreview();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.QueryBuilder.gameImportFromFile();
+      const result2 = await this.connection.execute(
+        query2,
+        core.QueryBuilder.gameImportFromFileVariables(input)
+      );
+      return result2["gameImportFromFile"];
+    }
+    if ("sourceUrl" in input && input.sourceUrl) {
+      const { query: query2 } = core.QueryBuilder.gameImportFromUrl();
+      const result2 = await this.connection.execute(
+        query2,
+        core.QueryBuilder.gameImportFromUrlVariables(input)
+      );
+      return result2["gameImportFromUrl"];
+    }
+    const { query } = core.QueryBuilder.gameImportFromPayload();
+    const result = await this.connection.execute(
+      query,
+      core.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 } = core.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 } = core.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 core.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 } = core.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 } = core.QueryBuilder.datasetExport();
+    const result = await this.connection.execute(query, core.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 } = core.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 } = core.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 core.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 } = core.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 } = core.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 } = core.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 } = core.QueryBuilder.fileUploadRequest();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.fileUploadRequestVariables(input)
+    );
+    return result["fileUploadRequest"];
+  }
+  /**
+   * Confirm that a presigned upload completed.
+   */
+  async confirmUpload(id) {
+    this.config.requireSecretCredential("files.confirmUpload");
+    const { query } = core.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 } = core.QueryBuilder.fileDelete();
+    const result = await this.connection.execute(query, { id });
+    return Boolean(result["fileDelete"]);
+  }
+};
 
 // src/client.ts
 var CardDBClient = class _CardDBClient {
@@ -1831,6 +2551,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
    *
@@ -1845,6 +2573,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
@@ -1932,7 +2664,11 @@ exports.DEFAULT_RETRY_MAX_DELAY = DEFAULT_RETRY_MAX_DELAY;
 exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
 exports.DatasetsResource = DatasetsResource;
 exports.DecksResource = DecksResource;
+exports.ExportsResource = ExportsResource;
+exports.FilesResource = FilesResource;
 exports.GamesResource = GamesResource;
+exports.ImportFormatsResource = ImportFormatsResource;
+exports.ImportsResource = ImportsResource;
 exports.PublishersResource = PublishersResource;
 exports.RecordsResource = RecordsResource;
 exports.RulesResource = RulesResource;