@boltic/sdk 0.1.3 → 0.1.5

package/dist/sdk.js

@@ -236,6 +236,20 @@ Context: ${JSON.stringify(context, null, 2)}`;
   }
   return String(error);
 }
+function decodeArrayBufferErrorBody(buffer) {
+  const txt = new TextDecoder().decode(buffer);
+  try {
+    return JSON.parse(txt);
+  } catch {
+    return txt;
+  }
+}
+function normalizeAxiosDataAfterResponse(config, status, data) {
+  if (config.responseType !== "arraybuffer" || !(data instanceof ArrayBuffer) || status < 400) {
+    return data;
+  }
+  return decodeArrayBufferErrorBody(data);
+}
 class AxiosAdapter {
   constructor() {
     try {
@@ -249,21 +263,36 @@ class AxiosAdapter {
   }
   async request(config) {
     try {
+      const isFormData = typeof FormData !== "undefined" && config.data instanceof FormData;
+      let headers = config.headers;
+      if (isFormData && headers) {
+        headers = { ...headers };
+        delete headers["Content-Type"];
+        delete headers["content-type"];
+      }
       const axiosConfig = {
         url: config.url,
         method: config.method.toLowerCase(),
-        headers: config.headers,
+        headers,
         params: config.params,
         data: config.data,
         timeout: config.timeout,
         signal: config.signal,
         validateStatus: () => true
       };
+      if (config.responseType === "arraybuffer") {
+        axiosConfig.responseType = "arraybuffer";
+      }
       const response = await this.axios(axiosConfig);
+      const responseData = normalizeAxiosDataAfterResponse(
+        config,
+        response.status,
+        response.data
+      );
       if (response.status < 200 || response.status >= 300) {
-        const isHtmlError = typeof response.data === "string" && response.data.trim().startsWith("<!DOCTYPE") || typeof response.data === "string" && response.data.includes("<html");
+        const isHtmlError = typeof responseData === "string" && responseData.trim().startsWith("<!DOCTYPE") || typeof responseData === "string" && responseData.includes("<html");
         if (isHtmlError) {
-          const htmlContent = response.data;
+          const htmlContent = responseData;
           const preMatch = htmlContent.match(/<pre>(.*?)<\/pre>/s);
           const errorMessage = preMatch ? preMatch[1].trim() : `HTTP ${response.status}: ${response.statusText}`;
           throw createErrorWithContext(errorMessage, {
@@ -274,9 +303,9 @@ class AxiosAdapter {
             isHtmlError: true
           });
         }
-        if (response.data && typeof response.data === "object" && "error" in response.data) {
+        if (responseData && typeof responseData === "object" && "error" in responseData) {
           return {
-            data: response.data,
+            data: responseData,
             status: response.status,
             statusText: response.statusText,
             headers: response.headers || {}
@@ -289,12 +318,12 @@ class AxiosAdapter {
             method: config.method,
             status: response.status,
             statusText: response.statusText,
-            responseData: response.data
+            responseData
           }
         );
       }
       return {
-        data: response.data,
+        data: responseData,
         status: response.status,
         statusText: response.statusText,
         headers: response.headers || {}
@@ -337,6 +366,26 @@ class AxiosAdapter {
     }
   }
 }
+async function parseFetchBodyDefault(response) {
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+async function parseFetchBodyArrayBuffer(response) {
+  const buf = await response.arrayBuffer();
+  if (response.status >= 400) {
+    return decodeArrayBufferErrorBody(buf);
+  }
+  return buf;
+}
+async function parseFetchResponseData(response, config) {
+  if (config.responseType === "arraybuffer") {
+    return parseFetchBodyArrayBuffer(response);
+  }
+  return parseFetchBodyDefault(response);
+}
 class FetchAdapter {
   async request(config) {
     const url = new URL(config.url);
@@ -347,16 +396,21 @@ class FetchAdapter {
         }
       });
     }
+    const isFormData = typeof FormData !== "undefined" && config.data instanceof FormData;
+    const headerMap = { ...config.headers || {} };
+    if (!isFormData) {
+      headerMap["Content-Type"] = headerMap["Content-Type"] ?? headerMap["content-type"] ?? "application/json";
+    } else {
+      delete headerMap["Content-Type"];
+      delete headerMap["content-type"];
+    }
     const init = {
       method: config.method,
-      headers: {
-        "Content-Type": "application/json",
-        ...config.headers
-      },
+      headers: headerMap,
       signal: config.signal
     };
     if (config.data && ["POST", "PUT", "PATCH", "DELETE"].includes(config.method)) {
-      init.body = JSON.stringify(config.data);
+      init.body = isFormData ? config.data : JSON.stringify(config.data);
     }
     try {
       const controller = new AbortController();
@@ -380,13 +434,10 @@ class FetchAdapter {
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
-      const contentType = response.headers.get("content-type");
-      let data;
-      if (contentType?.includes("application/json")) {
-        data = await response.json();
-      } else {
-        data = await response.text();
-      }
+      const data = await parseFetchResponseData(
+        response,
+        config
+      );
       const headers = {};
       response.headers.forEach((value, key) => {
         headers[key] = value;
@@ -549,7 +600,9 @@ class AuthManager2 {
 const SERVICE_PATHS = {
   DATABASES: "/service/sdk/boltic-tables/v1",
   WORKFLOW_TEMPORAL: "/service/panel/temporal/v1.0",
-  INTEGRATION: "/service/panel/integration/v1"
+  INTEGRATION: "/service/panel/integration/v1",
+  SERVERLESS: "/service/panel/serverless/v1.0",
+  STORAGE: "/service/panel/storage/v1.0"
 };
 class BaseApiClient {
   constructor(apiKey, config = {}, servicePath = SERVICE_PATHS.DATABASES) {
@@ -4076,7 +4129,10 @@ class SqlApiClient extends BaseApiClient {
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
-        headers: this.buildHeaders(),
+        headers: {
+          ...this.buildHeaders(),
+          "x-request-source": "sdk"
+        },
         data: request,
         timeout: this.config.timeout
       });
@@ -4107,7 +4163,10 @@ class SqlApiClient extends BaseApiClient {
       const response = await this.httpAdapter.request({
         url,
         method: endpoint.method,
-        headers: this.buildHeaders(),
+        headers: {
+          ...this.buildHeaders(),
+          "x-request-source": "sdk"
+        },
         data: request,
         timeout: this.config.timeout
       });
@@ -4786,7 +4845,7 @@ function buildExecuteActivityBody(params) {
     result: params.result ?? buildDefaultResultPayload()
   };
 }
-function sleep(ms) {
+function sleep$1(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 class WorkflowResource extends BaseResource {
@@ -4984,7 +5043,7 @@ class WorkflowResource extends BaseResource {
         }
         return result;
       }
-      await sleep(POLLING_INTERVAL_MS);
+      await sleep$1(POLLING_INTERVAL_MS);
     }
     return {
       error: {
@@ -4998,6 +5057,945 @@ class WorkflowResource extends BaseResource {
     };
   }
 }
+const STATUS_POLLING_INTERVAL_MS = 5e3;
+const MAX_STATUS_POLLING_ATTEMPTS = 60;
+const TERMINAL_STATUSES = [
+  "running",
+  "failed",
+  "degraded",
+  "suspended"
+];
+const DEFAULT_RESOURCES = {
+  CPU: 0.1,
+  MemoryMB: 128,
+  MemoryMaxMB: 128
+};
+const DEFAULT_SCALING = {
+  AutoStop: false,
+  Min: 1,
+  Max: 1,
+  MaxIdleTime: 0
+};
+const SERVERLESS_ENDPOINTS = {
+  list: {
+    path: "/apps",
+    method: "GET",
+    authenticated: true
+  },
+  get: {
+    path: "/apps/{app_id}",
+    method: "GET",
+    authenticated: true
+  },
+  create: {
+    path: "/apps",
+    method: "POST",
+    authenticated: true
+  },
+  update: {
+    path: "/apps/{app_id}",
+    method: "PUT",
+    authenticated: true
+  },
+  getBuilds: {
+    path: "/apps/{app_id}/builds",
+    method: "GET",
+    authenticated: true
+  },
+  getLogs: {
+    path: "/apps/{app_id}/logs",
+    method: "GET",
+    authenticated: true
+  },
+  getBuildLogs: {
+    path: "/apps/{app_id}/builds/{build_id}/logs",
+    method: "GET",
+    authenticated: true
+  }
+};
+function buildServerlessEndpointPath(endpoint, params = {}) {
+  let path = endpoint.path;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(`{${key}}`, value);
+  }
+  return path;
+}
+class ServerlessApiClient extends BaseApiClient {
+  constructor(apiKey, config = {}) {
+    super(apiKey, config, SERVICE_PATHS.SERVERLESS);
+  }
+  /**
+   * List all serverless functions with optional pagination and search.
+   */
+  async list(params = {}) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.list;
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 20),
+        sortBy: params.sortBy ?? "CreatedAt",
+        sortOrder: params.sortOrder ?? "desc"
+      });
+      if (params.query) {
+        query.set("q", params.query);
+      }
+      const url = `${this.baseURL}${endpoint.path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get a serverless function by its ID.
+   */
+  async get(appId) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.get;
+      const path = buildServerlessEndpointPath(endpoint, { app_id: appId });
+      const url = `${this.baseURL}${path}`;
+      console.log("url", url);
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      console.log("response", response.data);
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Create a new serverless function.
+   */
+  async create(payload) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.create;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: payload,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Update an existing serverless function.
+   */
+  async update(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.update;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const url = `${this.baseURL}${path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: params.payload,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * List builds for a serverless function.
+   */
+  async getBuilds(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getBuilds;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 20),
+        sortBy: "CreatedAt",
+        sortOrder: "desc"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get runtime logs for a serverless function.
+   */
+  async getLogs(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getLogs;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId
+      });
+      const now = Math.floor(Date.now() / 1e3);
+      const defaultStart = now - 24 * 60 * 60;
+      const query = new URLSearchParams({
+        page: String(params.page ?? 1),
+        limit: String(params.limit ?? 50),
+        sortBy: "Timestamp",
+        sortOrder: params.sortOrder ?? "DESC",
+        timestampStart: String(params.timestampStart ?? defaultStart),
+        timestampEnd: String(params.timestampEnd ?? now),
+        metric_interval: "60"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+  /**
+   * Get build logs for a specific build of a serverless function.
+   */
+  async getBuildLogs(params) {
+    try {
+      const endpoint = SERVERLESS_ENDPOINTS.getBuildLogs;
+      const path = buildServerlessEndpointPath(endpoint, {
+        app_id: params.appId,
+        build_id: params.buildId
+      });
+      const query = new URLSearchParams({
+        limit: "-1",
+        tail: "false",
+        sortOrder: "asc",
+        sortBy: "Timestamp"
+      });
+      const url = `${this.baseURL}${path}?${query.toString()}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SERVERLESS");
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class ServerlessResource extends BaseResource {
+  constructor(client) {
+    super(client, "/serverless");
+    const config = client.getConfig();
+    this.apiClient = new ServerlessApiClient(config.apiKey, {
+      environment: config.environment,
+      region: config.region,
+      timeout: config.timeout,
+      debug: config.debug
+    });
+  }
+  /**
+   * List all serverless functions with optional pagination and search.
+   *
+   * @param params - Optional pagination and filter parameters
+   * @returns Paginated list of serverless functions
+   *
+   * @example
+   * ```typescript
+   * const list = await client.serverless.list();
+   * const filtered = await client.serverless.list({ query: 'my-func', limit: 10 });
+   * ```
+   */
+  async list(params = {}) {
+    return this.apiClient.list(params);
+  }
+  /**
+   * Get a serverless function by its ID.
+   *
+   * @param appId - The serverless function ID
+   * @returns The serverless function details
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.get('serverless-id');
+   * ```
+   */
+  async get(appId) {
+    return this.apiClient.get(appId);
+  }
+  /**
+   * Create a new serverless function.
+   *
+   * Supports three runtime types:
+   * - `code` — deploy code directly (blueprint)
+   * - `git` — deploy from a Git repository
+   * - `container` — deploy a Docker container
+   *
+   * @param params - The serverless creation payload
+   * @returns The created serverless function
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.create({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   *   CodeOpts: { Language: 'nodejs/20', Code: 'module.exports.handler = ...' },
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.apiClient.create(params);
+  }
+  /**
+   * Create a serverless function and poll until it reaches a terminal state.
+   *
+   * Combines `create()` + `pollStatus()` for a simpler workflow.
+   *
+   * @param params - The serverless creation payload
+   * @returns The final serverless state after reaching a terminal status
+   *
+   * @example
+   * ```typescript
+   * const fn = await client.serverless.createAndWait({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   CodeOpts: { Language: 'nodejs/20', Code: '...' },
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   * });
+   * ```
+   */
+  async createAndWait(params) {
+    const createResult = await this.apiClient.create(params);
+    if (isErrorResponse(createResult)) {
+      return createResult;
+    }
+    const appId = createResult.data?.ID;
+    if (!appId) {
+      return {
+        error: {
+          code: "SERVERLESS_MISSING_ID",
+          message: "Create API response did not contain an ID",
+          meta: []
+        }
+      };
+    }
+    return this.pollStatus(appId);
+  }
+  /**
+   * Update an existing serverless function.
+   *
+   * @param params - The update parameters (appId + partial payload)
+   * @returns The updated serverless function
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.serverless.update({
+   *   appId: 'serverless-id',
+   *   payload: { Scaling: { AutoStop: true, Min: 0, Max: 3, MaxIdleTime: 300 } },
+   * });
+   * ```
+   */
+  async update(params) {
+    return this.apiClient.update(params);
+  }
+  /**
+   * Update a serverless function and poll until it reaches a terminal state.
+   *
+   * @param params - The update parameters (appId + partial payload)
+   * @returns The final serverless state after reaching a terminal status
+   */
+  async updateAndWait(params) {
+    const updateResult = await this.apiClient.update(params);
+    if (isErrorResponse(updateResult)) {
+      return updateResult;
+    }
+    return this.pollStatus(params.appId);
+  }
+  /**
+   * List builds for a serverless function.
+   *
+   * @param params - The app ID and optional pagination
+   * @returns List of builds
+   *
+   * @example
+   * ```typescript
+   * const builds = await client.serverless.getBuilds({ appId: 'serverless-id' });
+   * ```
+   */
+  async getBuilds(params) {
+    return this.apiClient.getBuilds(params);
+  }
+  /**
+   * Get runtime logs for a serverless function.
+   *
+   * @param params - The app ID and optional time range / pagination
+   * @returns Log entries
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.serverless.getLogs({ appId: 'serverless-id' });
+   * const recentLogs = await client.serverless.getLogs({
+   *   appId: 'serverless-id',
+   *   limit: 100,
+   *   sortOrder: 'DESC',
+   * });
+   * ```
+   */
+  async getLogs(params) {
+    return this.apiClient.getLogs(params);
+  }
+  /**
+   * Get build logs for a specific build.
+   *
+   * @param params - The app ID and build ID
+   * @returns Build log entries
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.serverless.getBuildLogs({
+   *   appId: 'serverless-id',
+   *   buildId: 'build-id',
+   * });
+   * ```
+   */
+  async getBuildLogs(params) {
+    return this.apiClient.getBuildLogs(params);
+  }
+  /**
+   * Poll a serverless function until it reaches a terminal status
+   * (running, failed, degraded, or suspended).
+   *
+   * @param appId - The serverless function ID to poll
+   * @param options - Optional polling configuration overrides
+   * @returns The final serverless state or a timeout error
+   *
+   * @example
+   * ```typescript
+   * const result = await client.serverless.pollStatus('serverless-id');
+   * ```
+   */
+  async pollStatus(appId, options = {}) {
+    const interval = options.intervalMs ?? STATUS_POLLING_INTERVAL_MS;
+    const maxAttempts = options.maxAttempts ?? MAX_STATUS_POLLING_ATTEMPTS;
+    const debug = this.client.getConfig().debug;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.apiClient.get(appId);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      const status = result.data?.Status;
+      if (debug) {
+        console.log(
+          `[ServerlessResource] Poll #${attempt + 1}: status=${status}`
+        );
+      }
+      if (status && TERMINAL_STATUSES.includes(status)) {
+        if (debug) {
+          console.log(
+            `[ServerlessResource] Reached terminal state: ${status} after ${attempt + 1} poll(s)`
+          );
+        }
+        return result;
+      }
+      await sleep(interval);
+    }
+    return {
+      error: {
+        code: "SERVERLESS_STATUS_TIMEOUT",
+        message: `Serverless ${appId} did not reach a terminal state within ${maxAttempts} polling attempts`,
+        meta: [
+          `app_id: ${appId}`,
+          `max_attempts: ${maxAttempts}`,
+          `interval_ms: ${interval}`
+        ]
+      }
+    };
+  }
+}
+const DEFAULT_STORAGE_TYPE = "gcs";
+const MAX_SIGNED_URL_EXPIRE_MINUTES = 7 * 24 * 60;
+const STORAGE_ENDPOINTS = {
+  list: {
+    path: "/storage/list",
+    method: "GET",
+    authenticated: true
+  },
+  upload: {
+    path: "/storage/upload",
+    method: "POST",
+    authenticated: true
+  },
+  directory: {
+    path: "/storage/directory",
+    method: "POST",
+    authenticated: true
+  },
+  deleteFile: {
+    path: "/storage/file",
+    method: "DELETE",
+    authenticated: true
+  },
+  objectAccess: {
+    path: "/storage/change-object-access",
+    method: "POST",
+    authenticated: true
+  },
+  fileExport: {
+    path: "/storage/file-export",
+    method: "POST",
+    authenticated: true
+  }
+};
+function buildStorageEndpointPath(endpoint) {
+  return endpoint.path;
+}
+const ERR_PREFIX = "STORAGE";
+class StorageApiClient extends BaseApiClient {
+  constructor(apiKey, config = {}) {
+    super(apiKey, config, SERVICE_PATHS.STORAGE);
+  }
+  /** Shared try/catch + http — same idea as inlined blocks in serverless/workflow clients, but DRY for storage. */
+  async requestStorage(config) {
+    try {
+      const response = await this.httpAdapter.request(config);
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, ERR_PREFIX);
+    }
+  }
+  url(path, query) {
+    const qs = query?.toString();
+    return qs ? `${this.baseURL}${path}?${qs}` : `${this.baseURL}${path}`;
+  }
+  storageTypeQuery(storageType) {
+    const q = new URLSearchParams();
+    q.set("storageType", storageType ?? DEFAULT_STORAGE_TYPE);
+    return q;
+  }
+  listQuery(params) {
+    const q = this.storageTypeQuery(params.storageType);
+    if (params.basePath !== void 0) {
+      q.set("basePath", params.basePath);
+    }
+    if (params.pageSize !== void 0) {
+      q.set("pageSize", String(params.pageSize));
+    }
+    if (params.nextPageToken !== void 0) {
+      q.set("nextPageToken", params.nextPageToken);
+    }
+    return q;
+  }
+  /** `expire_in` is minutes; clamp to max temporary URL lifetime (7 days). */
+  normalizeExpireInMinutes(raw) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+      throw new Error(
+        "expire_in must be a positive number of minutes (max 7 days for temporary signed URLs)"
+      );
+    }
+    const truncated = Math.trunc(n);
+    return Math.min(Math.max(1, truncated), MAX_SIGNED_URL_EXPIRE_MINUTES);
+  }
+  isTruthyFormFlag(v) {
+    if (v === void 0) return false;
+    if (typeof v === "boolean") return v;
+    const s = String(v).toLowerCase();
+    return s === "true" || s === "1" || s === "yes";
+  }
+  /**
+   * `public` shortcut: true + no expire_in → permanent; true + expire_in → temporary signed URL; false → private.
+   * Legacy: omit `public` and pass `is_public` / `is_public_permanent` / `expire_in` as before.
+   */
+  appendUploadVisibility(form, params) {
+    const hasPublic = Object.prototype.hasOwnProperty.call(params, "public");
+    if (hasPublic) {
+      const pub = this.isTruthyFormFlag(params.public);
+      if (!pub) {
+        form.append("is_public", "false");
+        return;
+      }
+      if (params.expire_in !== void 0) {
+        form.append("is_public", "true");
+        form.append(
+          "expire_in",
+          String(this.normalizeExpireInMinutes(params.expire_in))
+        );
+        return;
+      }
+      form.append("is_public", "false");
+      form.append("is_public_permanent", "true");
+      return;
+    }
+    if (params.is_public !== void 0) {
+      form.append("is_public", String(params.is_public));
+    }
+    if (params.expire_in !== void 0) {
+      form.append(
+        "expire_in",
+        String(this.normalizeExpireInMinutes(params.expire_in))
+      );
+    }
+    if (params.is_public_permanent !== void 0) {
+      form.append("is_public_permanent", String(params.is_public_permanent));
+    }
+  }
+  buildUploadForm(params) {
+    const logicalName = params.filename ?? params.file_name;
+    if (logicalName == null || logicalName === "") {
+      throw new Error("upload requires filename or file_name");
+    }
+    const form = new FormData();
+    form.append("file", params.file, logicalName);
+    form.append("filename", logicalName);
+    if (params.filepath !== void 0) {
+      form.append("filepath", params.filepath);
+    }
+    if (params.overwrite !== void 0) {
+      form.append("overwrite", String(params.overwrite));
+    }
+    this.appendUploadVisibility(form, params);
+    return form;
+  }
+  isErrorResult(result) {
+    return typeof result === "object" && result !== null && "error" in result && result.error !== void 0;
+  }
+  isAclErrorResult(result) {
+    return typeof result === "object" && result !== null && "error" in result && result.error !== void 0;
+  }
+  buildObjectAccessSummary(filePath, row, fallbackPublic) {
+    const isPublic = row != null ? Boolean(row.isPublic) : fallbackPublic;
+    return {
+      message: isPublic ? "File has been made publicly accessible." : "File's public access has been revoked, making it private.",
+      name: row?.name ?? row?.fullPath ?? filePath,
+      size: row?.size ?? null,
+      updated: row?.updatedAt ?? null,
+      public: isPublic
+    };
+  }
+  /**
+   * Parses Hawkeye `POST /change-object-access` success JSON
+   * `{ message, name, size, updated, public }`.
+   */
+  parseChangeObjectAccessResponse(raw) {
+    if (typeof raw !== "object" || raw === null) return null;
+    const o = raw;
+    if (typeof o.name !== "string" || typeof o.public !== "boolean") {
+      return null;
+    }
+    const message = typeof o.message === "string" && o.message.length > 0 ? o.message : o.public ? "File has been made publicly accessible." : "File's public access has been revoked, making it private.";
+    const size = o.size === void 0 || o.size === null ? null : String(o.size);
+    const updated = o.updated === void 0 || o.updated === null ? null : String(o.updated);
+    return {
+      message,
+      name: o.name,
+      size,
+      updated,
+      public: o.public
+    };
+  }
+  /** Resolves the list row for a full object path (same folder semantics as download size resolution). */
+  async findFileListItem(filePath, storageType) {
+    const lastSlash = filePath.lastIndexOf("/");
+    const nameOnly = lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1);
+    const folderPrefix = lastSlash === -1 ? "" : filePath.slice(0, lastSlash);
+    const basePath = folderPrefix ? `${folderPrefix}/` : "";
+    const result = await this.list({ basePath, storageType });
+    if (this.isErrorResult(result)) return result;
+    const rows = result.files?.data ?? [];
+    return rows.find(
+      (r) => r.fullPath === filePath || !r.isDirectory && (r.name === nameOnly || r.fullPath === filePath)
+    ) ?? null;
+  }
+  /** Keep only SDK list fields; flatten metadata to `size` / `updatedAt`. */
+  normalizeListItem(raw) {
+    const meta = raw.metadata ?? {};
+    let size;
+    if (meta.size !== void 0 && meta.size !== null) {
+      size = String(meta.size);
+    }
+    const updatedRaw = meta.updated ?? meta.timeUpdated;
+    let updatedAt;
+    if (updatedRaw !== void 0 && updatedRaw !== null) {
+      updatedAt = String(updatedRaw);
+    }
+    const name = raw.name;
+    const parentPath = raw.parentPath;
+    const isDirectory = Boolean(raw.isDirectory);
+    let fullPath;
+    if (!isDirectory && name) {
+      fullPath = parentPath ? `${parentPath}/${name}` : name;
+    }
+    const cdnRaw = raw.cdnUrl;
+    const cdnUrl = cdnRaw === void 0 || cdnRaw === null ? null : cdnRaw;
+    const item = {
+      name,
+      path: raw.path,
+      folderName: raw.folderName,
+      parentPath,
+      isDirectory,
+      isPublic: raw.isPublic,
+      cdnUrl,
+      fullPath
+    };
+    if (size !== void 0) item.size = size;
+    if (updatedAt !== void 0) item.updatedAt = updatedAt;
+    return item;
+  }
+  /** Map wire `shareable_link` to `temporary_sharable_link`. */
+  normalizeUploadData(raw) {
+    const message = String(raw.message ?? "");
+    const path = String(raw.path ?? "");
+    const out = { message, path };
+    const link = raw.temporary_sharable_link ?? raw.shareable_link;
+    if (link !== void 0 && link !== null && String(link) !== "") {
+      out.temporary_sharable_link = String(link);
+    }
+    if (raw.public_url !== void 0 && raw.public_url !== null) {
+      out.public_url = String(raw.public_url);
+    }
+    return out;
+  }
+  normalizeListResponse(data) {
+    const payload = data.files;
+    if (!payload?.data) return data;
+    return {
+      files: {
+        ...payload,
+        data: payload.data.map(
+          (item) => this.normalizeListItem(item)
+        )
+      }
+    };
+  }
+  async list(params = {}) {
+    const endpoint = STORAGE_ENDPOINTS.list;
+    const path = buildStorageEndpointPath(endpoint);
+    const result = await this.requestStorage({
+      url: this.url(path, this.listQuery(params)),
+      method: endpoint.method,
+      headers: this.buildHeaders(),
+      timeout: this.config.timeout
+    });
+    if (this.isErrorResult(result)) return result;
+    return this.normalizeListResponse(result);
+  }
+  async createFolder(body) {
+    const endpoint = STORAGE_ENDPOINTS.directory;
+    const path = buildStorageEndpointPath(endpoint);
+    const q = this.storageTypeQuery(body.storageType);
+    return this.requestStorage({
+      url: this.url(path, q),
+      method: endpoint.method,
+      headers: this.buildHeaders(),
+      data: { folder_path: body.folder_path },
+      timeout: this.config.timeout
+    });
+  }
+  async deleteFile(params) {
+    const endpoint = STORAGE_ENDPOINTS.deleteFile;
+    const path = buildStorageEndpointPath(endpoint);
+    const q = this.storageTypeQuery(params.storageType);
+    q.set("filename", params.filename);
+    const data = {};
+    if (params.filepath !== void 0) {
+      data.filepath = params.filepath;
+    }
+    if (params.totalsize !== void 0) {
+      data.totalsize = params.totalsize;
+    }
+    return this.requestStorage({
+      url: this.url(path, q),
+      method: endpoint.method,
+      headers: this.buildHeaders(),
+      data: Object.keys(data).length ? data : void 0,
+      timeout: this.config.timeout
+    });
+  }
+  /**
+   * `POST /change-object-access` — used by `makePublic` / `makePrivate`.
+   * Preferring API body `{ message, name, size, updated, public }`; otherwise falls back to a parent list.
+   */
+  async setObjectAccess(body) {
+    const endpoint = STORAGE_ENDPOINTS.objectAccess;
+    const path = buildStorageEndpointPath(endpoint);
+    const acl = await this.requestStorage({
+      url: this.url(path),
+      method: endpoint.method,
+      headers: this.buildHeaders(),
+      data: {
+        file_path: body.file_path,
+        public: body.public
+      },
+      timeout: this.config.timeout
+    });
+    if (this.isAclErrorResult(acl)) return acl;
+    const fromApi = this.parseChangeObjectAccessResponse(acl);
+    if (fromApi !== null) {
+      return fromApi;
+    }
+    const row = await this.findFileListItem(body.file_path);
+    if (this.isAclErrorResult(row)) return row;
+    return this.buildObjectAccessSummary(body.file_path, row, body.public);
+  }
+  async upload(params) {
+    const endpoint = STORAGE_ENDPOINTS.upload;
+    const path = buildStorageEndpointPath(endpoint);
+    const q = this.storageTypeQuery(params.storageType);
+    const headers = { ...this.buildHeaders() };
+    delete headers["Content-Type"];
+    const result = await this.requestStorage({
+      url: this.url(path, q),
+      method: endpoint.method,
+      headers,
+      data: this.buildUploadForm(params),
+      timeout: this.config.timeout
+    });
+    if (this.isAclErrorResult(result)) return result;
+    return this.normalizeUploadData(result);
+  }
+  async resolveFileSizeBytes(fileName, storageType) {
+    const lastSlash = fileName.lastIndexOf("/");
+    const nameOnly = lastSlash === -1 ? fileName : fileName.slice(lastSlash + 1);
+    const folderPrefix = lastSlash === -1 ? "" : fileName.slice(0, lastSlash);
+    const basePath = folderPrefix ? `${folderPrefix}/` : "";
+    const result = await this.list({ basePath, storageType });
+    if (this.isErrorResult(result)) {
+      throw new Error(
+        result.error?.message ?? "List failed while resolving file size"
+      );
+    }
+    const rows = result.files?.data ?? [];
+    const hit = rows.find(
+      (r) => r.fullPath === fileName || !r.isDirectory && r.name === nameOnly
+    );
+    const s = hit?.size;
+    if (s === void 0) {
+      throw new Error(
+        `Could not resolve size for "${fileName}". Pass sizeBytes (from list() item size).`
+      );
+    }
+    return Number(s);
+  }
+  /**
+   * Download file bytes via `POST /file-export` (range 0..size-1).
+   */
+  async downloadFile(params) {
+    try {
+      const sizeBytes = params.sizeBytes !== void 0 ? Number(params.sizeBytes) : await this.resolveFileSizeBytes(
+        params.file_name,
+        params.storageType
+      );
+      if (!Number.isFinite(sizeBytes) || sizeBytes <= 0) {
+        throw new Error(
+          "Invalid or unknown file size. Pass sizeBytes from list() item size."
+        );
+      }
+      const endpoint = STORAGE_ENDPOINTS.fileExport;
+      const path = buildStorageEndpointPath(endpoint);
+      const q = this.storageTypeQuery(params.storageType);
+      const response = await this.httpAdapter.request({
+        url: this.url(path, q),
+        method: "POST",
+        headers: { ...this.buildHeaders(), Accept: "*/*" },
+        data: {
+          file_name: params.file_name,
+          start_byte: 0,
+          end_byte: sizeBytes - 1
+        },
+        timeout: this.config.timeout,
+        responseType: "arraybuffer"
+      });
+      if (response.status < 200 || response.status >= 300) {
+        const d = response.data;
+        if (d && typeof d === "object" && d !== null && "error" in d) {
+          return d;
+        }
+        return this.formatErrorResponse(
+          new Error(`Download failed: HTTP ${response.status}`),
+          ERR_PREFIX
+        );
+      }
+      if (!(response.data instanceof ArrayBuffer)) {
+        throw new Error("Expected binary response body");
+      }
+      const headers = response.headers;
+      const ct = headers["content-type"] ?? headers["Content-Type"] ?? void 0;
+      return {
+        bytes: response.data,
+        status: response.status,
+        contentType: ct
+      };
+    } catch (error) {
+      return this.formatErrorResponse(error, ERR_PREFIX);
+    }
+  }
+}
+class StorageResource extends BaseResource {
+  constructor(client) {
+    super(client, "/storage");
+    const config = client.getConfig();
+    this.apiClient = new StorageApiClient(config.apiKey, {
+      environment: config.environment,
+      region: config.region,
+      timeout: config.timeout,
+      debug: config.debug,
+      headers: config.headers
+    });
+  }
+  async list(params = {}) {
+    return this.apiClient.list(params);
+  }
+  /** Direct upload — `POST /upload` (multipart); server persists the object. */
+  async upload(params) {
+    return this.apiClient.upload(params);
+  }
+  async createFolder(params) {
+    return this.apiClient.createFolder(params);
+  }
+  async deleteFile(params) {
+    return this.apiClient.deleteFile(params);
+  }
+  async makePublic(filePath) {
+    return this.apiClient.setObjectAccess({
+      file_path: filePath,
+      public: true
+    });
+  }
+  async makePrivate(filePath) {
+    return this.apiClient.setObjectAccess({
+      file_path: filePath,
+      public: false
+    });
+  }
+  /** Download file bytes via `POST /file-export` (full file). */
+  async downloadFile(params) {
+    return this.apiClient.downloadFile(params);
+  }
+}
 class BolticClient {
   constructor(apiKey, options = {}) {
     this.currentDatabase = null;
@@ -5021,6 +6019,8 @@ class BolticClient {
     this.indexResource = new IndexResource(this.baseClient);
     this.databaseResource = new DatabaseResource(this.baseClient);
     this.workflowResource = new WorkflowResource(this.baseClient);
+    this.serverlessResource = new ServerlessResource(this.baseClient);
+    this.storageResource = new StorageResource(this.baseClient);
     this.currentDatabase = null;
   }
   /**
@@ -5202,6 +6202,58 @@ class BolticClient {
       getIntegrationForm: (params) => this.workflowResource.getIntegrationForm(params)
     };
   }
+  /**
+   * Serverless function operations.
+   *
+   * @example
+   * ```typescript
+   * // List all serverless functions
+   * const list = await client.serverless.list();
+   *
+   * // Create a new serverless function
+   * const fn = await client.serverless.create({
+   *   Name: 'my-api',
+   *   Runtime: 'code',
+   *   CodeOpts: { Language: 'nodejs/20', Code: '...' },
+   *   Resources: { CPU: 0.1, MemoryMB: 128, MemoryMaxMB: 128 },
+   *   Scaling: { AutoStop: false, Min: 1, Max: 1, MaxIdleTime: 0 },
+   * });
+   *
+   * // Get a serverless function by ID
+   * const details = await client.serverless.get('serverless-id');
+   *
+   * // Get builds
+   * const builds = await client.serverless.getBuilds({ appId: 'id' });
+   *
+   * // Get runtime logs
+   * const logs = await client.serverless.getLogs({ appId: 'id' });
+   * ```
+   */
+  get serverless() {
+    return {
+      list: (params) => this.serverlessResource.list(params),
+      get: (appId) => this.serverlessResource.get(appId),
+      create: (params) => this.serverlessResource.create(params),
+      createAndWait: (params) => this.serverlessResource.createAndWait(params),
+      update: (params) => this.serverlessResource.update(params),
+      updateAndWait: (params) => this.serverlessResource.updateAndWait(params),
+      getBuilds: (params) => this.serverlessResource.getBuilds(params),
+      getLogs: (params) => this.serverlessResource.getLogs(params),
+      getBuildLogs: (params) => this.serverlessResource.getBuildLogs(params),
+      pollStatus: (appId, options) => this.serverlessResource.pollStatus(appId, options)
+    };
+  }
+  get storage() {
+    return {
+      list: (params) => this.storageResource.list(params),
+      upload: (params) => this.storageResource.upload(params),
+      createFolder: (params) => this.storageResource.createFolder(params),
+      deleteFile: (params) => this.storageResource.deleteFile(params),
+      makePublic: (filePath) => this.storageResource.makePublic(filePath),
+      makePrivate: (filePath) => this.storageResource.makePrivate(filePath),
+      downloadFile: (params) => this.storageResource.downloadFile(params)
+    };
+  }
   // SQL resource access for testing
   getSqlResource() {
     return this.sqlResource;
@@ -5285,6 +6337,8 @@ class BolticClient {
     this.indexResource = new IndexResource(this.baseClient);
     this.databaseResource = new DatabaseResource(this.baseClient);
     this.workflowResource = new WorkflowResource(this.baseClient);
+    this.serverlessResource = new ServerlessResource(this.baseClient);
+    this.storageResource = new StorageResource(this.baseClient);
   }
   // Security methods to prevent API key exposure
   toString() {
@@ -5312,9 +6366,22 @@ function createClient(apiKey, options = {}) {
 const VERSION = "1.0.0";
 exports.AuthManager = AuthManager$1;
 exports.BolticClient = BolticClient;
+exports.DEFAULT_RESOURCES = DEFAULT_RESOURCES;
+exports.DEFAULT_SCALING = DEFAULT_SCALING;
+exports.DEFAULT_STORAGE_TYPE = DEFAULT_STORAGE_TYPE;
+exports.MAX_SIGNED_URL_EXPIRE_MINUTES = MAX_SIGNED_URL_EXPIRE_MINUTES;
+exports.MAX_STATUS_POLLING_ATTEMPTS = MAX_STATUS_POLLING_ATTEMPTS;
 exports.SERVICE_PATHS = SERVICE_PATHS;
+exports.STATUS_POLLING_INTERVAL_MS = STATUS_POLLING_INTERVAL_MS;
+exports.STORAGE_ENDPOINTS = STORAGE_ENDPOINTS;
+exports.ServerlessApiClient = ServerlessApiClient;
+exports.ServerlessResource = ServerlessResource;
+exports.StorageApiClient = StorageApiClient;
+exports.StorageResource = StorageResource;
+exports.TERMINAL_STATUSES = TERMINAL_STATUSES;
 exports.VERSION = VERSION;
 exports.WorkflowResource = WorkflowResource;
+exports.buildStorageEndpointPath = buildStorageEndpointPath;
 exports.createClient = createClient;
 exports.createErrorWithContext = createErrorWithContext$1;
 exports.formatError = formatError$1;