@timbenniks/contentstack-platform-sdk 0.1.0

package/dist/react/hooks/index.cjs

@@ -0,0 +1,2097 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useAssets: () => useAssets,
+  useBrandKit: () => useBrandKit,
+  useCMA: () => useCMA,
+  useContentTypes: () => useContentTypes,
+  useCreateEntry: () => useCreateEntry,
+  useDeleteEntry: () => useDeleteEntry,
+  useEntries: () => useEntries,
+  useEntry: () => useEntry,
+  useGenerativeAI: () => useGenerativeAI,
+  useKnowledgeVault: () => useKnowledgeVault,
+  useLaunch: () => useLaunch,
+  usePublishEntry: () => usePublishEntry,
+  useUpdateEntry: () => useUpdateEntry
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/http/errors.ts
+var ContentstackError = class extends Error {
+  name = "ContentstackError";
+  status;
+  errorCode;
+  errors;
+  requestPath;
+  constructor(message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.status = options?.status;
+    this.errorCode = options?.errorCode;
+    this.errors = options?.errors;
+    this.requestPath = options?.requestPath;
+  }
+};
+var ContentstackAuthError = class extends ContentstackError {
+  name = "ContentstackAuthError";
+  status = 401;
+};
+var ContentstackForbiddenError = class extends ContentstackError {
+  name = "ContentstackForbiddenError";
+  status = 403;
+};
+var ContentstackNotFoundError = class extends ContentstackError {
+  name = "ContentstackNotFoundError";
+  status = 404;
+};
+var ContentstackValidationError = class extends ContentstackError {
+  name = "ContentstackValidationError";
+  status;
+  constructor(message, options) {
+    super(message, options);
+    this.status = options?.status ?? 400;
+  }
+};
+var ContentstackInvalidApiKeyError = class extends ContentstackError {
+  name = "ContentstackInvalidApiKeyError";
+  status = 412;
+};
+var ContentstackRateLimitError = class extends ContentstackError {
+  name = "ContentstackRateLimitError";
+  status = 429;
+  retryAfter;
+  constructor(message, options) {
+    super(message, { ...options, status: 429 });
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var ContentstackServerError = class extends ContentstackError {
+  name = "ContentstackServerError";
+};
+
+// src/regions/endpoints.ts
+var import_contentstack_endpoints = require("@timbenniks/contentstack-endpoints");
+var BRAND_KIT_URLS = {
+  us: {
+    brandKit: "https://brand-kits-api.contentstack.com",
+    brandKitAI: "https://ai.contentstack.com/brand-kits"
+  },
+  eu: {
+    brandKit: "https://eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://eu-ai.contentstack.com/brand-kits"
+  },
+  au: {
+    brandKit: "https://au-brand-kits-api.contentstack.com",
+    brandKitAI: "https://au-ai.contentstack.com/brand-kits"
+  },
+  "azure-na": {
+    brandKit: "https://azure-na-brand-kits-api.contentstack.com",
+    brandKitAI: "https://azure-na-ai.contentstack.com/brand-kits"
+  },
+  "azure-eu": {
+    brandKit: "https://azure-eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://azure-eu-ai.contentstack.com/brand-kits"
+  },
+  "gcp-na": {
+    brandKit: "https://gcp-na-brand-kits-api.contentstack.com",
+    brandKitAI: "https://gcp-na-ai.contentstack.com/brand-kits"
+  },
+  "gcp-eu": {
+    brandKit: "https://gcp-eu-brand-kits-api.contentstack.com",
+    brandKitAI: "https://gcp-eu-ai.contentstack.com/brand-kits"
+  }
+};
+function mapEndpoints(upstream, region, hostsOnly) {
+  const bk = BRAND_KIT_URLS[region];
+  const stripProtocol = (url) => url.replace(/^https?:\/\//, "");
+  return Object.freeze({
+    cma: upstream.contentManagement ?? "",
+    cda: upstream.contentDelivery ?? "",
+    graphql: upstream.graphqlDelivery ?? "",
+    images: upstream.images ?? "",
+    app: upstream.application ?? "",
+    preview: upstream.preview ?? "",
+    graphqlPreview: upstream.graphqlPreview ?? "",
+    launch: upstream.launch ?? "",
+    personalizeEdge: upstream.personalizeEdge ?? "",
+    brandKit: hostsOnly ? stripProtocol(bk.brandKit) : bk.brandKit,
+    brandKitAI: hostsOnly ? stripProtocol(bk.brandKitAI) : bk.brandKitAI
+  });
+}
+var ALL_REGIONS = [
+  "us",
+  "eu",
+  "au",
+  "azure-na",
+  "azure-eu",
+  "gcp-na",
+  "gcp-eu"
+];
+function buildEndpointMap() {
+  const map = {};
+  for (const region of ALL_REGIONS) {
+    map[region] = mapEndpoints((0, import_contentstack_endpoints.getContentstackEndpoints)(region), region, false);
+  }
+  return Object.freeze(map);
+}
+function buildHostMap() {
+  const map = {};
+  for (const region of ALL_REGIONS) {
+    map[region] = mapEndpoints((0, import_contentstack_endpoints.getContentstackEndpoints)(region, true), region, true);
+  }
+  return Object.freeze(map);
+}
+var ENDPOINT_MAP = buildEndpointMap();
+var HOST_MAP = buildHostMap();
+
+// src/regions/resolver.ts
+var VALID_REGIONS = new Set(Object.keys(ENDPOINT_MAP));
+function resolveEndpoints(region) {
+  return ENDPOINT_MAP[region];
+}
+
+// src/http/parse-error.ts
+async function parseErrorResponse(response, path) {
+  try {
+    const body = await response.json();
+    return new ContentstackError(body.error_message ?? body.message ?? response.statusText, {
+      status: response.status,
+      errorCode: body.error_code,
+      errors: body.errors,
+      requestPath: path
+    });
+  } catch {
+    return new ContentstackError(response.statusText, {
+      status: response.status,
+      requestPath: path
+    });
+  }
+}
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRY_LIMIT = 5;
+var DEFAULT_RETRY_DELAY = 300;
+var MAX_JITTER = 100;
+var ContentstackHttpClient = class _ContentstackHttpClient {
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      headers: config.headers ?? {},
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      retryOnError: config.retryOnError ?? true,
+      retryLimit: config.retryLimit ?? DEFAULT_RETRY_LIMIT,
+      retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY,
+      fetch: config.fetch ?? globalThis.fetch.bind(globalThis)
+    };
+  }
+  async get(path, params) {
+    let url = `${this.config.baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+    return this.request(url, { method: "GET" }, path);
+  }
+  async post(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async put(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async patch(path, body) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      },
+      path
+    );
+  }
+  async delete(path) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(url, { method: "DELETE" }, path);
+  }
+  async postForm(path, params) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(
+      url,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString()
+      },
+      path
+    );
+  }
+  async upload(path, form) {
+    const url = `${this.config.baseUrl}${path}`;
+    return this.request(url, { method: "POST", body: form }, path);
+  }
+  /** Return a new client with additional headers merged */
+  withHeaders(headers) {
+    return new _ContentstackHttpClient({
+      ...this.config,
+      headers: { ...this.config.headers, ...headers }
+    });
+  }
+  /** Return a new client with a different base URL */
+  withBaseUrl(baseUrl) {
+    return new _ContentstackHttpClient({
+      ...this.config,
+      baseUrl
+    });
+  }
+  async request(url, init, path) {
+    const headers = new Headers(this.config.headers);
+    if (init.headers) {
+      const initHeaders = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+      initHeaders.forEach((value, key) => headers.set(key, value));
+    }
+    let lastError;
+    const maxAttempts = this.config.retryOnError ? this.config.retryLimit + 1 : 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await this.config.fetch(url, {
+          ...init,
+          headers,
+          signal: controller.signal
+        });
+        if (response.ok) {
+          const data = await response.json().catch(() => ({}));
+          return { data, status: response.status, headers: response.headers };
+        }
+        const isRetryable = response.status === 429 || response.status >= 500;
+        if (isRetryable && this.config.retryOnError && attempt < maxAttempts - 1) {
+          const delay = this.calculateDelay(response, attempt);
+          await sleep(delay);
+          lastError = await this.createError(response, path);
+          continue;
+        }
+        throw await this.createError(response, path);
+      } catch (error) {
+        if (error instanceof ContentstackError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw new ContentstackError(`Request timed out after ${this.config.timeout}ms`, {
+            requestPath: path,
+            cause: error
+          });
+        }
+        throw new ContentstackError("Network request failed", {
+          requestPath: path,
+          cause: error instanceof Error ? error : new Error(String(error))
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw lastError ?? new ContentstackError("Request failed after retries", { requestPath: path });
+  }
+  calculateDelay(response, attempt) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = Number.parseFloat(retryAfter);
+      if (!Number.isNaN(seconds)) {
+        return seconds * 1e3;
+      }
+    }
+    const jitter = Math.random() * MAX_JITTER;
+    return this.config.retryDelay * 2 ** attempt + jitter;
+  }
+  async createError(response, path) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body.error_message ?? body.error_description ?? body.message ?? `HTTP ${response.status} error`;
+    const errorCode = body.error_code;
+    const errors = body.errors;
+    const retryAfter = response.headers.get("Retry-After");
+    const opts = { status: response.status, errorCode, errors, requestPath: path };
+    switch (response.status) {
+      case 400:
+        return new ContentstackValidationError(message, { ...opts, status: 400 });
+      case 401:
+        return new ContentstackAuthError(message, opts);
+      case 403:
+        return new ContentstackForbiddenError(message, opts);
+      case 404:
+        return new ContentstackNotFoundError(message, opts);
+      case 412:
+        return new ContentstackInvalidApiKeyError(message, opts);
+      case 422:
+        return new ContentstackValidationError(message, { ...opts, status: 422 });
+      case 429:
+        return new ContentstackRateLimitError(message, {
+          ...opts,
+          retryAfter: retryAfter ? Number.parseFloat(retryAfter) : void 0
+        });
+      default:
+        if (response.status >= 500) {
+          return new ContentstackServerError(message, opts);
+        }
+        return new ContentstackError(message, opts);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/cma/pagination.ts
+var DEFAULT_PAGE_SIZE = 25;
+function paginate(fetchPage, options) {
+  const pageSize = options?.limit ?? DEFAULT_PAGE_SIZE;
+  return {
+    [Symbol.asyncIterator]() {
+      let skip = 0;
+      let done = false;
+      let buffer = [];
+      let bufferIndex = 0;
+      let totalCount;
+      return {
+        async next() {
+          if (bufferIndex < buffer.length) {
+            return { value: buffer[bufferIndex++], done: false };
+          }
+          if (done) {
+            return { value: void 0, done: true };
+          }
+          const page = await fetchPage(skip, pageSize);
+          buffer = page.items;
+          bufferIndex = 0;
+          skip += page.items.length;
+          if (typeof page.count === "number") {
+            totalCount = page.count;
+          }
+          if (page.items.length === 0) {
+            done = true;
+            return { value: void 0, done: true };
+          }
+          if (typeof totalCount === "number" && skip >= totalCount) {
+            done = true;
+          }
+          return { value: buffer[bufferIndex++], done: false };
+        }
+      };
+    }
+  };
+}
+async function collectAll(iterable) {
+  const items = [];
+  for await (const item of iterable) {
+    items.push(item);
+  }
+  return items;
+}
+
+// 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 } : {}
+      }
+    }
+  };
+}
+
+// src/launch/response.ts
+function extractList(body, key) {
+  if (Array.isArray(body)) {
+    return { items: body };
+  }
+  if (body && typeof body === "object") {
+    const obj = body;
+    if (key in obj && Array.isArray(obj[key])) {
+      const pagination = obj.pagination;
+      return { items: obj[key], count: pagination?.count };
+    }
+    if ("data" in obj && Array.isArray(obj.data)) {
+      return { items: obj.data, count: obj.count };
+    }
+  }
+  return { items: [] };
+}
+function extractItem(body) {
+  if (body && typeof body === "object" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/launch/deployments.ts
+var DeploymentsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  basePath(projectUid, environmentUid) {
+    return `/projects/${projectUid}/environments/${environmentUid}/deployments`;
+  }
+  list(projectUid, environmentUid, options) {
+    return paginate(
+      async (skip, limit) => {
+        const params = {
+          skip: String(skip),
+          limit: String(limit)
+        };
+        const response = await this.http.get(
+          this.basePath(projectUid, environmentUid),
+          params
+        );
+        return extractList(response.data, "deployments");
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(projectUid, environmentUid, options) {
+    return collectAll(this.list(projectUid, environmentUid, options));
+  }
+  async get(projectUid, environmentUid, deploymentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}`
+    );
+    return extractItem(response.data);
+  }
+  async create(projectUid, environmentUid, data) {
+    const response = await this.http.post(this.basePath(projectUid, environmentUid), data);
+    return extractItem(response.data);
+  }
+  async getDeploymentLogs(projectUid, environmentUid, deploymentUid, options) {
+    const params = {};
+    if (options?.timestamp) params.timestamp = options.timestamp;
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/logs/deployment-logs`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return extractList(response.data, "logs").items;
+  }
+  async getServerLogs(projectUid, environmentUid, deploymentUid, options) {
+    const params = {};
+    if (options?.startTime !== void 0) params.startTime = String(options.startTime);
+    if (options?.endTime !== void 0) params.endTime = String(options.endTime);
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/logs/server-logs`,
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return extractList(response.data, "logs").items;
+  }
+  async getUploadUrl(projectUid, environmentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/upload/signed_url`
+    );
+    return extractItem(response.data);
+  }
+  async getDownloadUrl(projectUid, environmentUid, deploymentUid) {
+    const response = await this.http.get(
+      `${this.basePath(projectUid, environmentUid)}/${deploymentUid}/download/signed_url`
+    );
+    const item = extractItem(response.data);
+    return item.downloadUrl;
+  }
+};
+
+// src/launch/environments.ts
+var EnvironmentsClient2 = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(projectUid) {
+    return paginate(async (skip, limit) => {
+      const response = await this.http.get(`/projects/${projectUid}/environments`, {
+        skip: String(skip),
+        limit: String(limit)
+      });
+      return extractList(response.data, "environments");
+    });
+  }
+  async listAll(projectUid) {
+    return collectAll(this.list(projectUid));
+  }
+  async get(projectUid, envUid) {
+    const response = await this.http.get(`/projects/${projectUid}/environments/${envUid}`);
+    return extractItem(response.data);
+  }
+  async create(projectUid, data) {
+    const response = await this.http.post(`/projects/${projectUid}/environments`, data);
+    return extractItem(response.data);
+  }
+  async update(projectUid, envUid, data) {
+    const response = await this.http.put(
+      `/projects/${projectUid}/environments/${envUid}`,
+      data
+    );
+    return extractItem(response.data);
+  }
+  async delete(projectUid, envUid) {
+    await this.http.delete(`/projects/${projectUid}/environments/${envUid}`);
+  }
+  async revalidateCDNCache(projectUid, envUid, data) {
+    await this.http.post(
+      `/projects/${projectUid}/environments/${envUid}/revalidate-cdn-cache`,
+      data
+    );
+  }
+  async getUploadUrl(projectUid) {
+    const response = await this.http.get(
+      `/projects/${projectUid}/environments/upload/signed_url`
+    );
+    return extractItem(response.data);
+  }
+};
+
+// src/launch/projects.ts
+var ProjectsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(options) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get("/projects", {
+          skip: String(skip),
+          limit: String(limit)
+        });
+        return extractList(response.data, "projects");
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(options) {
+    return collectAll(this.list(options));
+  }
+  async get(projectUid) {
+    const response = await this.http.get(`/projects/${projectUid}`);
+    return extractItem(response.data);
+  }
+  async create(data) {
+    const response = await this.http.post("/projects", data);
+    return extractItem(response.data);
+  }
+  async update(projectUid, data) {
+    const response = await this.http.put(`/projects/${projectUid}`, data);
+    return extractItem(response.data);
+  }
+  async delete(projectUid) {
+    await this.http.delete(`/projects/${projectUid}`);
+  }
+  async transferGitRepository(projectUid, data) {
+    await this.http.patch(`/projects/${projectUid}/git-repository`, data);
+  }
+  async getUploadUrl() {
+    const response = await this.http.get("/projects/upload/signed_url");
+    return extractItem(response.data);
+  }
+};
+
+// src/launch/client.ts
+function createLaunchClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = {
+    organization_uid: config.organizationUid
+  };
+  switch (config.auth.type) {
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? endpoints.launch,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    projects: new ProjectsClient(http),
+    environments: new EnvironmentsClient2(http),
+    deployments: new DeploymentsClient(http)
+  };
+}
+
+// src/brandkit/brand-kits.ts
+var BrandKitsSubClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(options) {
+    return paginate(
+      async (skip, limit) => {
+        const response = await this.http.get(
+          "/v1/brand-kits",
+          {
+            skip: String(skip),
+            limit: String(limit)
+          }
+        );
+        return { items: response.data.data ?? [], count: response.data.count };
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(options) {
+    return collectAll(this.list(options));
+  }
+  async get(brandKitUid) {
+    const response = await this.http.get(`/v1/brand-kits/${brandKitUid}`);
+    return response.data.data;
+  }
+  async create(data) {
+    const response = await this.http.post("/v1/brand-kits", data);
+    return response.data.data;
+  }
+  async update(brandKitUid, data) {
+    const response = await this.http.put(`/v1/brand-kits/${brandKitUid}`, data);
+    return response.data.data;
+  }
+  async delete(brandKitUid) {
+    await this.http.delete(`/v1/brand-kits/${brandKitUid}`);
+  }
+};
+
+// src/brandkit/voice-profiles.ts
+var VoiceProfilesSubClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list(brandKitUid, options) {
+    const scoped = this.http.withHeaders({ brand_kit_uid: brandKitUid });
+    return paginate(
+      async (skip, limit) => {
+        const response = await scoped.get(
+          `/v1/brand-kits/${brandKitUid}/voice-profiles`,
+          { skip: String(skip), limit: String(limit) }
+        );
+        return { items: response.data.data ?? [], count: response.data.count };
+      },
+      { limit: options?.limit }
+    );
+  }
+  async listAll(brandKitUid, options) {
+    return collectAll(this.list(brandKitUid, options));
+  }
+  async get(brandKitUid, voiceProfileUid) {
+    const scoped = this.http.withHeaders({ brand_kit_uid: brandKitUid });
+    const response = await scoped.get(
+      `/v1/brand-kits/${brandKitUid}/voice-profiles/${voiceProfileUid}`
+    );
+    return response.data.data;
+  }
+  async create(brandKitUid, data) {
+    const scoped = this.http.withHeaders({ brand_kit_uid: brandKitUid });
+    const response = await scoped.post(
+      `/v1/brand-kits/${brandKitUid}/voice-profiles`,
+      data
+    );
+    return response.data.data;
+  }
+  async update(brandKitUid, voiceProfileUid, data) {
+    const scoped = this.http.withHeaders({ brand_kit_uid: brandKitUid });
+    const response = await scoped.put(
+      `/v1/brand-kits/${brandKitUid}/voice-profiles/${voiceProfileUid}`,
+      data
+    );
+    return response.data.data;
+  }
+  async delete(brandKitUid, voiceProfileUid) {
+    const scoped = this.http.withHeaders({ brand_kit_uid: brandKitUid });
+    await scoped.delete(`/v1/brand-kits/${brandKitUid}/voice-profiles/${voiceProfileUid}`);
+  }
+};
+
+// src/brandkit/client.ts
+function createBrandKitClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = {
+    organization_uid: config.organizationUid
+  };
+  switch (config.auth.type) {
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? endpoints.brandKit,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    brandKits: new BrandKitsSubClient(http),
+    voiceProfiles: new VoiceProfilesSubClient(http)
+  };
+}
+
+// src/knowledge-vault/items.ts
+var KnowledgeVaultItemsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async ingest(data) {
+    const response = await this.http.post("/v1/knowledge-vault", data);
+    return response.data.data;
+  }
+  async update(itemUid, data) {
+    const response = await this.http.put(
+      `/v1/knowledge-vault/${itemUid}`,
+      data
+    );
+    return response.data.data;
+  }
+  async delete(itemUid) {
+    await this.http.delete(`/v1/knowledge-vault/${itemUid}`);
+  }
+  async getUsage() {
+    const response = await this.http.get("/v1/knowledge-vault/usage");
+    return response.data.data;
+  }
+};
+
+// src/knowledge-vault/client.ts
+function createKnowledgeVaultClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = {
+    organization_uid: config.organizationUid,
+    brand_kit_uid: config.brandKitUid
+  };
+  switch (config.auth.type) {
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? endpoints.brandKitAI,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    items: new KnowledgeVaultItemsClient(http)
+  };
+}
+
+// src/generative-ai/client.ts
+function createGenerativeAIClient(config) {
+  const endpoints = resolveEndpoints(config.region);
+  const headers = {
+    organization_uid: config.organizationUid,
+    brand_kit_uid: config.brandKitUid
+  };
+  switch (config.auth.type) {
+    case "oauth":
+      headers.authorization = `Bearer ${config.auth.accessToken}`;
+      break;
+    case "authtoken":
+      headers.authtoken = config.auth.token;
+      break;
+  }
+  const http = new ContentstackHttpClient({
+    ...config.httpOptions,
+    baseUrl: config.httpOptions?.baseUrl ?? endpoints.brandKitAI,
+    headers: {
+      ...config.httpOptions?.headers,
+      ...headers
+    }
+  });
+  return {
+    async generate(data) {
+      const body = { prompt: data.prompt };
+      if (data.voiceProfileUid) {
+        body.voice_profile_uid = data.voiceProfileUid;
+      }
+      if (data.useKnowledgeVault !== void 0) {
+        body.knowledge_vault = data.useKnowledgeVault;
+      }
+      const response = await http.post(
+        "/v1/generative-ai/generate",
+        body
+      );
+      return response.data.data;
+    }
+  };
+}
+
+// src/react/hooks/shared/useQuery.ts
+var import_react2 = require("react");
+
+// src/react/provider/context.ts
+var import_react = require("react");
+var ContentstackContext = (0, import_react.createContext)(null);
+function useContentstackContext() {
+  const ctx = (0, import_react.useContext)(ContentstackContext);
+  if (!ctx) {
+    throw new Error(
+      'useContentstackContext must be used within a <ContentstackProvider>. Wrap your app with <ContentstackProvider region="..." proxyBasePath="/api/cma">.'
+    );
+  }
+  return ctx;
+}
+
+// src/react/hooks/shared/useQuery.ts
+function useQuery(path, params, options) {
+  const { proxyBasePath } = useContentstackContext();
+  const [data, setData] = (0, import_react2.useState)(void 0);
+  const [loading, setLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const abortRef = (0, import_react2.useRef)(null);
+  const enabled = options?.enabled ?? true;
+  const refetchInterval = options?.refetchInterval ?? 0;
+  const search = params ? `?${new URLSearchParams(params).toString()}` : "";
+  const url = `${proxyBasePath}${path}${search}`;
+  const fetchData = (0, import_react2.useCallback)(
+    async (signal) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(url, { signal });
+        if (signal?.aborted) return;
+        if (!response.ok) {
+          const err = await parseErrorResponse(response, path);
+          setError(err);
+          setData(void 0);
+          return;
+        }
+        const json = await response.json();
+        setData(json);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        setError(
+          new ContentstackError(err instanceof Error ? err.message : "Network error", {
+            requestPath: path,
+            cause: err instanceof Error ? err : void 0
+          })
+        );
+        setData(void 0);
+      } finally {
+        if (!signal?.aborted) {
+          setLoading(false);
+        }
+      }
+    },
+    [url, path]
+  );
+  (0, import_react2.useEffect)(() => {
+    if (!enabled) return;
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    fetchData(controller.signal);
+    return () => {
+      controller.abort();
+    };
+  }, [enabled, fetchData]);
+  (0, import_react2.useEffect)(() => {
+    if (!enabled || refetchInterval <= 0) return;
+    const id = setInterval(() => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      fetchData(controller.signal);
+    }, refetchInterval);
+    return () => {
+      clearInterval(id);
+    };
+  }, [enabled, refetchInterval, fetchData]);
+  const refetch = (0, import_react2.useCallback)(async () => {
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    await fetchData(controller.signal);
+  }, [fetchData]);
+  return { data, loading, error, refetch };
+}
+
+// src/react/hooks/useEntries.ts
+function useEntries(contentTypeUid, options) {
+  const result = useQuery(
+    `/content_types/${contentTypeUid}/entries`,
+    buildEntriesParams(options),
+    options
+  );
+  return {
+    ...result,
+    data: result.data?.entries,
+    count: result.data?.count
+  };
+}
+
+// src/react/hooks/useEntry.ts
+function useEntry(contentTypeUid, entryUid, options) {
+  const result = useQuery(
+    `/content_types/${contentTypeUid}/entries/${entryUid}`,
+    buildEntryParams(options),
+    options
+  );
+  return {
+    ...result,
+    data: result.data?.entry
+  };
+}
+
+// src/react/hooks/useAssets.ts
+function useAssets(options) {
+  const result = useQuery("/assets", buildAssetsParams(options), options);
+  return {
+    ...result,
+    data: result.data?.assets
+  };
+}
+
+// src/react/hooks/useContentTypes.ts
+function useContentTypes(options) {
+  const result = useQuery("/content_types", void 0, options);
+  return {
+    ...result,
+    data: result.data?.content_types
+  };
+}
+
+// src/react/hooks/useCMA.ts
+var import_react3 = require("react");
+function useCMA() {
+  const { proxyBasePath, region, apiKey } = useContentstackContext();
+  return (0, import_react3.useMemo)(
+    () => createCMAClient({
+      region,
+      apiKey: apiKey ?? "proxy",
+      auth: { type: "oauth", accessToken: "proxy" },
+      httpOptions: { baseUrl: proxyBasePath }
+    }),
+    [proxyBasePath, region, apiKey]
+  );
+}
+
+// src/react/hooks/useLaunch.ts
+var import_react4 = require("react");
+function useLaunch() {
+  const { launchProxyBasePath = "/api/launch", region, organizationUid } = useContentstackContext();
+  return (0, import_react4.useMemo)(
+    () => createLaunchClient({
+      region,
+      organizationUid: organizationUid ?? "proxy",
+      auth: { type: "oauth", accessToken: "proxy" },
+      httpOptions: { baseUrl: launchProxyBasePath }
+    }),
+    [launchProxyBasePath, region, organizationUid]
+  );
+}
+
+// src/react/hooks/useBrandKit.ts
+var import_react5 = require("react");
+function useBrandKit() {
+  const {
+    brandKitProxyBasePath = "/api/brandkit",
+    region,
+    organizationUid
+  } = useContentstackContext();
+  return (0, import_react5.useMemo)(
+    () => createBrandKitClient({
+      region,
+      organizationUid: organizationUid ?? "proxy",
+      auth: { type: "oauth", accessToken: "proxy" },
+      httpOptions: { baseUrl: brandKitProxyBasePath }
+    }),
+    [brandKitProxyBasePath, region, organizationUid]
+  );
+}
+
+// src/react/hooks/useKnowledgeVault.ts
+var import_react6 = require("react");
+function useKnowledgeVault() {
+  const {
+    brandKitProxyBasePath = "/api/brandkit",
+    region,
+    organizationUid,
+    brandKitUid
+  } = useContentstackContext();
+  return (0, import_react6.useMemo)(
+    () => createKnowledgeVaultClient({
+      region,
+      organizationUid: organizationUid ?? "proxy",
+      brandKitUid: brandKitUid ?? "proxy",
+      auth: { type: "oauth", accessToken: "proxy" },
+      httpOptions: { baseUrl: brandKitProxyBasePath }
+    }),
+    [brandKitProxyBasePath, region, organizationUid, brandKitUid]
+  );
+}
+
+// src/react/hooks/useGenerativeAI.ts
+var import_react7 = require("react");
+function useGenerativeAI() {
+  const {
+    brandKitProxyBasePath = "/api/brandkit",
+    region,
+    organizationUid,
+    brandKitUid
+  } = useContentstackContext();
+  return (0, import_react7.useMemo)(
+    () => createGenerativeAIClient({
+      region,
+      organizationUid: organizationUid ?? "proxy",
+      brandKitUid: brandKitUid ?? "proxy",
+      auth: { type: "oauth", accessToken: "proxy" },
+      httpOptions: { baseUrl: brandKitProxyBasePath }
+    }),
+    [brandKitProxyBasePath, region, organizationUid, brandKitUid]
+  );
+}
+
+// src/react/hooks/shared/useMutation.ts
+var import_react8 = require("react");
+function useMutation(method, buildRequest) {
+  const { proxyBasePath } = useContentstackContext();
+  const [data, setData] = (0, import_react8.useState)(void 0);
+  const [loading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const buildRequestRef = (0, import_react8.useRef)(buildRequest);
+  buildRequestRef.current = buildRequest;
+  const mutate = (0, import_react8.useCallback)(
+    async (variables) => {
+      const { path, body } = buildRequestRef.current(variables);
+      const url = `${proxyBasePath}${path}`;
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: body !== void 0 ? { "Content-Type": "application/json" } : void 0,
+          body: body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        if (!response.ok) {
+          const err = await parseErrorResponse(response, path);
+          setError(err);
+          setData(void 0);
+          throw err;
+        }
+        let json;
+        try {
+          json = await response.json();
+        } catch {
+          json = void 0;
+        }
+        setData(json);
+        return json;
+      } catch (err) {
+        if (err instanceof ContentstackError) throw err;
+        const csError = new ContentstackError(
+          err instanceof Error ? err.message : "Network error",
+          {
+            requestPath: path,
+            cause: err instanceof Error ? err : void 0
+          }
+        );
+        setError(csError);
+        setData(void 0);
+        throw csError;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [proxyBasePath, method]
+  );
+  const reset = (0, import_react8.useCallback)(() => {
+    setData(void 0);
+    setError(null);
+  }, []);
+  return { mutate, loading, error, data, reset };
+}
+
+// src/react/hooks/usePublishEntry.ts
+function usePublishEntry() {
+  return useMutation("POST", buildPublishEntryRequest);
+}
+
+// src/react/hooks/useCreateEntry.ts
+var import_react9 = require("react");
+function useCreateEntry() {
+  const result = useMutation(
+    "POST",
+    buildCreateEntryRequest
+  );
+  const mutate = (0, import_react9.useCallback)(
+    async (variables) => {
+      const raw = await result.mutate(variables);
+      return raw.entry;
+    },
+    [result.mutate]
+  );
+  return {
+    ...result,
+    data: result.data?.entry,
+    mutate
+  };
+}
+
+// src/react/hooks/useUpdateEntry.ts
+var import_react10 = require("react");
+function useUpdateEntry() {
+  const result = useMutation("PUT", buildUpdateEntryRequest);
+  const mutate = (0, import_react10.useCallback)(
+    async (variables) => {
+      const raw = await result.mutate(variables);
+      return raw.entry;
+    },
+    [result.mutate]
+  );
+  return {
+    ...result,
+    data: result.data?.entry,
+    mutate
+  };
+}
+
+// src/react/hooks/useDeleteEntry.ts
+function useDeleteEntry() {
+  return useMutation("DELETE", buildDeleteEntryRequest);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAssets,
+  useBrandKit,
+  useCMA,
+  useContentTypes,
+  useCreateEntry,
+  useDeleteEntry,
+  useEntries,
+  useEntry,
+  useGenerativeAI,
+  useKnowledgeVault,
+  useLaunch,
+  usePublishEntry,
+  useUpdateEntry
+});
+//# sourceMappingURL=index.cjs.map