@timbenniks/contentstack-platform-sdk 0.1.0

package/dist/chunk-EREPKWTW.mjs

@@ -0,0 +1,926 @@
+import {
+  collectAll,
+  paginate
+} from "./chunk-JZE2W7VW.mjs";
+import {
+  ContentstackHttpClient
+} from "./chunk-4CJ4IVPJ.mjs";
+import {
+  resolveEndpoints
+} from "./chunk-BK2IBTQS.mjs";
+
+// src/cma/assets.ts
+var AssetsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        if (opts?.folder) params.folder = opts.folder;
+        const response = await this.http.get("/assets", params);
+        return { items: response.data.assets ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async get(uid) {
+    const response = await this.http.get(`/assets/${uid}`);
+    return response.data.asset;
+  }
+  async upload(form) {
+    const response = await this.http.upload("/assets", form);
+    return response.data.asset;
+  }
+  async update(uid, data) {
+    const response = await this.http.put(`/assets/${uid}`, { asset: data });
+    return response.data.asset;
+  }
+  async delete(uid) {
+    await this.http.delete(`/assets/${uid}`);
+  }
+  async publish(uid, data) {
+    await this.http.post(`/assets/${uid}/publish`, { asset: data });
+  }
+  async unpublish(uid, data) {
+    await this.http.post(`/assets/${uid}/unpublish`, { asset: data });
+  }
+  // ─── Folders ──────────────────────────────────────────────────────
+  async listFolders(opts) {
+    const response = await this.http.get("/assets/folders", {
+      limit: String(opts?.limit ?? 100)
+    });
+    return response.data.assets ?? [];
+  }
+  async getFolder(uid) {
+    const response = await this.http.get(`/assets/folders/${uid}`);
+    return response.data.asset;
+  }
+  async createFolder(data) {
+    const response = await this.http.post("/assets/folders", {
+      asset: data
+    });
+    return response.data.asset;
+  }
+  async updateFolder(uid, data) {
+    const response = await this.http.put(`/assets/folders/${uid}`, {
+      asset: data
+    });
+    return response.data.asset;
+  }
+  async deleteFolder(uid) {
+    await this.http.delete(`/assets/folders/${uid}`);
+  }
+  // ─── Additional Operations ──────────────────────────────────────
+  async replace(uid, form) {
+    const response = await this.http.upload(`/assets/${uid}`, form);
+    return response.data.asset;
+  }
+  async getReferences(uid) {
+    const response = await this.http.get(`/assets/${uid}/references`);
+    return response.data.references ?? [];
+  }
+};
+
+// src/cma/base-client.ts
+var CrudClient = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get(this.config.basePath, {
+          skip: String(skip),
+          limit: String(limit)
+        });
+        const items = response.data[this.config.pluralKey] ?? [];
+        return { items, count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async get(uid) {
+    const response = await this.http.get(`${this.config.basePath}/${uid}`);
+    return response.data[this.config.singularKey];
+  }
+  async create(data) {
+    const response = await this.http.post(this.config.basePath, {
+      [this.config.singularKey]: data
+    });
+    return response.data[this.config.singularKey];
+  }
+  async update(uid, data) {
+    const response = await this.http.put(
+      `${this.config.basePath}/${uid}`,
+      { [this.config.singularKey]: data }
+    );
+    return response.data[this.config.singularKey];
+  }
+  async delete(uid) {
+    await this.http.delete(`${this.config.basePath}/${uid}`);
+  }
+};
+
+// src/cma/audit-log.ts
+var AuditLogClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/audit-logs", singularKey: "audit_log", pluralKey: "audit_logs" });
+  }
+};
+
+// src/cma/branch-aliases.ts
+var BranchAliasesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const response = await this.http.get(
+      "/stacks/branch_aliases"
+    );
+    return response.data.branch_aliases ?? [];
+  }
+  async get(uid) {
+    const response = await this.http.get(
+      `/stacks/branch_aliases/${uid}`
+    );
+    return response.data.branch_alias;
+  }
+  async createOrUpdate(uid, targetBranch) {
+    const response = await this.http.put(
+      `/stacks/branch_aliases/${uid}`,
+      { branch_alias: { target_branch: targetBranch } }
+    );
+    return response.data.branch_alias;
+  }
+  async delete(uid) {
+    await this.http.delete(`/stacks/branch_aliases/${uid}`);
+  }
+};
+
+// src/cma/branches.ts
+var BranchesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get(
+          "/stacks/branches",
+          { skip: String(skip), limit: String(limit) }
+        );
+        return { items: response.data.branches ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async get(uid) {
+    const response = await this.http.get(`/stacks/branches/${uid}`);
+    return response.data.branch;
+  }
+  async create(data) {
+    const response = await this.http.post("/stacks/branches", {
+      branch: data
+    });
+    return response.data.branch;
+  }
+  async delete(uid) {
+    await this.http.delete(`/stacks/branches/${uid}`);
+  }
+  async compare(baseBranch, compareBranch) {
+    const response = await this.http.get("/stacks/branches_compare", {
+      base_branch: baseBranch,
+      compare_branch: compareBranch
+    });
+    return response.data;
+  }
+  async merge(data) {
+    const response = await this.http.post("/stacks/branches_merge", data);
+    return response.data.merge_job;
+  }
+  async listMergeJobs() {
+    const response = await this.http.get("/stacks/branches_queue");
+    return response.data.merge_jobs ?? [];
+  }
+  async getMergeJob(uid) {
+    const response = await this.http.get(`/stacks/branches_queue/${uid}`);
+    return response.data.merge_job;
+  }
+};
+
+// src/cma/bulk.ts
+var BulkOperationsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async publish(data) {
+    await this.http.post("/bulk/publish", data);
+  }
+  async unpublish(data) {
+    await this.http.post("/bulk/unpublish", data);
+  }
+  async delete(data) {
+    await this.http.post("/bulk/delete", data);
+  }
+  async updateWorkflow(data) {
+    await this.http.post("/bulk/workflow", data);
+  }
+  async addItems(data) {
+    await this.http.post("/bulk/add", data);
+  }
+  async updateItems(data) {
+    await this.http.post("/bulk/update", data);
+  }
+  async jobStatus(jobId) {
+    const response = await this.http.get(`/bulk/jobs/${jobId}`);
+    return response.data.job;
+  }
+  async getJobItems(jobId, opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.skip) params.skip = String(opts.skip);
+    const response = await this.http.get(
+      `/bulk/jobs/${jobId}/items`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return response.data.items ?? [];
+  }
+};
+
+// src/cma/content-types.ts
+var ContentTypesClient = class extends CrudClient {
+  constructor(http) {
+    super(http, {
+      basePath: "/content_types",
+      singularKey: "content_type",
+      pluralKey: "content_types"
+    });
+  }
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        if (opts?.include_count) params.include_count = "true";
+        const response = await this.http.get("/content_types", params);
+        return { items: response.data.content_types ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async export(uid) {
+    const response = await this.http.get(
+      `/content_types/${uid}/export`
+    );
+    return response.data.content_type;
+  }
+  async import(data) {
+    const response = await this.http.post(
+      "/content_types/import",
+      data
+    );
+    return response.data.content_type;
+  }
+};
+
+// src/cma/entries.ts
+var EntriesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  basePath(ctUid) {
+    return `/content_types/${ctUid}/entries`;
+  }
+  list(ctUid, opts) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        if (opts?.locale) params.locale = opts.locale;
+        if (opts?.include_publish_details) params.include_publish_details = "true";
+        if (opts?.include_workflow) params.include_workflow = "true";
+        if (opts?.include_count) params.include_count = "true";
+        if (opts?.query) params.query = JSON.stringify(opts.query);
+        if (opts?.asc) params.asc = opts.asc;
+        if (opts?.desc) params.desc = opts.desc;
+        const response = await this.http.get(
+          this.basePath(ctUid),
+          params
+        );
+        return { items: response.data.entries ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(ctUid, opts) {
+    return collectAll(this.list(ctUid, opts));
+  }
+  async get(ctUid, entryUid, opts) {
+    const params = {};
+    if (opts?.locale) params.locale = opts.locale;
+    if (opts?.include_publish_details) params.include_publish_details = "true";
+    if (opts?.include_workflow) params.include_workflow = "true";
+    if (opts?.version) params.version = String(opts.version);
+    const response = await this.http.get(
+      `${this.basePath(ctUid)}/${entryUid}`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return response.data.entry;
+  }
+  async create(ctUid, data) {
+    const response = await this.http.post(this.basePath(ctUid), { entry: data });
+    return response.data.entry;
+  }
+  async update(ctUid, entryUid, data) {
+    const response = await this.http.put(`${this.basePath(ctUid)}/${entryUid}`, {
+      entry: data
+    });
+    return response.data.entry;
+  }
+  async delete(ctUid, entryUid, opts) {
+    let path = `${this.basePath(ctUid)}/${entryUid}`;
+    if (opts?.locale) path += `?locale=${encodeURIComponent(opts.locale)}`;
+    await this.http.delete(path);
+  }
+  async publish(ctUid, entryUid, data) {
+    await this.http.post(`${this.basePath(ctUid)}/${entryUid}/publish`, { entry: data });
+  }
+  async unpublish(ctUid, entryUid, data) {
+    await this.http.post(`${this.basePath(ctUid)}/${entryUid}/unpublish`, { entry: data });
+  }
+  async localize(ctUid, entryUid, data) {
+    const response = await this.http.post(
+      `${this.basePath(ctUid)}/${entryUid}/localize`,
+      { entry: data }
+    );
+    return response.data.entry;
+  }
+  async setWorkflowStage(ctUid, entryUid, data) {
+    await this.http.post(`${this.basePath(ctUid)}/${entryUid}/workflow`, data);
+  }
+  async references(ctUid, entryUid) {
+    const response = await this.http.get(
+      `${this.basePath(ctUid)}/${entryUid}/references`
+    );
+    return response.data.references ?? [];
+  }
+  async languages(ctUid, entryUid) {
+    const response = await this.http.get(
+      `${this.basePath(ctUid)}/${entryUid}/languages`
+    );
+    return response.data.locales ?? [];
+  }
+  async versions(ctUid, entryUid) {
+    const response = await this.http.get(
+      `${this.basePath(ctUid)}/${entryUid}/versions`
+    );
+    return response.data.versions ?? [];
+  }
+  async import(ctUid, data, opts) {
+    let path = `${this.basePath(ctUid)}/import`;
+    const params = [];
+    if (opts?.locale) params.push(`locale=${encodeURIComponent(opts.locale)}`);
+    if (opts?.overwrite) params.push("overwrite=true");
+    if (params.length > 0) path += `?${params.join("&")}`;
+    const response = await this.http.post(path, data);
+    return response.data.entry;
+  }
+};
+
+// src/cma/environments.ts
+var EnvironmentsClient = class extends CrudClient {
+  constructor(http) {
+    super(http, {
+      basePath: "/environments",
+      singularKey: "environment",
+      pluralKey: "environments"
+    });
+  }
+};
+
+// src/cma/extensions.ts
+var ExtensionsClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/extensions", singularKey: "extension", pluralKey: "extensions" });
+  }
+  async upload(form) {
+    const response = await this.http.upload("/extensions", form);
+    return response.data.extension;
+  }
+};
+
+// src/cma/global-fields.ts
+var GlobalFieldsClient = class extends CrudClient {
+  constructor(http) {
+    super(http, {
+      basePath: "/global_fields",
+      singularKey: "global_field",
+      pluralKey: "global_fields"
+    });
+  }
+  async export(uid) {
+    const response = await this.http.get(
+      `/global_fields/${uid}/export`
+    );
+    return response.data.global_field;
+  }
+  async import(data) {
+    const response = await this.http.post(
+      "/global_fields/import",
+      data
+    );
+    return response.data.global_field;
+  }
+};
+
+// src/cma/labels.ts
+var LabelsClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/labels", singularKey: "label", pluralKey: "labels" });
+  }
+};
+
+// src/cma/locales.ts
+var LocalesClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/locales", singularKey: "locale", pluralKey: "locales" });
+  }
+};
+
+// src/cma/publish-rules.ts
+var PublishRulesClient = class extends CrudClient {
+  constructor(http) {
+    super(http, {
+      basePath: "/workflows/publishing_rules",
+      singularKey: "publishing_rule",
+      pluralKey: "publishing_rules"
+    });
+  }
+};
+
+// src/cma/releases.ts
+var ReleasesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        if (opts?.include_count) params.include_count = "true";
+        const response = await this.http.get(
+          "/releases",
+          params
+        );
+        return { items: response.data.releases ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async get(uid) {
+    const response = await this.http.get(`/releases/${uid}`);
+    return response.data.release;
+  }
+  async create(data) {
+    const response = await this.http.post("/releases", { release: data });
+    return response.data.release;
+  }
+  async update(uid, data) {
+    const response = await this.http.put(`/releases/${uid}`, {
+      release: data
+    });
+    return response.data.release;
+  }
+  async delete(uid) {
+    await this.http.delete(`/releases/${uid}`);
+  }
+  async deploy(uid, data) {
+    await this.http.post(`/releases/${uid}/deploy`, { release: data });
+  }
+  // ─── Items ──────────────────────────────────────────────────────
+  async listItems(uid) {
+    const response = await this.http.get(`/releases/${uid}/items`);
+    return response.data.items ?? [];
+  }
+  async addItem(uid, item) {
+    await this.http.post(`/releases/${uid}/items`, { item });
+  }
+  async removeItem(uid, item) {
+    await this.http.post(`/releases/${uid}/items/delete`, { item });
+  }
+  async clone(uid, data) {
+    const response = await this.http.post(`/releases/${uid}/clone`, {
+      release: data
+    });
+    return response.data.release;
+  }
+};
+
+// src/cma/roles.ts
+var RolesClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/roles", singularKey: "role", pluralKey: "roles" });
+  }
+};
+
+// src/cma/taxonomies.ts
+var TaxonomiesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ─── Taxonomies ───────────────────────────────────────────────────
+  list(opts) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get(
+          "/taxonomies",
+          { skip: String(skip), limit: String(limit) }
+        );
+        return { items: response.data.taxonomies ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAll(opts) {
+    return collectAll(this.list(opts));
+  }
+  async get(uid) {
+    const response = await this.http.get(`/taxonomies/${uid}`);
+    return response.data.taxonomy;
+  }
+  async create(data) {
+    const response = await this.http.post("/taxonomies", {
+      taxonomy: data
+    });
+    return response.data.taxonomy;
+  }
+  async update(uid, data) {
+    const response = await this.http.put(`/taxonomies/${uid}`, {
+      taxonomy: data
+    });
+    return response.data.taxonomy;
+  }
+  async delete(uid) {
+    await this.http.delete(`/taxonomies/${uid}`);
+  }
+  // ─── Terms ────────────────────────────────────────────────────────
+  listTerms(taxonomyUid, opts) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get(
+          `/taxonomies/${taxonomyUid}/terms`,
+          { skip: String(skip), limit: String(limit) }
+        );
+        return { items: response.data.terms ?? [], count: response.data.count };
+      },
+      { limit: opts?.limit }
+    );
+  }
+  async listAllTerms(taxonomyUid, opts) {
+    return collectAll(this.listTerms(taxonomyUid, opts));
+  }
+  async getTerm(taxonomyUid, termUid) {
+    const response = await this.http.get(
+      `/taxonomies/${taxonomyUid}/terms/${termUid}`
+    );
+    return response.data.term;
+  }
+  async createTerm(taxonomyUid, data) {
+    const response = await this.http.post(
+      `/taxonomies/${taxonomyUid}/terms`,
+      { term: data }
+    );
+    return response.data.term;
+  }
+  async updateTerm(taxonomyUid, termUid, data) {
+    const response = await this.http.put(
+      `/taxonomies/${taxonomyUid}/terms/${termUid}`,
+      { term: data }
+    );
+    return response.data.term;
+  }
+  async deleteTerm(taxonomyUid, termUid) {
+    await this.http.delete(`/taxonomies/${taxonomyUid}/terms/${termUid}`);
+  }
+  async ancestors(taxonomyUid, termUid) {
+    const response = await this.http.get(
+      `/taxonomies/${taxonomyUid}/terms/${termUid}/ancestors`
+    );
+    return response.data.terms ?? [];
+  }
+  async descendants(taxonomyUid, termUid) {
+    const response = await this.http.get(
+      `/taxonomies/${taxonomyUid}/terms/${termUid}/descendants`
+    );
+    return response.data.terms ?? [];
+  }
+  async moveTerm(taxonomyUid, termUid, data) {
+    const response = await this.http.put(
+      `/taxonomies/${taxonomyUid}/terms/${termUid}/move`,
+      { term: data }
+    );
+    return response.data.term;
+  }
+  // ─── Import / Export ──────────────────────────────────────────────
+  async export(uid) {
+    const response = await this.http.get(`/taxonomies/${uid}/export`);
+    return response.data.taxonomy;
+  }
+  async import(data) {
+    const response = await this.http.post("/taxonomies/import", data);
+    return response.data.taxonomy;
+  }
+};
+
+// src/cma/tokens.ts
+function tokenCrud(http, basePath) {
+  return {
+    async list() {
+      const response = await http.get(basePath);
+      return response.data.tokens ?? [];
+    },
+    async get(uid) {
+      const response = await http.get(`${basePath}/${uid}`);
+      return response.data.token;
+    },
+    async create(data) {
+      const response = await http.post(basePath, { token: data });
+      return response.data.token;
+    },
+    async update(uid, data) {
+      const response = await http.put(`${basePath}/${uid}`, { token: data });
+      return response.data.token;
+    },
+    async delete(uid) {
+      await http.delete(`${basePath}/${uid}`);
+    }
+  };
+}
+var TokensClient = class {
+  management;
+  delivery;
+  preview;
+  constructor(http) {
+    this.management = tokenCrud(http, "/stacks/management_tokens");
+    this.delivery = tokenCrud(http, "/stacks/delivery_tokens");
+    this.preview = tokenCrud(http, "/stacks/preview_tokens");
+  }
+  // ─── Management Tokens ────────────────────────────────────────────
+  listManagementTokens() {
+    return this.management.list();
+  }
+  getManagementToken(uid) {
+    return this.management.get(uid);
+  }
+  createManagementToken(data) {
+    return this.management.create(data);
+  }
+  updateManagementToken(uid, data) {
+    return this.management.update(uid, data);
+  }
+  deleteManagementToken(uid) {
+    return this.management.delete(uid);
+  }
+  // ─── Delivery Tokens ──────────────────────────────────────────────
+  listDeliveryTokens() {
+    return this.delivery.list();
+  }
+  getDeliveryToken(uid) {
+    return this.delivery.get(uid);
+  }
+  createDeliveryToken(data) {
+    return this.delivery.create(data);
+  }
+  updateDeliveryToken(uid, data) {
+    return this.delivery.update(uid, data);
+  }
+  deleteDeliveryToken(uid) {
+    return this.delivery.delete(uid);
+  }
+  // ─── Preview Tokens ──────────────────────────────────────────────
+  listPreviewTokens() {
+    return this.preview.list();
+  }
+  getPreviewToken(uid) {
+    return this.preview.get(uid);
+  }
+  createPreviewToken(data) {
+    return this.preview.create(data);
+  }
+  updatePreviewToken(uid, data) {
+    return this.preview.update(uid, data);
+  }
+  deletePreviewToken(uid) {
+    return this.preview.delete(uid);
+  }
+};
+
+// src/cma/webhooks.ts
+var WebhooksClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/webhooks", singularKey: "webhook", pluralKey: "webhooks" });
+  }
+  async logs(uid) {
+    const response = await this.http.get(`/webhooks/${uid}/logs`);
+    return response.data.logs ?? [];
+  }
+  async retry(uid, executionUid) {
+    await this.http.post(`/webhooks/${uid}/retry/${executionUid}`, {});
+  }
+};
+
+// src/cma/workflows.ts
+var WorkflowsClient = class extends CrudClient {
+  constructor(http) {
+    super(http, { basePath: "/workflows", singularKey: "workflow", pluralKey: "workflows" });
+  }
+};
+
+// src/cma/client.ts
+function createCMAClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = { api_key: config.apiKey };
+  switch (config.auth.type) {
+    case "management-token":
+      headers.authorization = config.auth.token;
+      break;
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  if (config.branch) {
+    headers.branch = config.branch;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? `${endpoints.cma}/v3`,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    entries: new EntriesClient(http),
+    contentTypes: new ContentTypesClient(http),
+    assets: new AssetsClient(http),
+    environments: new EnvironmentsClient(http),
+    locales: new LocalesClient(http),
+    globalFields: new GlobalFieldsClient(http),
+    webhooks: new WebhooksClient(http),
+    workflows: new WorkflowsClient(http),
+    releases: new ReleasesClient(http),
+    branches: new BranchesClient(http),
+    branchAliases: new BranchAliasesClient(http),
+    taxonomies: new TaxonomiesClient(http),
+    bulk: new BulkOperationsClient(http),
+    tokens: new TokensClient(http),
+    labels: new LabelsClient(http),
+    roles: new RolesClient(http),
+    auditLog: new AuditLogClient(http),
+    extensions: new ExtensionsClient(http),
+    publishRules: new PublishRulesClient(http),
+    onBranch(branchUid) {
+      return createCMAClient({ ...config, branch: branchUid });
+    }
+  };
+}
+
+// src/cma/request-builders.ts
+function nonEmptyParams(params) {
+  return Object.keys(params).length > 0 ? params : void 0;
+}
+function buildEntryParams(options) {
+  if (!options) return void 0;
+  const params = {};
+  if (options.locale) params.locale = options.locale;
+  if (options.version !== void 0) params.version = String(options.version);
+  if (options.includePublishDetails) params.include_publish_details = "true";
+  return nonEmptyParams(params);
+}
+function buildEntriesParams(options) {
+  if (!options) return void 0;
+  const params = {};
+  if (options.locale) params.locale = options.locale;
+  if (options.limit !== void 0) params.limit = String(options.limit);
+  if (options.skip !== void 0) params.skip = String(options.skip);
+  if (options.includePublishDetails) params.include_publish_details = "true";
+  if (options.query) params.query = JSON.stringify(options.query);
+  return nonEmptyParams(params);
+}
+function buildAssetsParams(options) {
+  if (!options) return void 0;
+  const params = {};
+  if (options.folder) params.folder = options.folder;
+  if (options.limit !== void 0) params.limit = String(options.limit);
+  if (options.skip !== void 0) params.skip = String(options.skip);
+  return nonEmptyParams(params);
+}
+function appendQueryString(path, params) {
+  const query = params.toString();
+  return query ? `${path}?${query}` : path;
+}
+function buildCreateEntryRequest(vars) {
+  const params = new URLSearchParams();
+  if (vars.locale) params.set("locale", vars.locale);
+  return {
+    path: appendQueryString(`/content_types/${vars.contentTypeUid}/entries`, params),
+    body: { entry: vars.entry }
+  };
+}
+function buildUpdateEntryRequest(vars) {
+  const params = new URLSearchParams();
+  if (vars.locale) params.set("locale", vars.locale);
+  return {
+    path: appendQueryString(
+      `/content_types/${vars.contentTypeUid}/entries/${vars.entryUid}`,
+      params
+    ),
+    body: { entry: vars.entry }
+  };
+}
+function buildDeleteEntryRequest(vars) {
+  const params = new URLSearchParams();
+  if (vars.locale) params.set("locale", vars.locale);
+  if (vars.deleteAllLocalized) params.set("delete_all_localized", "true");
+  return {
+    path: appendQueryString(
+      `/content_types/${vars.contentTypeUid}/entries/${vars.entryUid}`,
+      params
+    )
+  };
+}
+function buildPublishEntryRequest(vars) {
+  return {
+    path: `/content_types/${vars.contentTypeUid}/entries/${vars.entryUid}/publish`,
+    body: {
+      entry: {
+        environments: vars.environments,
+        locales: vars.locales,
+        ...vars.scheduledAt ? { scheduled_at: vars.scheduledAt } : {}
+      }
+    }
+  };
+}
+
+export {
+  AssetsClient,
+  CrudClient,
+  AuditLogClient,
+  BranchAliasesClient,
+  BranchesClient,
+  BulkOperationsClient,
+  ContentTypesClient,
+  EntriesClient,
+  EnvironmentsClient,
+  ExtensionsClient,
+  GlobalFieldsClient,
+  LabelsClient,
+  LocalesClient,
+  PublishRulesClient,
+  ReleasesClient,
+  RolesClient,
+  TaxonomiesClient,
+  TokensClient,
+  WebhooksClient,
+  WorkflowsClient,
+  createCMAClient,
+  buildEntryParams,
+  buildEntriesParams,
+  buildAssetsParams,
+  buildCreateEntryRequest,
+  buildUpdateEntryRequest,
+  buildDeleteEntryRequest,
+  buildPublishEntryRequest
+};
+//# sourceMappingURL=chunk-EREPKWTW.mjs.map