@timbenniks/contentstack-platform-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2909 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AssetsClient: () => AssetsClient,
+  AuditLogClient: () => AuditLogClient,
+  BranchAliasesClient: () => BranchAliasesClient,
+  BranchesClient: () => BranchesClient,
+  BulkOperationsClient: () => BulkOperationsClient,
+  ContentTypesClient: () => ContentTypesClient,
+  ContentstackAuthError: () => ContentstackAuthError,
+  ContentstackConfigError: () => ContentstackConfigError,
+  ContentstackError: () => ContentstackError,
+  ContentstackForbiddenError: () => ContentstackForbiddenError,
+  ContentstackInvalidApiKeyError: () => ContentstackInvalidApiKeyError,
+  ContentstackNotFoundError: () => ContentstackNotFoundError,
+  ContentstackRateLimitError: () => ContentstackRateLimitError,
+  ContentstackServerError: () => ContentstackServerError,
+  ContentstackValidationError: () => ContentstackValidationError,
+  CrudClient: () => CrudClient,
+  EntriesClient: () => EntriesClient,
+  EnvironmentsClient: () => EnvironmentsClient,
+  ExtensionsClient: () => ExtensionsClient,
+  GlobalFieldsClient: () => GlobalFieldsClient,
+  LabelsClient: () => LabelsClient,
+  LocalesClient: () => LocalesClient,
+  PublishRulesClient: () => PublishRulesClient,
+  ReleasesClient: () => ReleasesClient,
+  RolesClient: () => RolesClient,
+  TaxonomiesClient: () => TaxonomiesClient,
+  TokensClient: () => TokensClient,
+  WebhooksClient: () => WebhooksClient,
+  WorkflowsClient: () => WorkflowsClient,
+  buildAssetsParams: () => buildAssetsParams,
+  buildAuthorizationUrl: () => buildAuthorizationUrl,
+  buildCreateEntryRequest: () => buildCreateEntryRequest,
+  buildDeleteEntryRequest: () => buildDeleteEntryRequest,
+  buildEntriesParams: () => buildEntriesParams,
+  buildEntryParams: () => buildEntryParams,
+  buildPublishEntryRequest: () => buildPublishEntryRequest,
+  buildUpdateEntryRequest: () => buildUpdateEntryRequest,
+  collectAll: () => collectAll,
+  contentstackAuthCallbacks: () => contentstackAuthCallbacks,
+  createAuthProvider: () => createAuthProvider,
+  createBrandKitClient: () => createBrandKitClient,
+  createCMAClient: () => createCMAClient,
+  createGenerativeAIClient: () => createGenerativeAIClient,
+  createKnowledgeVaultClient: () => createKnowledgeVaultClient,
+  createLaunchClient: () => createLaunchClient,
+  exchangeCode: () => exchangeCode,
+  fromHTML: () => fromHTML,
+  generateCodeChallenge: () => generateCodeChallenge,
+  generateCodeVerifier: () => generateCodeVerifier,
+  getUser: () => getUser,
+  imageTransform: () => imageTransform,
+  normalizeRegion: () => normalizeRegion,
+  paginate: () => paginate,
+  parseErrorResponse: () => parseErrorResponse,
+  refreshToken: () => refreshToken,
+  resolveEndpoints: () => resolveEndpoints,
+  resolveHosts: () => resolveHosts,
+  toHTML: () => toHTML,
+  toMarkdown: () => toMarkdown,
+  toPlainText: () => toPlainText,
+  transform: () => transform,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_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";
+};
+var ContentstackConfigError = class extends ContentstackError {
+  name = "ContentstackConfigError";
+};
+
+// 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();
+function isValidRegion(input) {
+  return (0, import_contentstack_endpoints.getRegionForString)(input) !== void 0;
+}
+var EXTRA_ALIASES = {
+  "north-america": "us",
+  europe: "eu",
+  australia: "au"
+};
+
+// src/regions/resolver.ts
+var VALID_REGIONS = new Set(Object.keys(ENDPOINT_MAP));
+function resolveEndpoints(region) {
+  return ENDPOINT_MAP[region];
+}
+function resolveHosts(region) {
+  return HOST_MAP[region];
+}
+function normalizeRegion(input) {
+  const lower = input.toLowerCase().trim();
+  if (VALID_REGIONS.has(lower)) {
+    return lower;
+  }
+  const extraAlias = EXTRA_ALIASES[lower];
+  if (extraAlias) {
+    return extraAlias;
+  }
+  if (isValidRegion(lower)) {
+    if (lower === "na" || lower === "aws-na" || lower === "aws_na") return "us";
+    if (lower === "aws-eu" || lower === "aws_eu") return "eu";
+    if (lower === "aws-au" || lower === "aws_au") return "au";
+    if (lower === "azure_na") return "azure-na";
+    if (lower === "azure_eu") return "azure-eu";
+    if (lower === "gcp_na") return "gcp-na";
+    if (lower === "gcp_eu") return "gcp-eu";
+  }
+  const validRegions = [...VALID_REGIONS].join(", ");
+  const validAliases = [...Object.keys(EXTRA_ALIASES), "na", "aws-na", "aws-eu", "aws-au"].join(
+    ", "
+  );
+  throw new ContentstackConfigError(
+    `Unknown region "${input}". Valid regions: ${validRegions}. Aliases: ${validAliases}.`
+  );
+}
+
+// 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/auth/pkce.ts
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+function generateCodeVerifier() {
+  const bytes = new Uint8Array(43);
+  globalThis.crypto.getRandomValues(bytes);
+  let result = "";
+  for (const byte of bytes) {
+    result += CHARSET[byte % CHARSET.length];
+  }
+  return result;
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  const bytes = new Uint8Array(digest);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/auth/oauth-client.ts
+function validateConfig(config) {
+  if (!config.appId) {
+    throw new ContentstackConfigError(
+      "appId is required for OAuth. This is your Contentstack app's UID, not the client ID."
+    );
+  }
+  if (config.appId === config.clientId) {
+    throw new ContentstackConfigError(
+      "appId and clientId must be different. appId is your Contentstack app UID; clientId is the OAuth client identifier."
+    );
+  }
+}
+async function buildAuthorizationUrl(config, options) {
+  validateConfig(config);
+  const endpoints = resolveEndpoints(config.region);
+  const authorizationUrl = `${endpoints.app}/apps/${config.appId}/authorize`;
+  const state = options?.state ?? generateCodeVerifier();
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: config.clientId,
+    redirect_uri: config.redirectUri,
+    scope: config.scopes.join(" "),
+    state
+  });
+  let codeVerifier;
+  if (options?.usePKCE) {
+    codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    params.set("code_challenge", codeChallenge);
+    params.set("code_challenge_method", "S256");
+  }
+  return {
+    url: `${authorizationUrl}?${params.toString()}`,
+    state,
+    codeVerifier
+  };
+}
+function mapTokenResponse(data) {
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresIn: data.expires_in,
+    tokenType: data.token_type
+  };
+}
+async function makeTokenRequest(appBaseUrl, body, errorMessage) {
+  const client = new ContentstackHttpClient({ baseUrl: appBaseUrl });
+  try {
+    const { data } = await client.postForm("/apps-api/token", body);
+    return mapTokenResponse(data);
+  } catch (err) {
+    if (err instanceof ContentstackError) {
+      throw new ContentstackAuthError(err.message || errorMessage, {
+        status: err.status,
+        requestPath: "/apps-api/token",
+        cause: err
+      });
+    }
+    throw new ContentstackAuthError(errorMessage, {
+      requestPath: "/apps-api/token",
+      cause: err instanceof Error ? err : void 0
+    });
+  }
+}
+async function exchangeCode(config, code, options) {
+  const endpoints = resolveEndpoints(config.region);
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: config.redirectUri,
+    client_id: config.clientId,
+    client_secret: config.clientSecret
+  });
+  if (options?.codeVerifier) {
+    body.set("code_verifier", options.codeVerifier);
+  }
+  return makeTokenRequest(endpoints.app, body, "Failed to exchange authorization code");
+}
+async function refreshToken(config, token) {
+  const endpoints = resolveEndpoints(config.region);
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: token,
+    client_id: config.clientId,
+    client_secret: config.clientSecret
+  });
+  return makeTokenRequest(endpoints.app, body, "Failed to refresh token");
+}
+function mapUser(user) {
+  return {
+    uid: user.uid,
+    email: user.email,
+    firstName: user.first_name ?? void 0,
+    lastName: user.last_name ?? void 0,
+    username: user.username ?? void 0,
+    profileImage: user.profile_image ?? void 0
+  };
+}
+async function getUser(region, accessToken) {
+  const endpoints = resolveEndpoints(region);
+  const client = new ContentstackHttpClient({
+    baseUrl: `${endpoints.cma}/v3`,
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  try {
+    const { data } = await client.get("/user");
+    return mapUser(data.user);
+  } catch (err) {
+    if (err instanceof ContentstackError) {
+      throw new ContentstackAuthError(err.message || "Failed to fetch user profile", {
+        status: err.status,
+        requestPath: "/v3/user",
+        cause: err
+      });
+    }
+    throw new ContentstackAuthError("Failed to fetch user profile", {
+      requestPath: "/v3/user",
+      cause: err instanceof Error ? err : void 0
+    });
+  }
+}
+function createAuthProvider(config) {
+  validateConfig(config);
+  const endpoints = resolveEndpoints(config.region);
+  const userClient = new ContentstackHttpClient({ baseUrl: `${endpoints.cma}/v3` });
+  return {
+    id: "contentstack",
+    name: "Contentstack",
+    type: "oauth",
+    checks: ["state"],
+    authorization: {
+      url: `${endpoints.app}/apps/${config.appId}/authorize`,
+      params: {
+        response_type: "code",
+        scope: config.scopes.join(" ")
+      }
+    },
+    token: `${endpoints.app}/apps-api/token`,
+    userinfo: {
+      url: `${endpoints.cma}/v3/user`,
+      async request({ tokens }) {
+        const authedClient = userClient.withHeaders({
+          Authorization: `Bearer ${tokens.access_token}`
+        });
+        const { data } = await authedClient.get("/user");
+        return data;
+      }
+    },
+    profile(profile) {
+      const user = profile.user;
+      return {
+        id: user.uid,
+        name: [user.first_name, user.last_name].filter(Boolean).join(" ") || user.username,
+        email: user.email,
+        image: user.profile_image ?? null
+      };
+    },
+    clientId: config.clientId,
+    clientSecret: config.clientSecret
+  };
+}
+function contentstackAuthCallbacks(config) {
+  return {
+    async jwt({
+      token,
+      account
+    }) {
+      if (account) {
+        token.accessToken = account.access_token;
+        token.refreshToken = account.refresh_token;
+        token.accessTokenExpiresAt = Date.now() + (account.expires_in ?? 3600) * 1e3;
+        return token;
+      }
+      const expiresAt = token.accessTokenExpiresAt;
+      if (expiresAt && Date.now() < expiresAt - 6e4) {
+        return token;
+      }
+      const currentRefreshToken = token.refreshToken;
+      if (!currentRefreshToken) {
+        token.error = "RefreshAccessTokenError";
+        return token;
+      }
+      try {
+        const tokens = await refreshToken(config, currentRefreshToken);
+        token.accessToken = tokens.accessToken;
+        token.refreshToken = tokens.refreshToken;
+        token.accessTokenExpiresAt = Date.now() + tokens.expiresIn * 1e3;
+        token.error = void 0;
+      } catch {
+        token.error = "RefreshAccessTokenError";
+      }
+      return token;
+    },
+    async session({
+      session,
+      token
+    }) {
+      session.accessToken = token.accessToken;
+      if (token.error) {
+        session.error = token.error;
+      }
+      return session;
+    }
+  };
+}
+
+// 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/images/builder.ts
+var VALID_FORMATS = /* @__PURE__ */ new Set(["webp", "jpg", "png", "gif", "avif", "pjpg"]);
+var VALID_FITS = /* @__PURE__ */ new Set(["bounds", "crop", "cover"]);
+var VALID_FILTERS = /* @__PURE__ */ new Set([
+  "nearest",
+  "bilinear",
+  "bicubic",
+  "lanczos2",
+  "lanczos3"
+]);
+var ImageTransformBuilderImpl = class _ImageTransformBuilderImpl {
+  constructor(assetUrl, params = {}) {
+    this.assetUrl = assetUrl;
+    this.params = params;
+  }
+  width(px) {
+    assertPositiveInteger("width", px);
+    return this.with("width", String(px));
+  }
+  height(px) {
+    assertPositiveInteger("height", px);
+    return this.with("height", String(px));
+  }
+  quality(q) {
+    if (!Number.isInteger(q) || q < 1 || q > 100) {
+      throw new ContentstackConfigError("quality() expects an integer between 1 and 100");
+    }
+    return this.with("quality", String(q));
+  }
+  format(fmt) {
+    if (!VALID_FORMATS.has(fmt)) {
+      throw new ContentstackConfigError(`Unsupported image format: ${fmt}`);
+    }
+    return this.with("format", fmt);
+  }
+  fit(mode) {
+    if (!VALID_FITS.has(mode)) {
+      throw new ContentstackConfigError(`Unsupported fit mode: ${mode}`);
+    }
+    return this.with("fit", mode);
+  }
+  crop(params) {
+    return this.withNonEmptyString("crop", params);
+  }
+  trim(edges) {
+    return this.withNonEmptyString("trim", edges);
+  }
+  orient(angle) {
+    if (!Number.isInteger(angle) || angle < 1 || angle > 8) {
+      throw new ContentstackConfigError("orient() expects a value between 1 and 8");
+    }
+    return this.with("orient", String(angle));
+  }
+  overlay(params) {
+    const entries = Object.entries(params).filter(([, value2]) => value2.trim().length > 0).sort(([a], [b]) => a.localeCompare(b));
+    if (entries.length === 0) {
+      throw new ContentstackConfigError("overlay() requires at least one non-empty key/value pair");
+    }
+    const value = entries.map(([key, val]) => `${key}:${val}`).join(",");
+    return this.with("overlay", value);
+  }
+  pad(pixels) {
+    return this.withNonEmptyString("pad", pixels);
+  }
+  bgColor(hex) {
+    const normalized = hex.trim().replace(/^#/, "");
+    if (!/^[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/.test(normalized)) {
+      throw new ContentstackConfigError("bgColor() expects a 3 or 6 character hex value");
+    }
+    return this.with("bg-color", normalized.toLowerCase());
+  }
+  dpr(ratio) {
+    if (!Number.isFinite(ratio) || ratio <= 0) {
+      throw new ContentstackConfigError("dpr() expects a positive number");
+    }
+    return this.with("dpr", String(ratio));
+  }
+  disableUpscale() {
+    return this.with("disable", "upscale");
+  }
+  resizeFilter(filter) {
+    if (!VALID_FILTERS.has(filter)) {
+      throw new ContentstackConfigError(`Unsupported resize filter: ${filter}`);
+    }
+    return this.with("resize-filter", filter);
+  }
+  toURL() {
+    if (Object.keys(this.params).length === 0) {
+      return this.assetUrl;
+    }
+    const query = new URLSearchParams(this.params);
+    try {
+      const url = new URL(this.assetUrl);
+      for (const [key, value] of query.entries()) {
+        url.searchParams.set(key, value);
+      }
+      return url.toString();
+    } catch {
+      const separator = this.assetUrl.includes("?") ? "&" : "?";
+      return `${this.assetUrl}${separator}${query.toString()}`;
+    }
+  }
+  toSrcSet(widths) {
+    return widths.map((width) => {
+      assertPositiveInteger("toSrcSet width", width);
+      return `${this.width(width).toURL()} ${width}w`;
+    }).join(", ");
+  }
+  toParams() {
+    return { ...this.params };
+  }
+  with(key, value) {
+    return new _ImageTransformBuilderImpl(this.assetUrl, {
+      ...this.params,
+      [key]: value
+    });
+  }
+  withNonEmptyString(key, value) {
+    if (!value.trim()) {
+      throw new ContentstackConfigError(`${key}() requires a non-empty string value`);
+    }
+    return this.with(key, value);
+  }
+};
+function imageTransform(assetUrl) {
+  if (!assetUrl.trim()) {
+    throw new ContentstackConfigError("imageTransform() requires a non-empty asset URL");
+  }
+  return new ImageTransformBuilderImpl(assetUrl);
+}
+function assertPositiveInteger(name, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new ContentstackConfigError(`${name} expects a positive integer`);
+  }
+}
+
+// src/rte/to-html.ts
+var import_json_rte_serializer = require("@contentstack/json-rte-serializer");
+
+// src/rte/utils.ts
+var KNOWN_RTE_TYPES = /* @__PURE__ */ new Set([
+  "doc",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "code",
+  "img",
+  "a",
+  "table",
+  "tr",
+  "td",
+  "th",
+  "hr",
+  "reference"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTextNode(value) {
+  return isRecord(value) && typeof value.text === "string" && typeof value.type !== "string";
+}
+function isElementNode(value) {
+  return isRecord(value) && typeof value.type === "string" && typeof value.uid === "string";
+}
+function decodeHTML(value) {
+  return value.replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function createUid() {
+  const uuid = globalThis.crypto?.randomUUID;
+  if (typeof uuid === "function") {
+    return uuid.call(globalThis.crypto);
+  }
+  return `rte-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/rte/serializer.ts
+var DEFAULT_TABLE_COLUMN_WIDTH = 250;
+function normalizeForSerializer(doc) {
+  const normalized = normalizeNode(doc);
+  if (!isTextNode(normalized) && normalized.type === "doc") {
+    return normalized;
+  }
+  return {
+    ...doc,
+    children: []
+  };
+}
+function normalizeNode(node) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  const children = node.children?.map((child) => normalizeNode(child));
+  const attrs = isRecord(node.attrs) ? { ...node.attrs } : {};
+  if (node.type === "a" && typeof attrs.url !== "string" && typeof attrs.href === "string") {
+    attrs.url = attrs.href;
+  }
+  if (node.type === "img" && typeof attrs.url !== "string" && typeof attrs.src === "string") {
+    attrs.url = attrs.src;
+  }
+  if (node.type === "table") {
+    const tableRows = (children ?? []).filter(
+      (row) => !isTextNode(row) && row.type === "tr"
+    );
+    const inferredCols = tableRows.reduce((max, row) => {
+      const columnCount = (row.children ?? []).filter(
+        (cell) => !isTextNode(cell) && (cell.type === "td" || cell.type === "th")
+      ).length;
+      return Math.max(max, columnCount);
+    }, 0);
+    const normalizedCols = typeof attrs.cols === "number" && attrs.cols > 0 ? attrs.cols : inferredCols;
+    const normalizedRows = typeof attrs.rows === "number" && attrs.rows > 0 ? attrs.rows : tableRows.length;
+    const normalizedWidths = Array.isArray(attrs.colWidths) && attrs.colWidths.length > 0 && attrs.colWidths.every((width) => typeof width === "number") ? attrs.colWidths : Array.from({ length: Math.max(normalizedCols, 1) }, () => DEFAULT_TABLE_COLUMN_WIDTH);
+    return {
+      ...node,
+      attrs: {
+        ...attrs,
+        rows: normalizedRows,
+        cols: Math.max(normalizedCols, 1),
+        colWidths: normalizedWidths
+      },
+      ...children ? { children } : {}
+    };
+  }
+  return {
+    ...node,
+    attrs,
+    ...children ? { children } : {}
+  };
+}
+
+// src/rte/to-html.ts
+function toHTML(doc, options = {}) {
+  return (0, import_json_rte_serializer.jsonToHtml)(
+    normalizeForSerializer(doc),
+    buildSerializerOptions(options)
+  );
+}
+function buildSerializerOptions(options) {
+  const { renderEntry, renderAsset, serializerOptions } = options;
+  if (!renderEntry && !renderAsset) {
+    return serializerOptions;
+  }
+  const customElementTypes = {
+    ...serializerOptions?.customElementTypes ?? {}
+  };
+  const existingReferenceRenderer = customElementTypes.reference;
+  customElementTypes.reference = (attrs, child, jsonBlock, extraProps) => {
+    const block = asRTENode(jsonBlock);
+    const referenceAttrs = isRecord(block.attrs) ? block.attrs : {};
+    if (referenceAttrs.type === "entry" && renderEntry) {
+      return renderEntry(referenceAttrs, block);
+    }
+    if (referenceAttrs.type === "asset" && renderAsset) {
+      return renderAsset(referenceAttrs, block);
+    }
+    return typeof existingReferenceRenderer === "function" ? existingReferenceRenderer(attrs, child, jsonBlock, extraProps) : "";
+  };
+  return {
+    ...serializerOptions,
+    customElementTypes
+  };
+}
+function asRTENode(value) {
+  if (isRecord(value) && typeof value.type === "string" && typeof value.uid === "string") {
+    return value;
+  }
+  return {
+    type: "reference",
+    uid: "reference"
+  };
+}
+
+// src/rte/to-markdown.ts
+var import_json_rte_serializer2 = require("@contentstack/json-rte-serializer");
+function toMarkdown(doc, options = {}) {
+  const mappedDoc = options.renderEntry || options.renderAsset ? mapReferenceNodes(doc, options) : doc;
+  const markdown = (0, import_json_rte_serializer2.jsonToMarkdown)(normalizeForSerializer(mappedDoc)).trim();
+  return normalizeMarkdownOutput(markdown);
+}
+function mapReferenceNodes(doc, options) {
+  const mapped = mapNode(doc, options);
+  if (isTextNode(mapped)) {
+    return {
+      ...doc,
+      children: []
+    };
+  }
+  return {
+    ...doc,
+    ...mapped,
+    type: "doc",
+    uid: mapped.uid ?? doc.uid
+  };
+}
+function mapNode(node, options) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  if (node.type === "reference") {
+    const attrs = node.attrs ?? {};
+    if (attrs.type === "entry" && options.renderEntry) {
+      return { text: options.renderEntry(attrs, node) };
+    }
+    if (attrs.type === "asset" && options.renderAsset) {
+      return { text: options.renderAsset(attrs, node) };
+    }
+    return { text: "" };
+  }
+  return {
+    ...node,
+    ...node.children ? { children: node.children.map((child) => mapNode(child, options)) } : {}
+  };
+}
+function normalizeMarkdownOutput(markdown) {
+  return markdown.replace(/!\[([^\]]*)\]\s*\n\s*\(([^)\n]+)\)/g, "![$1]($2)");
+}
+
+// src/rte/to-plaintext.ts
+var DOUBLE_BREAK_TYPES = /* @__PURE__ */ new Set([
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "code",
+  "ul",
+  "ol",
+  "table"
+]);
+var SINGLE_BREAK_TYPES = /* @__PURE__ */ new Set(["li", "tr", "td", "th"]);
+function toPlainText(doc) {
+  return renderNode(doc).replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderNode(node) {
+  if (isTextNode(node)) {
+    return node.text;
+  }
+  const children = (node.children ?? []).map((child) => renderNode(child)).join("");
+  if (node.type === "doc") {
+    return children;
+  }
+  if (node.type === "img") {
+    const alt = node.attrs?.alt;
+    if (typeof alt === "string" && alt.trim()) {
+      return `${alt}
+
+`;
+    }
+    return "\n";
+  }
+  if (node.type === "a") {
+    const href = node.attrs?.href;
+    const text = children || (typeof href === "string" ? href : "");
+    return text;
+  }
+  if (node.type === "hr") {
+    return "\n";
+  }
+  if (node.type === "reference") {
+    return "";
+  }
+  if (DOUBLE_BREAK_TYPES.has(node.type)) {
+    return `${children}
+
+`;
+  }
+  if (SINGLE_BREAK_TYPES.has(node.type)) {
+    return `${children}
+`;
+  }
+  return children;
+}
+
+// src/rte/from-html.ts
+var import_json_rte_serializer3 = require("@contentstack/json-rte-serializer");
+var VOID_TAGS = /* @__PURE__ */ new Set(["img", "hr", "br", "meta", "link", "input"]);
+function fromHTML(html, options = {}) {
+  const parsed = parseWithSerializer(html, options);
+  if (parsed) {
+    return parsed;
+  }
+  return parseWithFallback(html);
+}
+function parseWithSerializer(html, options) {
+  try {
+    const parsed = (0, import_json_rte_serializer3.htmlToJson)(html, options.serializerOptions);
+    return normalizeDoc(parsed);
+  } catch {
+    return null;
+  }
+}
+function normalizeDoc(value) {
+  if (isRecord(value) && value.type === "doc" && Array.isArray(value.children)) {
+    return {
+      ...value,
+      type: "doc",
+      uid: typeof value.uid === "string" && value.uid.length > 0 ? value.uid : createUid(),
+      children: value.children
+    };
+  }
+  return null;
+}
+function parseWithFallback(html) {
+  const root = parseHTML(html);
+  const children = convertNodes(root.children);
+  return {
+    type: "doc",
+    uid: createUid(),
+    children
+  };
+}
+function parseHTML(html) {
+  const root = {
+    kind: "element",
+    tag: "root",
+    attrs: {},
+    children: []
+  };
+  const stack = [root];
+  const tokenPattern = /<!--[\s\S]*?-->|<\/?[^>]+>|[^<]+/g;
+  const tokens = html.match(tokenPattern) ?? [];
+  for (const token of tokens) {
+    if (!token) {
+      continue;
+    }
+    if (token.startsWith("<!--")) {
+      continue;
+    }
+    if (!token.startsWith("<")) {
+      const text = decodeHTML(token);
+      if (text.length === 0) {
+        continue;
+      }
+      const parent2 = stack[stack.length - 1];
+      if (!parent2) {
+        continue;
+      }
+      parent2.children.push({
+        kind: "text",
+        value: text
+      });
+      continue;
+    }
+    if (token.startsWith("</")) {
+      const closingTag = token.slice(2, -1).trim().toLowerCase();
+      while (stack.length > 1) {
+        const current = stack.pop();
+        if (current?.tag === closingTag) {
+          break;
+        }
+      }
+      continue;
+    }
+    const parsed = parseOpeningTag(token);
+    if (!parsed) {
+      continue;
+    }
+    const parent = stack[stack.length - 1];
+    if (!parent) {
+      continue;
+    }
+    parent.children.push(parsed.element);
+    const isVoid = parsed.selfClosing || VOID_TAGS.has(parsed.element.tag);
+    if (!isVoid) {
+      stack.push(parsed.element);
+    }
+  }
+  return root;
+}
+function parseOpeningTag(token) {
+  const isSelfClosing = token.endsWith("/>");
+  const content = token.slice(1, token.length - (isSelfClosing ? 2 : 1)).trim();
+  if (!content) {
+    return null;
+  }
+  const tagMatch = content.match(/^([a-zA-Z0-9-]+)/);
+  if (!tagMatch?.[1]) {
+    return null;
+  }
+  const tag = tagMatch[1].toLowerCase();
+  const attrs = parseAttributes(content.slice(tag.length).trim());
+  return {
+    element: {
+      kind: "element",
+      tag,
+      attrs,
+      children: []
+    },
+    selfClosing: isSelfClosing
+  };
+}
+function parseAttributes(input) {
+  const attrs = {};
+  const attrPattern = /([:@a-zA-Z0-9_-]+)(?:\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>/]+)))?/g;
+  let match = attrPattern.exec(input);
+  while (match) {
+    const key = match[1];
+    if (key) {
+      const value = decodeHTML(match[3] ?? match[4] ?? match[5] ?? "");
+      attrs[key] = value;
+    }
+    match = attrPattern.exec(input);
+  }
+  return attrs;
+}
+function convertNodes(nodes, marks = {}) {
+  const output = [];
+  for (const node of nodes) {
+    if (node.kind === "text") {
+      const cleaned = normalizeText(node.value);
+      if (!cleaned) {
+        continue;
+      }
+      output.push({
+        text: cleaned,
+        ...marks.bold ? { bold: true } : {},
+        ...marks.italic ? { italic: true } : {},
+        ...marks.underline ? { underline: true } : {},
+        ...marks.strikethrough ? { strikethrough: true } : {},
+        ...marks.code ? { code: true } : {},
+        ...marks.superscript ? { superscript: true } : {},
+        ...marks.subscript ? { subscript: true } : {}
+      });
+      continue;
+    }
+    output.push(...convertElement(node, marks));
+  }
+  return output;
+}
+function convertElement(element, marks) {
+  switch (element.tag) {
+    case "strong":
+    case "b":
+      return convertNodes(element.children, { ...marks, bold: true });
+    case "em":
+    case "i":
+      return convertNodes(element.children, { ...marks, italic: true });
+    case "u":
+      return convertNodes(element.children, { ...marks, underline: true });
+    case "s":
+    case "strike":
+    case "del":
+      return convertNodes(element.children, { ...marks, strikethrough: true });
+    case "sup":
+      return convertNodes(element.children, { ...marks, superscript: true });
+    case "sub":
+      return convertNodes(element.children, { ...marks, subscript: true });
+    case "code":
+      return convertNodes(element.children, { ...marks, code: true });
+    case "br":
+      return [{ text: "\n" }];
+    case "img":
+      return [
+        {
+          type: "img",
+          uid: createUid(),
+          attrs: {
+            src: element.attrs.src ?? "",
+            alt: element.attrs.alt ?? ""
+          }
+        }
+      ];
+    case "hr":
+      return [
+        {
+          type: "hr",
+          uid: createUid()
+        }
+      ];
+    case "a":
+      return [
+        {
+          type: "a",
+          uid: createUid(),
+          attrs: {
+            href: element.attrs.href ?? "",
+            ...element.attrs.target ? { target: element.attrs.target } : {}
+          },
+          children: convertNodes(element.children)
+        }
+      ];
+    case "reference":
+      return [
+        {
+          type: "reference",
+          uid: createUid(),
+          attrs: {
+            ...element.attrs
+          }
+        }
+      ];
+    case "pre": {
+      const codeText = extractTextContent(element);
+      return [
+        {
+          type: "code",
+          uid: createUid(),
+          children: codeText ? [{ text: codeText }] : []
+        }
+      ];
+    }
+    case "p":
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+    case "ul":
+    case "ol":
+    case "li":
+    case "blockquote":
+    case "table":
+    case "tr":
+    case "td":
+    case "th":
+      return [
+        {
+          type: element.tag,
+          uid: createUid(),
+          children: convertNodes(element.children)
+        }
+      ];
+    default:
+      return convertNodes(element.children, marks);
+  }
+}
+function extractTextContent(node) {
+  if (node.kind === "text") {
+    return decodeHTML(node.value);
+  }
+  return node.children.map((child) => extractTextContent(child)).join("");
+}
+function normalizeText(value) {
+  const collapsed = value.replace(/\s+/g, " ");
+  if (collapsed.trim().length === 0) {
+    return " ";
+  }
+  return collapsed;
+}
+
+// src/rte/transform.ts
+function transform(doc, visitors) {
+  const transformed = visitNode(doc, visitors);
+  if (!transformed || isTextNode(transformed) || transformed.type !== "doc") {
+    return {
+      ...doc,
+      children: []
+    };
+  }
+  return transformed;
+}
+function visitNode(node, visitors) {
+  if (isTextNode(node)) {
+    return { ...node };
+  }
+  const nextChildren = (node.children ?? []).map((child) => visitNode(child, visitors)).filter((child) => Boolean(child));
+  const withChildren = {
+    ...node,
+    ...node.children ? { children: nextChildren } : {}
+  };
+  const visitor = visitors[withChildren.type];
+  if (!visitor) {
+    return withChildren;
+  }
+  return visitor(withChildren);
+}
+
+// src/rte/validate.ts
+function validate(doc) {
+  const errors = [];
+  if (!isElementNode(doc)) {
+    errors.push("Document must be an object node with type and uid");
+    return { valid: false, errors };
+  }
+  if (doc.type !== "doc") {
+    errors.push('Document root node must have type "doc"');
+  }
+  if (!Array.isArray(doc.children)) {
+    errors.push('Document root node must include a "children" array');
+  } else {
+    validateChildren(doc.children, "doc.children", errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateChildren(children, path, errors) {
+  children.forEach((child, index) => {
+    validateNode(child, `${path}[${index}]`, errors);
+  });
+}
+function validateNode(node, path, errors) {
+  if (isTextNode(node)) {
+    if (typeof node.text !== "string") {
+      errors.push(`${path} must have a string text value`);
+    }
+    return;
+  }
+  if (!isElementNode(node)) {
+    errors.push(`${path} must be a valid element node or text node`);
+    return;
+  }
+  validateElementNode(node, path, errors);
+}
+function validateElementNode(node, path, errors) {
+  if (!KNOWN_RTE_TYPES.has(node.type)) {
+    errors.push(`${path}.type "${node.type}" is not a supported RTE node type`);
+  }
+  if (typeof node.uid !== "string" || node.uid.trim().length === 0) {
+    errors.push(`${path}.uid must be a non-empty string`);
+  }
+  if (node.children !== void 0) {
+    if (!Array.isArray(node.children)) {
+      errors.push(`${path}.children must be an array when provided`);
+    } else {
+      validateChildren(node.children, `${path}.children`, errors);
+    }
+  }
+  switch (node.type) {
+    case "img":
+      validateImgNode(node, path, errors);
+      break;
+    case "a":
+      validateAnchorNode(node, path, errors);
+      break;
+    case "reference":
+      validateReferenceNode(node, path, errors);
+      break;
+    case "hr":
+      if (Array.isArray(node.children) && node.children.length > 0) {
+        errors.push(`${path}.children must be empty for hr nodes`);
+      }
+      break;
+  }
+}
+function validateImgNode(node, path, errors) {
+  if (!isRecord(node.attrs) || typeof node.attrs.src !== "string" || node.attrs.src.length === 0) {
+    errors.push(`${path}.attrs.src must be a non-empty string for img nodes`);
+  }
+  if (isRecord(node.attrs) && node.attrs.alt !== void 0 && typeof node.attrs.alt !== "string") {
+    errors.push(`${path}.attrs.alt must be a string when provided`);
+  }
+}
+function validateAnchorNode(node, path, errors) {
+  if (!isRecord(node.attrs) || typeof node.attrs.href !== "string" || node.attrs.href.length === 0) {
+    errors.push(`${path}.attrs.href must be a non-empty string for a nodes`);
+  }
+  if (isRecord(node.attrs) && node.attrs.target !== void 0 && typeof node.attrs.target !== "string") {
+    errors.push(`${path}.attrs.target must be a string when provided`);
+  }
+}
+function validateReferenceNode(node, path, errors) {
+  if (!isRecord(node.attrs)) {
+    errors.push(`${path}.attrs must be present for reference nodes`);
+    return;
+  }
+  const refType = node.attrs.type;
+  if (refType !== "entry" && refType !== "asset") {
+    errors.push(`${path}.attrs.type must be "entry" or "asset" for reference nodes`);
+    return;
+  }
+  if (refType === "entry" && typeof node.attrs["entry-uid"] !== "string") {
+    errors.push(`${path}.attrs["entry-uid"] must be provided for entry references`);
+  }
+  if (refType === "asset" && typeof node.attrs["asset-uid"] !== "string") {
+    errors.push(`${path}.attrs["asset-uid"] must be provided for asset references`);
+  }
+}
+
+// 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;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssetsClient,
+  AuditLogClient,
+  BranchAliasesClient,
+  BranchesClient,
+  BulkOperationsClient,
+  ContentTypesClient,
+  ContentstackAuthError,
+  ContentstackConfigError,
+  ContentstackError,
+  ContentstackForbiddenError,
+  ContentstackInvalidApiKeyError,
+  ContentstackNotFoundError,
+  ContentstackRateLimitError,
+  ContentstackServerError,
+  ContentstackValidationError,
+  CrudClient,
+  EntriesClient,
+  EnvironmentsClient,
+  ExtensionsClient,
+  GlobalFieldsClient,
+  LabelsClient,
+  LocalesClient,
+  PublishRulesClient,
+  ReleasesClient,
+  RolesClient,
+  TaxonomiesClient,
+  TokensClient,
+  WebhooksClient,
+  WorkflowsClient,
+  buildAssetsParams,
+  buildAuthorizationUrl,
+  buildCreateEntryRequest,
+  buildDeleteEntryRequest,
+  buildEntriesParams,
+  buildEntryParams,
+  buildPublishEntryRequest,
+  buildUpdateEntryRequest,
+  collectAll,
+  contentstackAuthCallbacks,
+  createAuthProvider,
+  createBrandKitClient,
+  createCMAClient,
+  createGenerativeAIClient,
+  createKnowledgeVaultClient,
+  createLaunchClient,
+  exchangeCode,
+  fromHTML,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  getUser,
+  imageTransform,
+  normalizeRegion,
+  paginate,
+  parseErrorResponse,
+  refreshToken,
+  resolveEndpoints,
+  resolveHosts,
+  toHTML,
+  toMarkdown,
+  toPlainText,
+  transform,
+  validate
+});
+//# sourceMappingURL=index.cjs.map