@foxnose/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1353 @@
+// src/auth/anonymous.ts
+var AnonymousAuth = class {
+  buildHeaders(_request) {
+    return {};
+  }
+};
+
+// src/auth/jwt.ts
+var StaticTokenProvider = class {
+  constructor(token) {
+    this.token = token;
+  }
+  getToken() {
+    return this.token;
+  }
+};
+var JWTAuth = class _JWTAuth {
+  provider;
+  scheme;
+  constructor(provider, options) {
+    this.provider = provider;
+    this.scheme = options?.scheme ?? "Bearer";
+  }
+  buildHeaders(_request) {
+    const token = this.provider.getToken();
+    if (!token) {
+      throw new Error("Token provider returned an empty token");
+    }
+    return { Authorization: `${this.scheme} ${token}` };
+  }
+  /**
+   * Convenience constructor for scripts with manual token management.
+   */
+  static fromStaticToken(token, options) {
+    return new _JWTAuth(new StaticTokenProvider(token), options);
+  }
+};
+
+// src/auth/secure.ts
+import { createHash, createSign } from "crypto";
+
+// src/errors.ts
+var FoxnoseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FoxnoseError";
+  }
+};
+var FoxnoseAPIError = class extends FoxnoseError {
+  statusCode;
+  errorCode;
+  detail;
+  responseHeaders;
+  responseBody;
+  constructor(options) {
+    const code = options.errorCode ? `, error_code=${options.errorCode}` : "";
+    super(`${options.message} (status=${options.statusCode}${code})`);
+    this.name = "FoxnoseAPIError";
+    this.statusCode = options.statusCode;
+    this.errorCode = options.errorCode;
+    this.detail = options.detail;
+    this.responseHeaders = options.responseHeaders;
+    this.responseBody = options.responseBody;
+  }
+};
+var FoxnoseAuthError = class extends FoxnoseError {
+  constructor(message) {
+    super(message);
+    this.name = "FoxnoseAuthError";
+  }
+};
+var FoxnoseTransportError = class extends FoxnoseError {
+  constructor(message) {
+    super(message);
+    this.name = "FoxnoseTransportError";
+  }
+};
+
+// src/auth/secure.ts
+var SecureKeyAuth = class {
+  publicKey;
+  privateKeyPem;
+  clock;
+  constructor(publicKey, privateKey, options) {
+    if (!publicKey || !privateKey) {
+      throw new Error("publicKey and privateKey are required");
+    }
+    this.publicKey = publicKey;
+    this.clock = options?.clock ?? (() => /* @__PURE__ */ new Date());
+    try {
+      const derB64 = privateKey;
+      this.privateKeyPem = `-----BEGIN EC PRIVATE KEY-----
+` + derB64.match(/.{1,64}/g).join("\n") + `
+-----END EC PRIVATE KEY-----`;
+    } catch (err) {
+      throw new FoxnoseAuthError(`Failed to load private key: ${err}`);
+    }
+  }
+  buildHeaders(request) {
+    const body = request.body ?? new Uint8Array(0);
+    const now = this.clock();
+    const timestamp = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+    let path;
+    try {
+      const parsed = new URL(request.url);
+      path = parsed.pathname || "/";
+      if (parsed.search) {
+        path = `${path}${parsed.search}`;
+      }
+    } catch {
+      path = request.path || "/";
+    }
+    const bodyHash = createHash("sha256").update(body).digest("hex");
+    const dataToSign = `${path}|${bodyHash}|${timestamp}`;
+    const signer = createSign("SHA256");
+    signer.update(dataToSign);
+    signer.end();
+    const signatureBuffer = signer.sign({
+      key: this.privateKeyPem,
+      dsaEncoding: "der"
+    });
+    const signatureB64 = signatureBuffer.toString("base64");
+    return {
+      Authorization: `Secure ${this.publicKey}:${signatureB64}`,
+      Date: timestamp
+    };
+  }
+};
+
+// src/auth/simple.ts
+var SimpleKeyAuth = class {
+  publicKey;
+  secretKey;
+  constructor(publicKey, secretKey) {
+    if (!publicKey || !secretKey) {
+      throw new Error("publicKey and secretKey are required");
+    }
+    this.publicKey = publicKey;
+    this.secretKey = secretKey;
+  }
+  buildHeaders(_request) {
+    return { Authorization: `Simple ${this.publicKey}:${this.secretKey}` };
+  }
+};
+
+// src/config.ts
+var DEFAULT_RETRY_CONFIG = {
+  attempts: 3,
+  backoffFactor: 0.5,
+  statusCodes: [408, 425, 429, 500, 502, 503, 504],
+  methods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]
+};
+var SDK_VERSION = "0.1.0";
+var DEFAULT_USER_AGENT = `foxnose-sdk-js/${SDK_VERSION}`;
+function createConfig(options) {
+  if (!options.baseUrl) {
+    throw new Error("baseUrl must be provided");
+  }
+  return {
+    baseUrl: options.baseUrl.replace(/\/+$/, ""),
+    timeout: options.timeout ?? 3e4,
+    defaultHeaders: options.defaultHeaders,
+    userAgent: options.userAgent ?? DEFAULT_USER_AGENT
+  };
+}
+
+// src/http.ts
+var HttpTransport = class {
+  config;
+  auth;
+  retry;
+  constructor(options) {
+    this.config = options.config;
+    this.auth = options.auth ?? new AnonymousAuth();
+    this.retry = options.retryConfig ?? { ...DEFAULT_RETRY_CONFIG };
+  }
+  async request(method, path, options) {
+    const parseJson = options?.parseJson ?? true;
+    const response = await this.sendWithRetries(method, path, options);
+    return this.maybeDecodeResponse(response, parseJson);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  close() {
+  }
+  buildUrl(path, params) {
+    const base = this.config.baseUrl + path;
+    if (!params || Object.keys(params).length === 0) {
+      return base;
+    }
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    }
+    const qs = searchParams.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  buildRequest(method, path, options) {
+    const headers = {};
+    if (this.config.defaultHeaders) {
+      Object.assign(headers, this.config.defaultHeaders);
+    }
+    headers["User-Agent"] = headers["User-Agent"] ?? this.config.userAgent;
+    if (options?.headers) {
+      Object.assign(headers, options.headers);
+    }
+    let body = new Uint8Array(0);
+    let bodyInit;
+    if (options?.jsonBody !== void 0) {
+      const jsonStr = JSON.stringify(options.jsonBody);
+      body = new TextEncoder().encode(jsonStr);
+      bodyInit = jsonStr;
+      headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+    } else if (options?.content) {
+      body = options.content;
+      bodyInit = options.content;
+    }
+    const url = this.buildUrl(path, options?.params);
+    const requestData = {
+      method: method.toUpperCase(),
+      url,
+      path: this.buildSigningPath(path, options?.params),
+      body
+    };
+    const authHeaders = this.auth.buildHeaders(requestData);
+    if (authHeaders) {
+      Object.assign(headers, authHeaders);
+    }
+    const init = {
+      method: method.toUpperCase(),
+      headers,
+      body: bodyInit
+    };
+    return { url, init, body };
+  }
+  buildSigningPath(path, params) {
+    if (!params || Object.keys(params).length === 0) {
+      return path;
+    }
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    }
+    const qs = searchParams.toString();
+    return qs ? `${path}?${qs}` : path;
+  }
+  shouldRetry(method, statusCode) {
+    if (!this.retry.methods.includes(method.toUpperCase())) {
+      return false;
+    }
+    return this.retry.statusCodes.includes(statusCode);
+  }
+  computeDelay(attempt, retryAfter) {
+    if (retryAfter) {
+      const parsed = parseFloat(retryAfter);
+      if (!isNaN(parsed)) {
+        return parsed * 1e3;
+      }
+      return 0;
+    }
+    const base = this.retry.backoffFactor * Math.pow(2, Math.max(attempt - 1, 0)) * 1e3;
+    return base * (0.5 + Math.random() * 0.5);
+  }
+  async maybeDecodeResponse(response, parseJson) {
+    if (!parseJson) {
+      return response;
+    }
+    const text = await response.text();
+    if (!text) {
+      return null;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async sendWithRetries(method, path, options) {
+    for (let attempt = 1; attempt <= this.retry.attempts; attempt++) {
+      const { url, init } = this.buildRequest(method, path, options);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      init.signal = controller.signal;
+      let response;
+      try {
+        response = await fetch(url, init);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        const delay = this.handleTransportError(err, method, attempt);
+        if (delay > 0) {
+          await this.sleep(delay);
+        }
+        continue;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (response.status >= 400) {
+        if (this.shouldRetry(method, response.status) && attempt < this.retry.attempts) {
+          const delay = this.computeDelay(attempt, response.headers.get("Retry-After"));
+          if (delay > 0) {
+            await this.sleep(delay);
+          }
+          continue;
+        }
+        await this.raiseAPIError(response);
+      }
+      return response;
+    }
+    throw new FoxnoseTransportError("All retry attempts exhausted");
+  }
+  handleTransportError(err, method, attempt) {
+    const canRetry = this.retry.methods.includes(method.toUpperCase()) && attempt < this.retry.attempts;
+    if (!canRetry) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new FoxnoseTransportError(message);
+    }
+    return this.computeDelay(attempt);
+  }
+  async raiseAPIError(response) {
+    let message = "";
+    let errorCode;
+    let detail;
+    let body;
+    try {
+      const text = await response.text();
+      message = text;
+      if (text) {
+        try {
+          const payload = JSON.parse(text);
+          message = payload.message ?? message;
+          errorCode = payload.error_code;
+          detail = payload.detail;
+          body = payload;
+        } catch {
+          body = text;
+        }
+      }
+    } catch {
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    throw new FoxnoseAPIError({
+      message: message || "API request failed",
+      statusCode: response.status,
+      errorCode,
+      detail,
+      responseHeaders,
+      responseBody: body
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/management/models.ts
+function resolveKey(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object" && "key" in value && typeof value.key === "string") {
+    return value.key;
+  }
+  throw new TypeError(
+    `Expected a string or an object with a 'key' attribute, got ${typeof value}`
+  );
+}
+
+// src/management/paths.ts
+function managementPaths(environmentKey) {
+  return {
+    // Organization paths
+    orgRoot: (orgKey) => `/organizations/${orgKey}`,
+    projectsBase: (orgKey) => `/organizations/${orgKey}/projects`,
+    projectRoot: (orgKey, projectKey) => `/organizations/${orgKey}/projects/${projectKey}`,
+    environmentsBase: (orgKey, projectKey) => `/organizations/${orgKey}/projects/${projectKey}/environments`,
+    environmentRoot: (orgKey, projectKey, envKey) => `/organizations/${orgKey}/projects/${projectKey}/environments/${envKey}`,
+    // Folder paths
+    foldersTreeRoot: () => `/v1/${environmentKey}/folders/tree`,
+    foldersTreeItem: () => `/v1/${environmentKey}/folders/tree/folder`,
+    folderVersionsBase: (folderKey) => `/v1/${environmentKey}/folders/${folderKey}/model/versions`,
+    folderSchemaTree: (folderKey, versionKey) => `/v1/${environmentKey}/folders/${folderKey}/model/versions/${versionKey}/schema/tree`,
+    // Component paths
+    componentsRoot: () => `/v1/${environmentKey}/components`,
+    componentRoot: (componentKey) => `/v1/${environmentKey}/components/${componentKey}`,
+    componentVersionsBase: (componentKey) => `/v1/${environmentKey}/components/${componentKey}/model/versions`,
+    componentSchemaTree: (componentKey, versionKey) => `/v1/${environmentKey}/components/${componentKey}/model/versions/${versionKey}/schema/tree`,
+    // Resource paths
+    resourceBase: (folderKey) => `/v1/${environmentKey}/folders/${folderKey}/resources`,
+    revisionBase: (folderKey, resourceKey) => `/v1/${environmentKey}/folders/${folderKey}/resources/${resourceKey}/revisions`,
+    // Management API key paths
+    managementApiKeysRoot: () => `/v1/${environmentKey}/permissions/management-api/api-keys`,
+    managementApiKeyRoot: (apiKey) => `/v1/${environmentKey}/permissions/management-api/api-keys/${apiKey}`,
+    // Flux API key paths
+    fluxApiKeysRoot: () => `/v1/${environmentKey}/permissions/flux-api/api-keys`,
+    fluxApiKeyRoot: (apiKey) => `/v1/${environmentKey}/permissions/flux-api/api-keys/${apiKey}`,
+    // API management paths
+    apisRoot: () => `/v1/${environmentKey}/api`,
+    apiRoot: (apiKey) => `/v1/${environmentKey}/api/${apiKey}`,
+    apiFoldersRoot: (apiKey) => `/v1/${environmentKey}/api/${apiKey}/folders`,
+    // Management role paths
+    managementRolesRoot: () => `/v1/${environmentKey}/permissions/management-api/roles`,
+    managementRoleRoot: (roleKey) => `/v1/${environmentKey}/permissions/management-api/roles/${roleKey}`,
+    rolePermissionsRoot: (roleKey) => `/v1/${environmentKey}/permissions/management-api/roles/${roleKey}/permissions`,
+    rolePermissionsBatch: (roleKey) => `/v1/${environmentKey}/permissions/management-api/roles/${roleKey}/permissions/batch`,
+    rolePermissionObjectsRoot: (roleKey) => `/v1/${environmentKey}/permissions/management-api/roles/${roleKey}/permissions/objects`,
+    // Flux role paths
+    fluxRolesRoot: () => `/v1/${environmentKey}/permissions/flux-api/roles`,
+    fluxRoleRoot: (roleKey) => `/v1/${environmentKey}/permissions/flux-api/roles/${roleKey}`,
+    fluxRolePermissionsRoot: (roleKey) => `/v1/${environmentKey}/permissions/flux-api/roles/${roleKey}/permissions`,
+    fluxRolePermissionsBatch: (roleKey) => `/v1/${environmentKey}/permissions/flux-api/roles/${roleKey}/permissions/batch`,
+    fluxRolePermissionObjectsRoot: (roleKey) => `/v1/${environmentKey}/permissions/flux-api/roles/${roleKey}/permissions/objects`,
+    // Locale paths
+    localesRoot: () => `/v1/${environmentKey}/locales`,
+    localeRoot: (code) => `/v1/${environmentKey}/locales/${code}`
+  };
+}
+
+// src/management/client.ts
+var ManagementClient = class {
+  environmentKey;
+  transport;
+  paths;
+  constructor(options) {
+    if (!options.environmentKey) {
+      throw new Error("environmentKey must be provided");
+    }
+    this.environmentKey = options.environmentKey;
+    const config = createConfig({
+      baseUrl: options.baseUrl ?? "https://api.foxnose.net",
+      timeout: options.timeout,
+      defaultHeaders: options.defaultHeaders
+    });
+    this.transport = new HttpTransport({
+      config,
+      auth: options.auth,
+      retryConfig: options.retryConfig
+    });
+    this.paths = managementPaths(options.environmentKey);
+  }
+  /**
+   * Low-level escape hatch for calling arbitrary endpoints.
+   */
+  async request(method, path, options) {
+    return this.transport.request(method, path, options);
+  }
+  close() {
+    this.transport.close();
+  }
+  // ------------------------------------------------------------------ //
+  // Organization operations
+  // ------------------------------------------------------------------ //
+  async listOrganizations() {
+    const payload = await this.request("GET", "/organizations/") ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async getOrganization(orgKey) {
+    const key = resolveKey(orgKey);
+    return this.request("GET", `${this.paths.orgRoot(key)}/`);
+  }
+  async updateOrganization(orgKey, payload) {
+    const key = resolveKey(orgKey);
+    return this.request("PUT", `${this.paths.orgRoot(key)}/`, { jsonBody: payload });
+  }
+  async listRegions() {
+    const payload = await this.request("GET", "/regions/") ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async getAvailablePlans() {
+    return this.request("GET", "/plans/");
+  }
+  async getOrganizationPlan(orgKey) {
+    const key = resolveKey(orgKey);
+    return this.request("GET", `${this.paths.orgRoot(key)}/plan/`);
+  }
+  async setOrganizationPlan(orgKey, planCode) {
+    const key = resolveKey(orgKey);
+    return this.request("POST", `${this.paths.orgRoot(key)}/plan/${planCode}/`);
+  }
+  async getOrganizationUsage(orgKey) {
+    const key = resolveKey(orgKey);
+    return this.request("GET", `${this.paths.orgRoot(key)}/usage/`);
+  }
+  // ------------------------------------------------------------------ //
+  // Management API key operations
+  // ------------------------------------------------------------------ //
+  async listManagementApiKeys(params) {
+    return this.request("GET", `${this.paths.managementApiKeysRoot()}/`, { params });
+  }
+  async createManagementApiKey(payload) {
+    return this.request("POST", `${this.paths.managementApiKeysRoot()}/`, {
+      jsonBody: payload
+    });
+  }
+  async getManagementApiKey(key) {
+    const k = resolveKey(key);
+    return this.request("GET", `${this.paths.managementApiKeyRoot(k)}/`);
+  }
+  async updateManagementApiKey(key, payload) {
+    const k = resolveKey(key);
+    return this.request("PUT", `${this.paths.managementApiKeyRoot(k)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteManagementApiKey(key) {
+    const k = resolveKey(key);
+    await this.request("DELETE", `${this.paths.managementApiKeyRoot(k)}/`, {
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Flux API key operations
+  // ------------------------------------------------------------------ //
+  async listFluxApiKeys(params) {
+    return this.request("GET", `${this.paths.fluxApiKeysRoot()}/`, { params });
+  }
+  async createFluxApiKey(payload) {
+    return this.request("POST", `${this.paths.fluxApiKeysRoot()}/`, { jsonBody: payload });
+  }
+  async getFluxApiKey(key) {
+    const k = resolveKey(key);
+    return this.request("GET", `${this.paths.fluxApiKeyRoot(k)}/`);
+  }
+  async updateFluxApiKey(key, payload) {
+    const k = resolveKey(key);
+    return this.request("PUT", `${this.paths.fluxApiKeyRoot(k)}/`, { jsonBody: payload });
+  }
+  async deleteFluxApiKey(key) {
+    const k = resolveKey(key);
+    await this.request("DELETE", `${this.paths.fluxApiKeyRoot(k)}/`, { parseJson: false });
+  }
+  // ------------------------------------------------------------------ //
+  // API management operations
+  // ------------------------------------------------------------------ //
+  async listApis(params) {
+    return this.request("GET", `${this.paths.apisRoot()}/`, { params });
+  }
+  async createApi(payload) {
+    return this.request("POST", `${this.paths.apisRoot()}/`, { jsonBody: payload });
+  }
+  async getApi(apiKey) {
+    const key = resolveKey(apiKey);
+    return this.request("GET", `${this.paths.apiRoot(key)}/`);
+  }
+  async updateApi(apiKey, payload) {
+    const key = resolveKey(apiKey);
+    return this.request("PUT", `${this.paths.apiRoot(key)}/`, { jsonBody: payload });
+  }
+  async deleteApi(apiKey) {
+    const key = resolveKey(apiKey);
+    await this.request("DELETE", `${this.paths.apiRoot(key)}/`, { parseJson: false });
+  }
+  // ------------------------------------------------------------------ //
+  // API Folder associations
+  // ------------------------------------------------------------------ //
+  async listApiFolders(apiKey, params) {
+    const key = resolveKey(apiKey);
+    return this.request("GET", `${this.paths.apiFoldersRoot(key)}/`, { params });
+  }
+  async addApiFolder(apiKey, folderKey, options) {
+    const aKey = resolveKey(apiKey);
+    const fKey = resolveKey(folderKey);
+    const body = { folder: fKey };
+    if (options?.allowedMethods) {
+      body.allowed_methods = options.allowedMethods;
+    }
+    return this.request("POST", `${this.paths.apiFoldersRoot(aKey)}/`, { jsonBody: body });
+  }
+  async getApiFolder(apiKey, folderKey) {
+    const aKey = resolveKey(apiKey);
+    const fKey = resolveKey(folderKey);
+    return this.request("GET", `${this.paths.apiFoldersRoot(aKey)}/${fKey}/`);
+  }
+  async updateApiFolder(apiKey, folderKey, options) {
+    const aKey = resolveKey(apiKey);
+    const fKey = resolveKey(folderKey);
+    const body = {};
+    if (options?.allowedMethods) {
+      body.allowed_methods = options.allowedMethods;
+    }
+    return this.request("PUT", `${this.paths.apiFoldersRoot(aKey)}/${fKey}/`, {
+      jsonBody: body
+    });
+  }
+  async removeApiFolder(apiKey, folderKey) {
+    const aKey = resolveKey(apiKey);
+    const fKey = resolveKey(folderKey);
+    await this.request("DELETE", `${this.paths.apiFoldersRoot(aKey)}/${fKey}/`, {
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Management role operations
+  // ------------------------------------------------------------------ //
+  async listManagementRoles(params) {
+    return this.request("GET", `${this.paths.managementRolesRoot()}/`, { params });
+  }
+  async createManagementRole(payload) {
+    return this.request("POST", `${this.paths.managementRolesRoot()}/`, {
+      jsonBody: payload
+    });
+  }
+  async getManagementRole(roleKey) {
+    const key = resolveKey(roleKey);
+    return this.request("GET", `${this.paths.managementRoleRoot(key)}/`);
+  }
+  async updateManagementRole(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("PUT", `${this.paths.managementRoleRoot(key)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteManagementRole(roleKey) {
+    const key = resolveKey(roleKey);
+    await this.request("DELETE", `${this.paths.managementRoleRoot(key)}/`, {
+      parseJson: false
+    });
+  }
+  // Management role permissions
+  async listManagementRolePermissions(roleKey) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("GET", `${this.paths.rolePermissionsRoot(key)}/`) ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async upsertManagementRolePermission(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("POST", `${this.paths.rolePermissionsRoot(key)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteManagementRolePermission(roleKey, contentType) {
+    const key = resolveKey(roleKey);
+    await this.request("DELETE", `${this.paths.rolePermissionsRoot(key)}/`, {
+      params: { content_type: contentType },
+      parseJson: false
+    });
+  }
+  async replaceManagementRolePermissions(roleKey, permissions) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("POST", `${this.paths.rolePermissionsBatch(key)}/`, {
+      jsonBody: permissions
+    });
+    return Array.isArray(payload) ? payload : [];
+  }
+  // Management permission objects
+  async listManagementPermissionObjects(roleKey, contentType) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("GET", `${this.paths.rolePermissionObjectsRoot(key)}/`, {
+      params: { content_type: contentType }
+    }) ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async addManagementPermissionObject(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("POST", `${this.paths.rolePermissionObjectsRoot(key)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteManagementPermissionObject(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    await this.request("DELETE", `${this.paths.rolePermissionObjectsRoot(key)}/`, {
+      jsonBody: payload,
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Flux role operations
+  // ------------------------------------------------------------------ //
+  async listFluxRoles(params) {
+    return this.request("GET", `${this.paths.fluxRolesRoot()}/`, { params });
+  }
+  async createFluxRole(payload) {
+    return this.request("POST", `${this.paths.fluxRolesRoot()}/`, { jsonBody: payload });
+  }
+  async getFluxRole(roleKey) {
+    const key = resolveKey(roleKey);
+    return this.request("GET", `${this.paths.fluxRoleRoot(key)}/`);
+  }
+  async updateFluxRole(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("PUT", `${this.paths.fluxRoleRoot(key)}/`, { jsonBody: payload });
+  }
+  async deleteFluxRole(roleKey) {
+    const key = resolveKey(roleKey);
+    await this.request("DELETE", `${this.paths.fluxRoleRoot(key)}/`, { parseJson: false });
+  }
+  // Flux role permissions
+  async listFluxRolePermissions(roleKey) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("GET", `${this.paths.fluxRolePermissionsRoot(key)}/`) ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async upsertFluxRolePermission(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("POST", `${this.paths.fluxRolePermissionsRoot(key)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteFluxRolePermission(roleKey, contentType) {
+    const key = resolveKey(roleKey);
+    await this.request(
+      "DELETE",
+      `${this.paths.fluxRolePermissionsRoot(key)}/`,
+      { params: { content_type: contentType }, parseJson: false }
+    );
+  }
+  async replaceFluxRolePermissions(roleKey, permissions) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("POST", `${this.paths.fluxRolePermissionsBatch(key)}/`, {
+      jsonBody: permissions
+    });
+    return Array.isArray(payload) ? payload : [];
+  }
+  // Flux permission objects
+  async listFluxPermissionObjects(roleKey, contentType) {
+    const key = resolveKey(roleKey);
+    const payload = await this.request("GET", `${this.paths.fluxRolePermissionObjectsRoot(key)}/`, {
+      params: { content_type: contentType }
+    }) ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async addFluxPermissionObject(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    return this.request("POST", `${this.paths.fluxRolePermissionObjectsRoot(key)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteFluxPermissionObject(roleKey, payload) {
+    const key = resolveKey(roleKey);
+    await this.request("DELETE", `${this.paths.fluxRolePermissionObjectsRoot(key)}/`, {
+      jsonBody: payload,
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Folder operations
+  // ------------------------------------------------------------------ //
+  async listFolders(params) {
+    return this.request("GET", `${this.paths.foldersTreeRoot()}/`, { params });
+  }
+  async getFolder(folderKey) {
+    const key = resolveKey(folderKey);
+    return this.request("GET", `${this.paths.foldersTreeItem()}/`, {
+      params: { key }
+    });
+  }
+  async getFolderByPath(path) {
+    return this.request("GET", `${this.paths.foldersTreeItem()}/`, {
+      params: { path }
+    });
+  }
+  async listFolderTree(options) {
+    const params = {};
+    if (options?.key) params.key = options.key;
+    if (options?.mode) params.mode = options.mode;
+    return this.request("GET", `${this.paths.foldersTreeRoot()}/`, { params });
+  }
+  async createFolder(payload) {
+    return this.request("POST", `${this.paths.foldersTreeRoot()}/`, { jsonBody: payload });
+  }
+  async updateFolder(folderKey, payload) {
+    const key = resolveKey(folderKey);
+    return this.request("PUT", `${this.paths.foldersTreeItem()}/`, {
+      params: { key },
+      jsonBody: payload
+    });
+  }
+  async deleteFolder(folderKey) {
+    const key = resolveKey(folderKey);
+    await this.request("DELETE", `${this.paths.foldersTreeItem()}/`, {
+      params: { key },
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Folder version operations
+  // ------------------------------------------------------------------ //
+  async listFolderVersions(folderKey, params) {
+    const key = resolveKey(folderKey);
+    return this.request("GET", `${this.paths.folderVersionsBase(key)}/`, { params });
+  }
+  async createFolderVersion(folderKey, payload, options) {
+    const key = resolveKey(folderKey);
+    const params = {};
+    if (options?.copyFrom) {
+      params.copy_from = resolveKey(options.copyFrom);
+    }
+    return this.request("POST", `${this.paths.folderVersionsBase(key)}/`, {
+      jsonBody: payload,
+      params: Object.keys(params).length > 0 ? params : void 0
+    });
+  }
+  async getFolderVersion(folderKey, versionKey, options) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    const params = {};
+    if (options?.includeSchema !== void 0) {
+      params.include_schema = options.includeSchema;
+    }
+    return this.request("GET", `${this.paths.folderVersionsBase(fKey)}/${vKey}/`, {
+      params: Object.keys(params).length > 0 ? params : void 0
+    });
+  }
+  async updateFolderVersion(folderKey, versionKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("PUT", `${this.paths.folderVersionsBase(fKey)}/${vKey}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteFolderVersion(folderKey, versionKey) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    await this.request("DELETE", `${this.paths.folderVersionsBase(fKey)}/${vKey}/`, {
+      parseJson: false
+    });
+  }
+  async publishFolderVersion(folderKey, versionKey) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "POST",
+      `${this.paths.folderVersionsBase(fKey)}/${vKey}/publish/`
+    );
+  }
+  // ------------------------------------------------------------------ //
+  // Folder field operations
+  // ------------------------------------------------------------------ //
+  async listFolderFields(folderKey, versionKey, params) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("GET", `${this.paths.folderSchemaTree(fKey, vKey)}/`, { params });
+  }
+  async createFolderField(folderKey, versionKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("POST", `${this.paths.folderSchemaTree(fKey, vKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async getFolderField(folderKey, versionKey, fieldPath) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "GET",
+      `${this.paths.folderSchemaTree(fKey, vKey)}/field/`,
+      { params: { path: fieldPath } }
+    );
+  }
+  async updateFolderField(folderKey, versionKey, fieldPath, payload) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "PUT",
+      `${this.paths.folderSchemaTree(fKey, vKey)}/field/`,
+      { params: { path: fieldPath }, jsonBody: payload }
+    );
+  }
+  async deleteFolderField(folderKey, versionKey, fieldPath) {
+    const fKey = resolveKey(folderKey);
+    const vKey = resolveKey(versionKey);
+    await this.request(
+      "DELETE",
+      `${this.paths.folderSchemaTree(fKey, vKey)}/field/`,
+      { params: { path: fieldPath }, parseJson: false }
+    );
+  }
+  // ------------------------------------------------------------------ //
+  // Component operations
+  // ------------------------------------------------------------------ //
+  async listComponents(params) {
+    return this.request("GET", `${this.paths.componentsRoot()}/`, { params });
+  }
+  async getComponent(componentKey) {
+    const key = resolveKey(componentKey);
+    return this.request("GET", `${this.paths.componentRoot(key)}/`);
+  }
+  async createComponent(payload) {
+    return this.request("POST", `${this.paths.componentsRoot()}/`, { jsonBody: payload });
+  }
+  async updateComponent(componentKey, payload) {
+    const key = resolveKey(componentKey);
+    return this.request("PUT", `${this.paths.componentRoot(key)}/`, { jsonBody: payload });
+  }
+  async deleteComponent(componentKey) {
+    const key = resolveKey(componentKey);
+    await this.request("DELETE", `${this.paths.componentRoot(key)}/`, { parseJson: false });
+  }
+  // ------------------------------------------------------------------ //
+  // Component version operations
+  // ------------------------------------------------------------------ //
+  async listComponentVersions(componentKey, params) {
+    const key = resolveKey(componentKey);
+    return this.request("GET", `${this.paths.componentVersionsBase(key)}/`, { params });
+  }
+  async createComponentVersion(componentKey, payload, options) {
+    const key = resolveKey(componentKey);
+    const params = {};
+    if (options?.copyFrom) {
+      params.copy_from = resolveKey(options.copyFrom);
+    }
+    return this.request("POST", `${this.paths.componentVersionsBase(key)}/`, {
+      jsonBody: payload,
+      params: Object.keys(params).length > 0 ? params : void 0
+    });
+  }
+  async getComponentVersion(componentKey, versionKey, options) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    const params = {};
+    if (options?.includeSchema !== void 0) {
+      params.include_schema = options.includeSchema;
+    }
+    return this.request("GET", `${this.paths.componentVersionsBase(cKey)}/${vKey}/`, {
+      params: Object.keys(params).length > 0 ? params : void 0
+    });
+  }
+  async publishComponentVersion(componentKey, versionKey) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "POST",
+      `${this.paths.componentVersionsBase(cKey)}/${vKey}/publish/`
+    );
+  }
+  async updateComponentVersion(componentKey, versionKey, payload) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("PUT", `${this.paths.componentVersionsBase(cKey)}/${vKey}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteComponentVersion(componentKey, versionKey) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    await this.request("DELETE", `${this.paths.componentVersionsBase(cKey)}/${vKey}/`, {
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Component field operations
+  // ------------------------------------------------------------------ //
+  async listComponentFields(componentKey, versionKey, params) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("GET", `${this.paths.componentSchemaTree(cKey, vKey)}/`, { params });
+  }
+  async createComponentField(componentKey, versionKey, payload) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request("POST", `${this.paths.componentSchemaTree(cKey, vKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async getComponentField(componentKey, versionKey, fieldPath) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "GET",
+      `${this.paths.componentSchemaTree(cKey, vKey)}/field/`,
+      { params: { path: fieldPath } }
+    );
+  }
+  async updateComponentField(componentKey, versionKey, fieldPath, payload) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    return this.request(
+      "PUT",
+      `${this.paths.componentSchemaTree(cKey, vKey)}/field/`,
+      { params: { path: fieldPath }, jsonBody: payload }
+    );
+  }
+  async deleteComponentField(componentKey, versionKey, fieldPath) {
+    const cKey = resolveKey(componentKey);
+    const vKey = resolveKey(versionKey);
+    await this.request(
+      "DELETE",
+      `${this.paths.componentSchemaTree(cKey, vKey)}/field/`,
+      { params: { path: fieldPath }, parseJson: false }
+    );
+  }
+  // ------------------------------------------------------------------ //
+  // Resource operations
+  // ------------------------------------------------------------------ //
+  async listResources(folderKey, params) {
+    const key = resolveKey(folderKey);
+    return this.request("GET", `${this.paths.resourceBase(key)}/`, { params });
+  }
+  async getResource(folderKey, resourceKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    return this.request("GET", `${this.paths.resourceBase(fKey)}/${rKey}/`);
+  }
+  async createResource(folderKey, payload, options) {
+    const key = resolveKey(folderKey);
+    const params = {};
+    if (options?.component) {
+      params.component = resolveKey(options.component);
+    }
+    const body = { ...payload };
+    if (options?.externalId) {
+      body.external_id = options.externalId;
+    }
+    return this.request("POST", `${this.paths.resourceBase(key)}/`, {
+      params: Object.keys(params).length ? params : void 0,
+      jsonBody: body
+    });
+  }
+  async upsertResource(folderKey, payload, options) {
+    const key = resolveKey(folderKey);
+    const params = { external_id: options.externalId };
+    if (options.component) {
+      params.component = resolveKey(options.component);
+    }
+    return this.request("PUT", `${this.paths.resourceBase(key)}/`, {
+      params,
+      jsonBody: payload
+    });
+  }
+  async batchUpsertResources(folderKey, items, options) {
+    const fKey = resolveKey(folderKey);
+    const maxConcurrency = options?.maxConcurrency ?? 5;
+    if (maxConcurrency < 1) {
+      throw new Error("maxConcurrency must be at least 1");
+    }
+    if (items.length === 0) {
+      return { succeeded: [], failed: [] };
+    }
+    const failFast = options?.failFast ?? false;
+    const onProgress = options?.onProgress;
+    const succeeded = [];
+    const failed = [];
+    let completed = 0;
+    const queue = [...items.entries()];
+    const processItem = async (index, item) => {
+      try {
+        const params = { external_id: item.external_id };
+        if (item.component) {
+          params.component = item.component;
+        }
+        const result = await this.request(
+          "PUT",
+          `${this.paths.resourceBase(fKey)}/`,
+          { params, jsonBody: item.payload }
+        );
+        succeeded.push(result);
+      } catch (err) {
+        failed.push({
+          index,
+          external_id: item.external_id,
+          error: err instanceof Error ? err : new Error(String(err))
+        });
+        if (failFast) {
+          throw err;
+        }
+      } finally {
+        completed++;
+        onProgress?.(completed, items.length);
+      }
+    };
+    let i = 0;
+    while (i < queue.length) {
+      const batch = queue.slice(i, i + maxConcurrency);
+      try {
+        await Promise.all(batch.map(([index, item]) => processItem(index, item)));
+      } catch (err) {
+        if (failFast) throw err;
+      }
+      i += maxConcurrency;
+    }
+    return { succeeded, failed };
+  }
+  async updateResource(folderKey, resourceKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    await this.request("PUT", `${this.paths.resourceBase(fKey)}/${rKey}/`, {
+      jsonBody: payload,
+      parseJson: false
+    });
+    return this.getResource(fKey, rKey);
+  }
+  async deleteResource(folderKey, resourceKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    await this.request("DELETE", `${this.paths.resourceBase(fKey)}/${rKey}/`, {
+      parseJson: false
+    });
+  }
+  async getResourceData(folderKey, resourceKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    return this.request("GET", `${this.paths.resourceBase(fKey)}/${rKey}/data/`);
+  }
+  // ------------------------------------------------------------------ //
+  // Revision operations
+  // ------------------------------------------------------------------ //
+  async listRevisions(folderKey, resourceKey, params) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    return this.request("GET", `${this.paths.revisionBase(fKey, rKey)}/`, { params });
+  }
+  async createRevision(folderKey, resourceKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    return this.request("POST", `${this.paths.revisionBase(fKey, rKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async getRevision(folderKey, resourceKey, revisionKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    return this.request("GET", `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/`);
+  }
+  async updateRevision(folderKey, resourceKey, revisionKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    return this.request("PUT", `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteRevision(folderKey, resourceKey, revisionKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    await this.request("DELETE", `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/`, {
+      parseJson: false
+    });
+  }
+  async publishRevision(folderKey, resourceKey, revisionKey, payload) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    return this.request(
+      "POST",
+      `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/publish/`,
+      payload ? { jsonBody: payload } : void 0
+    );
+  }
+  async validateRevision(folderKey, resourceKey, revisionKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    return this.request(
+      "POST",
+      `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/validate/`
+    );
+  }
+  async getRevisionData(folderKey, resourceKey, revisionKey) {
+    const fKey = resolveKey(folderKey);
+    const rKey = resolveKey(resourceKey);
+    const rvKey = resolveKey(revisionKey);
+    return this.request("GET", `${this.paths.revisionBase(fKey, rKey)}/${rvKey}/data/`);
+  }
+  // ------------------------------------------------------------------ //
+  // Locale operations
+  // ------------------------------------------------------------------ //
+  async listLocales() {
+    const payload = await this.request("GET", `${this.paths.localesRoot()}/`) ?? [];
+    return Array.isArray(payload) ? payload : [payload];
+  }
+  async createLocale(payload) {
+    return this.request("POST", `${this.paths.localesRoot()}/`, { jsonBody: payload });
+  }
+  async getLocale(code) {
+    return this.request("GET", `${this.paths.localeRoot(code)}/`);
+  }
+  async updateLocale(code, payload) {
+    return this.request("PUT", `${this.paths.localeRoot(code)}/`, { jsonBody: payload });
+  }
+  async deleteLocale(code) {
+    await this.request("DELETE", `${this.paths.localeRoot(code)}/`, { parseJson: false });
+  }
+  // ------------------------------------------------------------------ //
+  // Project operations
+  // ------------------------------------------------------------------ //
+  async listProjects(orgKey, params) {
+    const key = resolveKey(orgKey);
+    return this.request("GET", `${this.paths.projectsBase(key)}/`, { params });
+  }
+  async getProject(orgKey, projectKey) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    return this.request("GET", `${this.paths.projectRoot(oKey, pKey)}/`);
+  }
+  async createProject(orgKey, payload) {
+    const key = resolveKey(orgKey);
+    return this.request("POST", `${this.paths.projectsBase(key)}/`, { jsonBody: payload });
+  }
+  async updateProject(orgKey, projectKey, payload) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    return this.request("PUT", `${this.paths.projectRoot(oKey, pKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteProject(orgKey, projectKey) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    await this.request("DELETE", `${this.paths.projectRoot(oKey, pKey)}/`, {
+      parseJson: false
+    });
+  }
+  // ------------------------------------------------------------------ //
+  // Environment operations
+  // ------------------------------------------------------------------ //
+  async listEnvironments(orgKey, projectKey) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const payload = await this.request("GET", `${this.paths.environmentsBase(oKey, pKey)}/`) ?? [];
+    if (Array.isArray(payload)) {
+      return payload;
+    }
+    if (payload && typeof payload === "object" && "results" in payload) {
+      return payload.results;
+    }
+    return [payload];
+  }
+  async getEnvironment(orgKey, projectKey, envKey) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const eKey = resolveKey(envKey);
+    return this.request("GET", `${this.paths.environmentRoot(oKey, pKey, eKey)}/`);
+  }
+  async createEnvironment(orgKey, projectKey, payload) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    return this.request("POST", `${this.paths.environmentsBase(oKey, pKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async updateEnvironment(orgKey, projectKey, envKey, payload) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const eKey = resolveKey(envKey);
+    return this.request("PUT", `${this.paths.environmentRoot(oKey, pKey, eKey)}/`, {
+      jsonBody: payload
+    });
+  }
+  async deleteEnvironment(orgKey, projectKey, envKey) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const eKey = resolveKey(envKey);
+    await this.request("DELETE", `${this.paths.environmentRoot(oKey, pKey, eKey)}/`, {
+      parseJson: false
+    });
+  }
+  async toggleEnvironment(orgKey, projectKey, envKey, isEnabled) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const eKey = resolveKey(envKey);
+    await this.request(
+      "POST",
+      `${this.paths.environmentRoot(oKey, pKey, eKey)}/toggle/`,
+      { jsonBody: { is_enabled: isEnabled } }
+    );
+  }
+  async updateEnvironmentProtection(orgKey, projectKey, envKey, options) {
+    const oKey = resolveKey(orgKey);
+    const pKey = resolveKey(projectKey);
+    const eKey = resolveKey(envKey);
+    const body = { protection_level: options.protectionLevel };
+    if (options.protectionReason) {
+      body.protection_reason = options.protectionReason;
+    }
+    return this.request(
+      "PATCH",
+      `${this.paths.environmentRoot(oKey, pKey, eKey)}/protection/`,
+      { jsonBody: body }
+    );
+  }
+  async clearEnvironmentProtection(orgKey, projectKey, envKey) {
+    return this.updateEnvironmentProtection(orgKey, projectKey, envKey, {
+      protectionLevel: "none"
+    });
+  }
+};
+
+// src/flux/client.ts
+function cleanPrefix(prefix) {
+  const value = prefix.replace(/^\/+|\/+$/g, "");
+  if (!value) {
+    throw new Error("apiPrefix cannot be empty");
+  }
+  return value;
+}
+function normalizeFolderPath(folderPath) {
+  return folderPath.replace(/^\/+|\/+$/g, "");
+}
+var FluxClient = class {
+  apiPrefix;
+  transport;
+  constructor(options) {
+    this.apiPrefix = cleanPrefix(options.apiPrefix);
+    const config = createConfig({
+      baseUrl: options.baseUrl,
+      timeout: options.timeout ?? 15e3,
+      defaultHeaders: options.defaultHeaders
+    });
+    this.transport = new HttpTransport({
+      config,
+      auth: options.auth,
+      retryConfig: options.retryConfig
+    });
+  }
+  buildPath(folderPath, suffix = "") {
+    const folder = normalizeFolderPath(folderPath);
+    const base = `/${this.apiPrefix}/${folder}`;
+    return suffix ? `${base}${suffix}` : base;
+  }
+  async listResources(folderPath, params) {
+    const path = this.buildPath(folderPath);
+    return this.transport.request("GET", path, { params });
+  }
+  async getResource(folderPath, resourceKey, params) {
+    const path = this.buildPath(folderPath, `/${resourceKey}`);
+    return this.transport.request("GET", path, { params });
+  }
+  async search(folderPath, body) {
+    const path = this.buildPath(folderPath, "/_search");
+    return this.transport.request("POST", path, { jsonBody: body });
+  }
+  close() {
+    this.transport.close();
+  }
+};
+export {
+  AnonymousAuth,
+  DEFAULT_RETRY_CONFIG,
+  DEFAULT_USER_AGENT,
+  FluxClient,
+  FoxnoseAPIError,
+  FoxnoseAuthError,
+  FoxnoseError,
+  FoxnoseTransportError,
+  HttpTransport,
+  JWTAuth,
+  ManagementClient,
+  SDK_VERSION,
+  SecureKeyAuth,
+  SimpleKeyAuth,
+  StaticTokenProvider,
+  SDK_VERSION as VERSION,
+  createConfig,
+  resolveKey
+};
+//# sourceMappingURL=index.js.map