@boltic/sdk 0.1.4 → 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;
@@ -550,7 +601,8 @@ const SERVICE_PATHS = {
   DATABASES: "/service/sdk/boltic-tables/v1",
   WORKFLOW_TEMPORAL: "/service/panel/temporal/v1.0",
   INTEGRATION: "/service/panel/integration/v1",
-  SERVERLESS: "/service/panel/serverless/v1.0"
+  SERVERLESS: "/service/panel/serverless/v1.0",
+  STORAGE: "/service/panel/storage/v1.0"
 };
 class BaseApiClient {
   constructor(apiKey, config = {}, servicePath = SERVICE_PATHS.DATABASES) {
@@ -4077,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
       });
@@ -4108,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
       });
@@ -5478,6 +5536,466 @@ class ServerlessResource extends BaseResource {
     };
   }
 }
+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;
@@ -5502,6 +6020,7 @@ class BolticClient {
     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;
   }
   /**
@@ -5724,6 +6243,17 @@ class BolticClient {
       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;
@@ -5808,6 +6338,7 @@ class BolticClient {
     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() {
@@ -5837,14 +6368,20 @@ 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;