@boltic/sdk 0.1.3 → 0.1.5

package/dist/types/index.d.ts

@@ -172,6 +172,8 @@ export declare class BolticClient {
     private indexResource;
     private databaseResource;
     private workflowResource;
+    private serverlessResource;
+    private storageResource;
     private currentDatabase;
     private clientOptions;
     constructor(apiKey: string, options?: ClientOptions);
@@ -311,6 +313,59 @@ export declare class BolticClient {
         getIntegrationResource: (params: GetIntegrationResourceParams) => Promise<BolticErrorResponse | BolticSuccessResponse<IntegrationResourceData>>;
         getIntegrationForm: (params: GetIntegrationFormParams) => Promise<BolticErrorResponse | BolticSuccessResponse<Record<string, unknown> | IntegrationFormJsonSchema>>;
     };
+    /**
+     * 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(): {
+        list: (params?: ListServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ListServerlessData>>;
+        get: (appId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        create: (params: CreateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        createAndWait: (params: CreateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        update: (params: UpdateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        updateAndWait: (params: UpdateServerlessParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+        getBuilds: (params: GetBuildsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetBuildsData>>;
+        getLogs: (params: GetLogsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetLogsData>>;
+        getBuildLogs: (params: GetBuildLogsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<GetBuildLogsData>>;
+        pollStatus: (appId: string, options?: {
+            intervalMs?: number;
+            maxAttempts?: number;
+        }) => Promise<BolticErrorResponse | BolticSuccessResponse<ServerlessData>>;
+    };
+    get storage(): {
+        list: (params?: ListStorageParams) => Promise<BolticErrorResponse | ListStorageData>;
+        upload: (params: UploadParams) => Promise<BolticErrorResponse | UploadData>;
+        createFolder: (params: CreateFolderParams) => Promise<BolticErrorResponse | CreateFolderData>;
+        deleteFile: (params: DeleteFileParams) => Promise<BolticErrorResponse | {
+            message: unknown;
+        }>;
+        makePublic: (filePath: string) => Promise<BolticErrorResponse | ObjectAccessSummary>;
+        makePrivate: (filePath: string) => Promise<BolticErrorResponse | ObjectAccessSummary>;
+        downloadFile: (params: DownloadFileParams) => Promise<BolticErrorResponse | DownloadFileData>;
+    };
     getSqlResource(): SqlResource;
     updateApiKey(newApiKey: string): void;
     updateConfig(updates: Partial<ClientConfig>): void;
@@ -371,6 +426,15 @@ export declare interface BolticSuccessResponse<T> {
     };
 }
 
+export declare function buildStorageEndpointPath(endpoint: StorageApiEndpoint): string;
+
+export declare interface ChangeObjectAccessParams {
+    /** Full file path in bucket */
+    file_path: string;
+    /** `true` = public, `false` = private */
+    public: boolean;
+}
+
 export declare interface ClientConfig extends EnvironmentConfig {
     apiKey: string;
     environment: Environment;
@@ -482,6 +546,32 @@ export declare function createClient(apiKey: string, options?: ClientOptions): B
  */
 export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
 
+export declare interface CreateFolderData {
+    message: string;
+}
+
+export declare interface CreateFolderParams {
+    storageType?: string;
+    /** Target folder path (`folder_path` body field). */
+    folder_path: string;
+}
+
+export declare type CreateServerlessData = ServerlessData;
+
+export declare interface CreateServerlessParams {
+    Name: string;
+    Description?: string;
+    Runtime: ServerlessRuntime;
+    Env?: Record<string, string>;
+    PortMap?: ServerlessPortMap[];
+    Scaling?: ServerlessScaling;
+    Resources?: ServerlessResources;
+    Timeout?: number;
+    Validations?: unknown;
+    CodeOpts?: ServerlessCodeOpts;
+    ContainerOpts?: ServerlessContainerOpts;
+}
+
 /** Data returned from the get-credentials API */
 export declare type CredentialsListData = Record<string, unknown>;
 
@@ -623,10 +713,60 @@ declare const DateFormatEnum: Readonly<{
 
 declare type DecimalType = '00' | '0.0' | '0.00' | '0.000' | '0.0000' | '0.00000' | '0.000000';
 
+/** Default resource allocation for new serverless functions */
+export declare const DEFAULT_RESOURCES: {
+    readonly CPU: 0.1;
+    readonly MemoryMB: 128;
+    readonly MemoryMaxMB: 128;
+};
+
+/** Default scaling configuration for new serverless functions */
+export declare const DEFAULT_SCALING: {
+    readonly AutoStop: false;
+    readonly Min: 1;
+    readonly Max: 1;
+    readonly MaxIdleTime: 0;
+};
+
+/** Default backend storage driver (GCS). */
+export declare const DEFAULT_STORAGE_TYPE: "gcs";
+
+export declare interface DeleteFileData {
+    message: unknown;
+}
+
+export declare interface DeleteFileParams {
+    storageType?: string;
+    /** Full object path in bucket */
+    filename: string;
+    /** Optional metering payload (Zenith sends `totalsize`). */
+    filepath?: string;
+    totalsize?: number;
+}
+
 declare interface DeleteIndexResponse {
     message?: string;
 }
 
+export declare interface DownloadFileData {
+    bytes: ArrayBuffer;
+    /** Usually 206 Partial Content for range responses. */
+    status: number;
+    contentType?: string;
+}
+
+/** `POST /file-export` — byte range download; SDK requests full file by default. */
+export declare interface DownloadFileParams {
+    storageType?: string;
+    /** Full object path in bucket (same as list `fullPath` / delete `filename`). */
+    file_name: string;
+    /**
+     * Size in bytes from `list()` item `size`. If omitted, the SDK lists the parent folder
+     * and matches by `fullPath` / `name`.
+     */
+    sizeBytes?: number | string;
+}
+
 export declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
 
 export declare interface EnvironmentConfig {
@@ -755,6 +895,26 @@ export declare interface FormField {
     };
 }
 
+export declare type GetBuildLogsData = ServerlessBuildLogEntry[];
+
+export declare interface GetBuildLogsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** The build ID. */
+    buildId: string;
+}
+
+export declare type GetBuildsData = ServerlessBuild[];
+
+export declare interface GetBuildsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 20 */
+    limit?: number;
+}
+
 /** Parameters accepted by `workflow.getCredentials()`. */
 export declare interface GetCredentialsParams {
     /** Integration name (e.g. "freshsales"). Automatically uppercased by the SDK. */
@@ -823,6 +983,30 @@ export declare interface GetIntegrationsParams {
     per_page?: number;
 }
 
+export declare type GetLogsData = ServerlessLogEntry[];
+
+export declare interface GetLogsParams {
+    /** The serverless function ID. */
+    appId: string;
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 50 */
+    limit?: number;
+    /** Sort direction. @defaultValue 'DESC' */
+    sortOrder?: 'ASC' | 'DESC';
+    /** Unix epoch start (seconds). Defaults to 24h ago. */
+    timestampStart?: number;
+    /** Unix epoch end (seconds). Defaults to now. */
+    timestampEnd?: number;
+}
+
+export declare type GetServerlessData = ServerlessData;
+
+export declare interface GetServerlessParams {
+    /** The serverless function ID. */
+    appId: string;
+}
+
 declare interface HttpAdapter {
     request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
 }
@@ -835,6 +1019,11 @@ declare interface HttpRequestConfig {
     data?: unknown;
     timeout?: number;
     signal?: AbortSignal;
+    /**
+     * Opt-in only. When unset (default), JSON/text parsing is unchanged for all services.
+     * Storage `downloadFile` sets `arraybuffer` for binary bodies.
+     */
+    responseType?: 'arraybuffer';
 }
 
 declare interface HttpResponse<T = unknown> {
@@ -947,6 +1136,54 @@ declare interface ListIndexesResponse {
     };
 }
 
+export declare type ListServerlessData = ServerlessData[];
+
+export declare interface ListServerlessParams {
+    /** Page number (1-based). @defaultValue 1 */
+    page?: number;
+    /** Items per page. @defaultValue 20 */
+    limit?: number;
+    /** Field to sort by. @defaultValue 'CreatedAt' */
+    sortBy?: string;
+    /** Sort direction. @defaultValue 'desc' */
+    sortOrder?: 'asc' | 'desc';
+    /** Search query string to filter by name. */
+    query?: string;
+}
+
+export declare interface ListStorageData {
+    files: StorageListFilesPayload;
+}
+
+/** List query — forwarded to backend object listing. */
+export declare interface ListStorageParams {
+    storageType?: string;
+    /** Folder prefix to list under */
+    basePath?: string;
+    pageSize?: number | string;
+    nextPageToken?: string;
+}
+
+/**
+ * `expire_in` for upload temporary read URLs is **minutes**.
+ * Backend caps TTL to 7 days.
+ */
+export declare const MAX_SIGNED_URL_EXPIRE_MINUTES: number;
+
+/** Maximum number of status polling attempts before timeout */
+export declare const MAX_STATUS_POLLING_ATTEMPTS = 60;
+
+/** Returned by `makePublic` / `makePrivate` — matches `POST /change-object-access` success body. */
+export declare interface ObjectAccessSummary {
+    /** Human-readable status from the API. */
+    message: string;
+    /** Full object path in the bucket. */
+    name: string;
+    size: string | null;
+    updated: string | null;
+    public: boolean;
+}
+
 export declare interface PaginationInfo {
     total_count: number;
     total_pages: number;
@@ -1223,11 +1460,314 @@ export declare interface RetryConfig {
     maximum_interval: number;
 }
 
+export declare class ServerlessApiClient extends BaseApiClient {
+    constructor(apiKey: string, config?: Omit<BaseApiClientConfig, 'apiKey'>);
+    /**
+     * List all serverless functions with optional pagination and search.
+     */
+    list(params?: ListServerlessParams): Promise<ServerlessResponse<ListServerlessData>>;
+    /**
+     * Get a serverless function by its ID.
+     */
+    get(appId: string): Promise<ServerlessResponse<GetServerlessData>>;
+    /**
+     * Create a new serverless function.
+     */
+    create(payload: CreateServerlessParams): Promise<ServerlessResponse<CreateServerlessData>>;
+    /**
+     * Update an existing serverless function.
+     */
+    update(params: UpdateServerlessParams): Promise<ServerlessResponse<UpdateServerlessData>>;
+    /**
+     * List builds for a serverless function.
+     */
+    getBuilds(params: GetBuildsParams): Promise<ServerlessResponse<GetBuildsData>>;
+    /**
+     * Get runtime logs for a serverless function.
+     */
+    getLogs(params: GetLogsParams): Promise<ServerlessResponse<GetLogsData>>;
+    /**
+     * Get build logs for a specific build of a serverless function.
+     */
+    getBuildLogs(params: GetBuildLogsParams): Promise<ServerlessResponse<GetBuildLogsData>>;
+}
+
+export declare interface ServerlessApiEndpoint {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    authenticated: boolean;
+}
+
+export declare interface ServerlessAppDomain {
+    DomainName: string;
+    BaseUrl?: string;
+}
+
+export declare interface ServerlessBuild {
+    ID: string;
+    Version?: number;
+    Status?: string;
+    StatusHistory?: ServerlessBuildStatusEntry[];
+    CreatedAt?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessBuildLogEntry {
+    Log?: string;
+    Timestamp?: number;
+    Message?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessBuildStatusEntry {
+    Status: string;
+    Timestamp?: string;
+}
+
+export declare interface ServerlessCodeOpts {
+    Language: string;
+    Packages?: string[];
+    Code?: string;
+}
+
+export declare interface ServerlessConfig {
+    Name: string;
+    Description?: string;
+    Runtime: ServerlessRuntime;
+    Env?: Record<string, string>;
+    PortMap?: ServerlessPortMap[];
+    Scaling?: ServerlessScaling;
+    Resources?: ServerlessResources;
+    Timeout?: number;
+    Validations?: unknown;
+    CodeOpts?: ServerlessCodeOpts;
+    ContainerOpts?: ServerlessContainerOpts;
+}
+
+export declare interface ServerlessContainerOpts {
+    Image: string;
+    Args?: string[];
+    Command?: string;
+}
+
+export declare interface ServerlessData {
+    ID: string;
+    ParentID?: string;
+    Status: ServerlessStatus;
+    Config: ServerlessConfig;
+    Links?: {
+        Git?: {
+            Repository?: ServerlessGitRepository;
+        };
+    };
+    AppDomain?: ServerlessAppDomain[];
+    RegionID?: string;
+    CreatedAt?: string;
+    UpdatedAt?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessGitRepository {
+    SshURL?: string;
+    HtmlURL?: string;
+    CloneURL?: string;
+}
+
+export declare interface ServerlessLogEntry {
+    Timestamp?: number;
+    Severity?: string;
+    Log?: string;
+    [key: string]: unknown;
+}
+
+export declare interface ServerlessPortMap {
+    ContainerPort?: number;
+    HostPort?: number;
+    Protocol?: string;
+}
+
+export declare class ServerlessResource extends BaseResource {
+    private apiClient;
+    constructor(client: BaseClient);
+    /**
+     * 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 });
+     * ```
+     */
+    list(params?: ListServerlessParams): Promise<BolticSuccessResponse<ListServerlessData> | BolticErrorResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    get(appId: string): Promise<BolticSuccessResponse<GetServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 = ...' },
+     * });
+     * ```
+     */
+    create(params: CreateServerlessParams): Promise<BolticSuccessResponse<CreateServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 },
+     * });
+     * ```
+     */
+    createAndWait(params: CreateServerlessParams): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+    /**
+     * 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 } },
+     * });
+     * ```
+     */
+    update(params: UpdateServerlessParams): Promise<BolticSuccessResponse<UpdateServerlessData> | BolticErrorResponse>;
+    /**
+     * 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
+     */
+    updateAndWait(params: UpdateServerlessParams): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+    /**
+     * 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' });
+     * ```
+     */
+    getBuilds(params: GetBuildsParams): Promise<BolticSuccessResponse<GetBuildsData> | BolticErrorResponse>;
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    getLogs(params: GetLogsParams): Promise<BolticSuccessResponse<GetLogsData> | BolticErrorResponse>;
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    getBuildLogs(params: GetBuildLogsParams): Promise<BolticSuccessResponse<GetBuildLogsData> | BolticErrorResponse>;
+    /**
+     * 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');
+     * ```
+     */
+    pollStatus(appId: string, options?: {
+        intervalMs?: number;
+        maxAttempts?: number;
+    }): Promise<BolticSuccessResponse<ServerlessData> | BolticErrorResponse>;
+}
+
+export declare interface ServerlessResources {
+    CPU: number;
+    MemoryMB: number;
+    MemoryMaxMB: number;
+}
+
+declare type ServerlessResponse<T> = BolticSuccessResponse<T> | BolticErrorResponse;
+
+export declare type ServerlessRuntime = 'code' | 'git' | 'container';
+
+export declare interface ServerlessScaling {
+    AutoStop: boolean;
+    Min: number;
+    Max: number;
+    MaxIdleTime: number;
+}
+
+export declare type ServerlessStatus = 'running' | 'draft' | 'building' | 'pending' | 'stopped' | 'failed' | 'degraded' | 'suspended';
+
 /** Well-known service paths used across the SDK */
 export declare const SERVICE_PATHS: {
     readonly DATABASES: "/service/sdk/boltic-tables/v1";
     readonly WORKFLOW_TEMPORAL: "/service/panel/temporal/v1.0";
     readonly INTEGRATION: "/service/panel/integration/v1";
+    readonly SERVERLESS: "/service/panel/serverless/v1.0";
+    readonly STORAGE: "/service/panel/storage/v1.0";
 };
 
 export declare interface ServiceAuthConfig extends AuthConfig_2 {
@@ -1266,6 +1806,126 @@ declare class SqlResource {
     executeSQL(query: string, dbId?: string): Promise<ExecuteSQLApiResponse | BolticErrorResponse>;
 }
 
+/** Polling interval in milliseconds between status checks */
+export declare const STATUS_POLLING_INTERVAL_MS = 5000;
+
+export declare const STORAGE_ENDPOINTS: StorageEndpoints;
+
+export declare class StorageApiClient extends BaseApiClient {
+    constructor(apiKey: string, config?: Omit<BaseApiClientConfig, 'apiKey'>);
+    /** Shared try/catch + http — same idea as inlined blocks in serverless/workflow clients, but DRY for storage. */
+    private requestStorage;
+    private url;
+    private storageTypeQuery;
+    private listQuery;
+    /** `expire_in` is minutes; clamp to max temporary URL lifetime (7 days). */
+    private normalizeExpireInMinutes;
+    private isTruthyFormFlag;
+    /**
+     * `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.
+     */
+    private appendUploadVisibility;
+    private buildUploadForm;
+    private isErrorResult;
+    private isAclErrorResult;
+    private buildObjectAccessSummary;
+    /**
+     * Parses Hawkeye `POST /change-object-access` success JSON
+     * `{ message, name, size, updated, public }`.
+     */
+    private parseChangeObjectAccessResponse;
+    /** Resolves the list row for a full object path (same folder semantics as download size resolution). */
+    private findFileListItem;
+    /** Keep only SDK list fields; flatten metadata to `size` / `updatedAt`. */
+    private normalizeListItem;
+    /** Map wire `shareable_link` to `temporary_sharable_link`. */
+    private normalizeUploadData;
+    private normalizeListResponse;
+    list(params?: ListStorageParams): Promise<StorageResult_2<ListStorageData>>;
+    createFolder(body: CreateFolderParams): Promise<StorageResult_2<CreateFolderData>>;
+    deleteFile(params: DeleteFileParams): Promise<StorageResult_2<{
+        message: unknown;
+    }>>;
+    /**
+     * `POST /change-object-access` — used by `makePublic` / `makePrivate`.
+     * Preferring API body `{ message, name, size, updated, public }`; otherwise falls back to a parent list.
+     */
+    setObjectAccess(body: ChangeObjectAccessParams): Promise<StorageResult_2<ObjectAccessSummary>>;
+    upload(params: UploadParams): Promise<StorageResult_2<UploadData>>;
+    private resolveFileSizeBytes;
+    /**
+     * Download file bytes via `POST /file-export` (range 0..size-1).
+     */
+    downloadFile(params: DownloadFileParams): Promise<StorageResult_2<DownloadFileData>>;
+}
+
+export declare type StorageApiEndpoint = {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    authenticated: boolean;
+};
+
+declare interface StorageEndpoints {
+    list: StorageApiEndpoint;
+    upload: StorageApiEndpoint;
+    directory: StorageApiEndpoint;
+    deleteFile: StorageApiEndpoint;
+    objectAccess: StorageApiEndpoint;
+    /** Range download (`POST /file-export`). */
+    fileExport: StorageApiEndpoint;
+}
+
+/** Response shape from `GET .../list` — `{ files: listResult }`. */
+export declare interface StorageListFilesPayload {
+    data?: StorageListItem[];
+    next_page_token?: string;
+    totalCount?: number;
+}
+
+/**
+ * List row — only these fields are returned (size / `updatedAt` flattened from object metadata).
+ */
+export declare interface StorageListItem {
+    name?: string;
+    path?: string;
+    folderName?: string;
+    parentPath?: string;
+    isDirectory?: boolean;
+    isPublic?: boolean;
+    cdnUrl?: string | null;
+    /** Full object path in the bucket: `parentPath/name` for files, when derivable. */
+    fullPath?: string;
+    /** Byte size as string (from object metadata). */
+    size?: string;
+    /** Last update time (from `updated` / `timeUpdated` in raw metadata). */
+    updatedAt?: string;
+}
+
+export declare class StorageResource extends BaseResource {
+    private apiClient;
+    constructor(client: BaseClient);
+    list(params?: ListStorageParams): Promise<StorageResult<ListStorageData>>;
+    /** Direct upload — `POST /upload` (multipart); server persists the object. */
+    upload(params: UploadParams): Promise<StorageResult<UploadData>>;
+    createFolder(params: CreateFolderParams): Promise<StorageResult<CreateFolderData>>;
+    deleteFile(params: DeleteFileParams): Promise<StorageResult<{
+        message: unknown;
+    }>>;
+    makePublic(filePath: string): Promise<StorageResult<ObjectAccessSummary>>;
+    makePrivate(filePath: string): Promise<StorageResult<ObjectAccessSummary>>;
+    /** Download file bytes via `POST /file-export` (full file). */
+    downloadFile(params: DownloadFileParams): Promise<StorageResult<DownloadFileData>>;
+}
+
+export declare type StorageResponse<T> = StorageSuccess<T> | BolticErrorResponse;
+
+declare type StorageResult<T> = StorageResponse<T>;
+
+declare type StorageResult_2<T> = T | BolticErrorResponse;
+
+declare type StorageSuccess<T> = T;
+
 /**
  * Table Builder - provides a fluent interface for creating tables
  */
@@ -1541,6 +2201,9 @@ declare interface TableUpdateRequest {
     fields?: Array<keyof TableRecord>;
 }
 
+/** Serverless statuses that indicate the function has reached a terminal state */
+export declare const TERMINAL_STATUSES: readonly ["running", "failed", "degraded", "suspended"];
+
 declare interface TextToSQLOptions {
     currentQuery?: string;
 }
@@ -1584,6 +2247,67 @@ export declare function transformFormToDefaults(fields: FormField[], skipFields?
  */
 export declare function transformFormToJsonSchema(fields: FormField[], skipFields?: Set<string>): IntegrationFormJsonSchema;
 
+export declare type UpdateServerlessData = ServerlessData;
+
+export declare interface UpdateServerlessParams {
+    /** The serverless function ID to update. */
+    appId: string;
+    /** The update payload — partial config fields to update. */
+    payload: Partial<CreateServerlessParams>;
+}
+
+export declare interface UploadData {
+    message: string;
+    path: string;
+    /** Temporary signed read URL (mapped from API `shareable_link` when present). */
+    temporary_sharable_link?: string;
+    public_url?: string;
+}
+
+/**
+ * Shared multipart fields for `POST /upload` (direct upload handler).
+ *
+ * **Preferred — `public` (mapped by the SDK):**
+ * - Omitted or `false` → private upload.
+ * - `true` **without** `expire_in` → permanent public (CDN-style `public_url`); sends `is_public_permanent`, not time-limited signed upload.
+ * - `true` **with** `expire_in` → temporary signed read URL (`temporary_sharable_link` on upload response). `expire_in` is **minutes**, max 7 days (SDK clamps to `MAX_SIGNED_URL_EXPIRE_MINUTES`).
+ *
+ * If **`public` is set** (including `false`), it takes precedence over `is_public` / `is_public_permanent` for the wire shape.
+ *
+ * **Legacy (omit `public`):** set `is_public` / `is_public_permanent` / `expire_in` directly as the backend expects.
+ */
+export declare interface UploadMultipartFields {
+    storageType?: string;
+    file: Blob;
+    filepath?: string;
+    overwrite?: boolean | string;
+    /**
+     * High-level visibility. See interface JSDoc. When present, controls how `is_public` / `is_public_permanent` / `expire_in` are sent.
+     */
+    public?: boolean | string;
+    /** @deprecated Prefer `public` unless you need raw backend fields. */
+    is_public?: boolean | string;
+    /**
+     * Signed URL lifetime in **minutes** when using `public: true` (temporary) or legacy `is_public: true`.
+     * Capped at 7 days; the SDK clamps to `MAX_SIGNED_URL_EXPIRE_MINUTES`.
+     */
+    expire_in?: number | string;
+    /** @deprecated Prefer `public: true` without `expire_in` unless you need raw backend fields. */
+    is_public_permanent?: boolean | string;
+}
+
+/**
+ * Direct upload — `POST /upload` (multipart). The handler reads `req.body.filename` (not `file_name`).
+ * Multer: `file` field. Path: `filepath` + `filename`.
+ */
+export declare type UploadParams = UploadMultipartFields & ({
+    filename: string;
+    file_name?: string;
+} | {
+    file_name: string;
+    filename?: string;
+});
+
 export declare const VERSION = "1.0.0";
 
 export declare interface WhereCondition {