@boltic/sdk 0.1.2 → 0.1.4

package/dist/types/index.d.ts

@@ -1,3 +1,21 @@
+/** A single activity node in the execute request body */
+export declare interface ActivityNode {
+    data: {
+        type: string;
+        name: string;
+        properties: ActivityProperties;
+    };
+}
+
+/** Properties describing the activity to execute (dynamic, varies by integration) */
+export declare type ActivityProperties = Record<string, unknown>;
+
+/** Result/context payload sent alongside activity nodes */
+export declare interface ActivityResultPayload {
+    payload: Record<string, unknown>;
+    global_variables: Record<string, unknown>;
+}
+
 declare interface AddIndexRequest {
     field_names: string[];
     method: 'btree' | 'hash' | 'spgist' | 'gin' | 'brin';
@@ -39,44 +57,79 @@ declare interface AuthConfig_2 {
 
 export declare interface AuthHeaders {
     'x-boltic-token': string;
-    'x-boltic-service'?: string;
-    [key: string]: string | undefined;
+    [key: string]: string;
 }
 
 declare interface AuthHeaders_2 {
     'x-boltic-token': string;
-    [key: string]: string;
+    'x-boltic-service'?: string;
+    [key: string]: string | undefined;
 }
 
 export declare class AuthManager {
     private config;
     private tokenInfo;
-    constructor(config: AuthConfig);
+    constructor(config: AuthConfig_2);
     private validateApiKey;
-    getAuthHeaders(): AuthHeaders;
+    getAuthHeaders(): AuthHeaders_2;
     updateApiKey(newApiKey: string): void;
     isAuthenticated(): boolean;
     validateApiKeyAsync(): Promise<boolean>;
-    getTokenInfo(): TokenInfo | null;
-    getServiceHeaders(service?: string): AuthHeaders;
+    getTokenInfo(): TokenInfo_2 | null;
+    getServiceHeaders(service?: string): AuthHeaders_2;
     validateForService(): Promise<boolean>;
 }
 
 declare class AuthManager_2 {
     private config;
     private tokenInfo;
-    constructor(config: AuthConfig_2);
+    constructor(config: AuthConfig);
     private validateApiKey;
-    getAuthHeaders(): AuthHeaders_2;
+    getAuthHeaders(): AuthHeaders;
     updateApiKey(newApiKey: string): void;
     isAuthenticated(): boolean;
     validateApiKeyAsync(): Promise<boolean>;
-    getTokenInfo(): TokenInfo_2 | null;
+    getTokenInfo(): TokenInfo | null;
     getMaxRetries(): number;
     toString(): string;
     toJSON(): object;
 }
 
+/**
+ * Base API Client — provides common functionality for all API clients.
+ *
+ * Subclasses pass a `servicePath` to target different backend services
+ * while sharing auth, headers, error handling, and HTTP infrastructure.
+ */
+declare abstract class BaseApiClient {
+    protected httpAdapter: HttpAdapter;
+    protected config: BaseApiClientConfig;
+    protected baseURL: string;
+    protected environment: Environment;
+    protected region: Region;
+    constructor(apiKey: string, config?: Omit<BaseApiClientConfig, 'apiKey'>, servicePath?: string);
+    /**
+     * Resolve a secondary service URL using the same region/environment
+     * but a different service path.
+     */
+    protected resolveAdditionalServiceURL(servicePath: string): string;
+    protected buildHeaders(): Record<string, string>;
+    protected formatErrorResponse(error: unknown, prefix?: string): BolticErrorResponse;
+    toString(): string;
+    toJSON(): object;
+}
+
+export declare interface BaseApiClientConfig {
+    apiKey: string;
+    environment?: Environment;
+    region?: Region;
+    timeout?: number;
+    debug?: boolean;
+    retryAttempts?: number;
+    retryDelay?: number;
+    headers?: Record<string, string>;
+}
+
 declare class BaseClient {
     private httpAdapter;
     private authManager;
@@ -96,6 +149,18 @@ declare class BaseClient {
     getConfig(): ClientConfig;
 }
 
+declare abstract class BaseResource {
+    protected client: BaseClient;
+    protected basePath: string;
+    constructor(client: BaseClient, basePath: string);
+    getBasePath(): string;
+    protected makeRequest<T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, data?: unknown, options?: {
+        params?: Record<string, unknown>;
+    }): Promise<ApiResponse<T>>;
+    protected buildQueryParams(options?: QueryOptions): Record<string, unknown>;
+    protected handleResponse<T>(response: ApiResponse<T>): ApiResponse<T>;
+}
+
 export declare class BolticClient {
     private configManager;
     private authManager;
@@ -106,6 +171,8 @@ export declare class BolticClient {
     private sqlResource;
     private indexResource;
     private databaseResource;
+    private workflowResource;
+    private serverlessResource;
     private currentDatabase;
     private clientOptions;
     constructor(apiKey: string, options?: ClientOptions);
@@ -183,7 +250,7 @@ export declare class BolticClient {
             insert: (data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
             insertMany: (records: RecordData[], options?: {
                 validation?: boolean;
-            }) => Promise<RecordBulkInsertResponse | BolticErrorResponse>;
+            }) => Promise<BolticErrorResponse | RecordBulkInsertResponse>;
             findOne: (recordId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
             update: (options: RecordUpdateOptions) => Promise<BolticErrorResponse | BolticListResponse<RecordWithId>>;
             updateById: (recordId: string, data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
@@ -199,7 +266,7 @@ export declare class BolticClient {
         insert: (tableName: string, data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
         insertMany: (tableName: string, records: RecordData[], options?: {
             validation?: boolean;
-        }) => Promise<RecordBulkInsertResponse | BolticErrorResponse>;
+        }) => Promise<BolticErrorResponse | RecordBulkInsertResponse>;
         findAll: (tableName: string, options?: RecordQueryOptions) => Promise<BolticErrorResponse | BolticListResponse<RecordWithId>>;
         findOne: (tableName: string, recordId: string, options?: {
             show_decrypted?: boolean;
@@ -220,6 +287,73 @@ export declare class BolticClient {
         textToSQL: (prompt: string, options?: TextToSQLOptions) => Promise<AsyncIterable<string>>;
         executeSQL: (query: string) => Promise<BolticErrorResponse | ExecuteSQLApiResponse>;
     };
+    /**
+     * Workflow integration operations.
+     *
+     * @example
+     * ```typescript
+     * // Execute and poll for result
+     * const result = await client.workflow.executeIntegration({
+     *   nodes: [{ id: 'api1', data: { ... }, activity_data: { ... } }],
+     * });
+     *
+     * // Get execution result by ID
+     * const exec = await client.workflow.getIntegrationExecuteById('run-uuid');
+     *
+     * // List integrations
+     * const integrations = await client.workflow.getIntegrations();
+     * ```
+     */
+    get workflow(): {
+        executeIntegration: (params: ExecuteIntegrationParams) => Promise<BolticErrorResponse | BolticSuccessResponse<ExecuteActivityResponseData | IntegrationExecutionData>>;
+        getIntegrationExecuteById: (executionId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<IntegrationExecutionData>>;
+        getIntegrations: (params?: GetIntegrationsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<IntegrationsListData>>;
+        getCredentials: (params: GetCredentialsParams) => Promise<BolticErrorResponse | BolticSuccessResponse<CredentialsListData>>;
+        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>>;
+    };
     getSqlResource(): SqlResource;
     updateApiKey(newApiKey: string): void;
     updateConfig(updates: Partial<ClientConfig>): void;
@@ -253,15 +387,6 @@ export declare interface BolticErrorResponse {
     };
 }
 
-declare interface BolticErrorResponse_2 {
-    data?: never;
-    error: {
-        code?: string;
-        message?: string;
-        meta?: string[];
-    };
-}
-
 export declare interface BolticListResponse<T> {
     data: T[];
     pagination?: {
@@ -279,18 +404,6 @@ export declare interface BolticListResponse<T> {
     };
 }
 
-declare interface BolticListResponse_2<T = unknown> {
-    data: T[];
-    pagination?: {
-        total_count: number;
-        total_pages: number;
-        current_page: number;
-        per_page: number;
-        type: string;
-    };
-    message?: string;
-}
-
 export declare interface BolticSuccessResponse<T> {
     data: T;
     message?: string;
@@ -301,12 +414,7 @@ export declare interface BolticSuccessResponse<T> {
     };
 }
 
-declare interface BolticSuccessResponse_2<T = unknown> {
-    data: T;
-    message?: string;
-}
-
-declare interface ClientConfig extends EnvironmentConfig {
+export declare interface ClientConfig extends EnvironmentConfig {
     apiKey: string;
     environment: Environment;
     region: Region;
@@ -417,6 +525,25 @@ export declare function createClient(apiKey: string, options?: ClientOptions): B
  */
 export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
 
+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>;
+
 declare interface DatabaseContext {
     databaseId?: string;
     dbInternalName?: string;
@@ -555,13 +682,28 @@ 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;
+};
+
 declare interface DeleteIndexResponse {
     message?: string;
 }
 
-declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
+export declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
 
-declare interface EnvironmentConfig {
+export declare interface EnvironmentConfig {
     baseURL: string;
     timeout: number;
     retryAttempts?: number;
@@ -570,6 +712,38 @@ declare interface EnvironmentConfig {
 
 declare type ErrorInterceptor = (error: unknown) => unknown | Promise<unknown>;
 
+/** Data returned from the execute-activity API */
+export declare interface ExecuteActivityResponseData {
+    execution_id: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Parameters accepted by `workflow.executeIntegration()`.
+ *
+ * @remarks
+ * When `executeOnly` is `false` (default), the SDK will poll
+ * `getIntegrationExecuteById` until the execution reaches a terminal state.
+ */
+export declare interface ExecuteIntegrationParams {
+    /**
+     * If `true`, return immediately after the execute call without polling.
+     * @defaultValue false
+     */
+    executeOnly?: boolean;
+    /** Activity data describing what to execute. The SDK wraps this into the `nodes[]` structure the API expects. */
+    data: {
+        type: string;
+        name: string;
+        properties: ActivityProperties;
+    };
+    /**
+     * Result/context payload for the execute request.
+     * Falls back to a sensible default when omitted.
+     */
+    result?: ActivityResultPayload;
+}
+
 declare interface ExecuteSQLApiResponse {
     data: Record<string, unknown>[];
     count?: number;
@@ -631,11 +805,146 @@ declare interface FilterParams {
  */
 export declare function formatError(error: unknown): string;
 
+/** A single field in the integration form response */
+export declare interface FormField {
+    name: string;
+    meta: {
+        displayType?: string;
+        value?: unknown;
+        validation?: {
+            required?: boolean;
+            [key: string]: unknown;
+        };
+        options?: Array<{
+            label: string;
+            value: string;
+        }>;
+        description?: string;
+        placeholder?: string;
+        displayName?: string;
+        config?: Record<string, unknown>;
+        htmlProps?: Record<string, unknown>;
+        dependencies?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+
+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. */
+    entity: string;
+    /**
+     * Current page number for pagination.
+     * @defaultValue 1
+     */
+    current_page?: number;
+    /**
+     * Number of items per page.
+     * @defaultValue 999
+     */
+    page_size?: number;
+}
+
 /**
  * Extracts HTTP status code from axios or fetch errors
  */
 export declare function getHttpStatusCode(error: unknown): number | null;
 
+/** Parameters accepted by `workflow.getIntegrationForm()`. */
+export declare interface GetIntegrationFormParams {
+    /** Integration slug identifier (e.g. "blt-int.asana"). */
+    integration_slug: string;
+    /** Resource type (e.g. "project", "task"). */
+    resource: string;
+    /** Operation type (e.g. "create", "update", "read"). */
+    operation: string;
+    /** Credential secret for the integration. */
+    secret: string;
+    /**
+     * When `true`, returns only the form schema without executing.
+     * @defaultValue true
+     */
+    getFormOnly?: boolean;
+    /**
+     * When `true`, the response `data` is returned as a JSON Schema object
+     * describing the expected input shape (type, required, default, enum).
+     *
+     * When `false` or omitted, the response `data` is a flat JSON object
+     * with default/fallback values for each field.
+     *
+     * @defaultValue false
+     */
+    asJsonSchema?: boolean;
+}
+
+/** Parameters accepted by `workflow.getIntegrationResource()`. */
+export declare interface GetIntegrationResourceParams {
+    /** Integration slug identifier (e.g. "blt-int.asana"). */
+    integration_slug: string;
+}
+
+/** Parameters accepted by `workflow.getIntegrations()`. */
+export declare interface GetIntegrationsParams {
+    /**
+     * Page number for pagination.
+     * @defaultValue 1
+     */
+    page?: number;
+    /**
+     * Number of items per page.
+     * @defaultValue 999
+     */
+    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>>;
+}
+
 declare interface HttpRequestConfig {
     url: string;
     method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
@@ -667,6 +976,24 @@ declare interface IndexListItem {
     created_by?: string;
 }
 
+/** Data returned from the get-execution-by-id API */
+export declare type IntegrationExecutionData = Record<string, unknown>;
+
+/** Data returned from the get-integration-form API */
+export declare type IntegrationFormData = Record<string, unknown>;
+
+/** JSON Schema output for an integration form */
+export declare interface IntegrationFormJsonSchema {
+    type: 'object';
+    properties: Record<string, JsonSchemaProperty>;
+}
+
+/** Data returned from the get-integration-resource API */
+export declare type IntegrationResourceData = Record<string, unknown>;
+
+/** Data returned from the get-integrations API */
+export declare type IntegrationsListData = Record<string, unknown>;
+
 declare interface InterceptorManager {
     request: {
         use(interceptor: RequestInterceptor): number;
@@ -704,6 +1031,15 @@ export declare function isListResponse<T>(response: ApiResponse<T>): response is
  */
 export declare function isNetworkError(error: unknown): error is Error;
 
+/** A single property in the generated JSON Schema */
+export declare interface JsonSchemaProperty {
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+    enum?: string[];
+}
+
 declare interface ListIndexesQuery {
     page?: {
         page_no: number;
@@ -729,6 +1065,32 @@ 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;
+}
+
+/** Maximum number of status polling attempts before timeout */
+export declare const MAX_STATUS_POLLING_ATTEMPTS = 60;
+
+export declare interface PaginationInfo {
+    total_count: number;
+    total_pages: number;
+    current_page: number;
+    per_page: number;
+    type: string;
+}
+
 /**
  * Pagination parameters
  */
@@ -755,6 +1117,17 @@ export declare interface QueryOperator<T = unknown> {
     $exists?: boolean;
 }
 
+export declare interface QueryOptions {
+    fields?: string[];
+    sort?: Array<{
+        field: string;
+        order: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    offset?: number;
+    where?: Record<string, unknown>;
+}
+
 /**
  * Record Builder - provides a fluent interface for building record queries and operations
  */
@@ -963,11 +1336,339 @@ export declare interface RecordWithId extends RecordData {
 
 export declare type Region = 'asia-south1' | 'us-central1';
 
+export declare interface RegionHostConfig {
+    host: string;
+    timeout: number;
+    debug?: boolean;
+}
+
 declare type RequestInterceptor = (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
 
+/**
+ * Resolve a full service URL from region, environment, and service path.
+ */
+export declare function resolveServiceURL(region: Region, environment: Environment, servicePath: string): string;
+
 declare type ResponseInterceptor = (response: HttpResponse) => HttpResponse | Promise<HttpResponse>;
 
-export declare interface ServiceAuthConfig extends AuthConfig {
+/** Retry configuration for an activity */
+export declare interface RetryConfig {
+    maximum_attempts: number;
+    backoff_coefficient: number;
+    initial_interval: number;
+    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";
+};
+
+export declare interface ServiceAuthConfig extends AuthConfig_2 {
     service: string;
     serviceEndpoint?: string;
 }
@@ -1003,6 +1704,9 @@ 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;
+
 /**
  * Table Builder - provides a fluent interface for creating tables
  */
@@ -1236,30 +1940,23 @@ export declare interface TableRecord {
     source?: 'boltic' | 'copilot';
 }
 
-/**
- * Tables API Client - handles all table-related API operations
- */
-declare class TablesApiClient {
-    private httpAdapter;
-    private config;
-    private baseURL;
-    constructor(apiKey: string, config?: Omit<TablesApiClientConfig, 'apiKey'>);
-    private getBaseURL;
+declare class TablesApiClient extends BaseApiClient {
+    constructor(apiKey: string, config?: Omit<BaseApiClientConfig, 'apiKey'>);
     /**
      * Create a new table
      */
-    createTable(request: TableCreateRequest, options?: TableCreateOptions): Promise<BolticSuccessResponse_2<TableCreateResponse> | BolticErrorResponse_2>;
+    createTable(request: TableCreateRequest, options?: TableCreateOptions): Promise<BolticSuccessResponse<TableCreateResponse> | BolticErrorResponse>;
     /**
      * List tables with filtering and pagination
      */
-    listTables(options?: TableListOptions): Promise<BolticListResponse_2<TableRecord> | BolticErrorResponse_2>;
+    listTables(options?: TableListOptions): Promise<BolticListResponse<TableRecord> | BolticErrorResponse>;
     /**
      * Get a specific table by ID
      */
     getTable(tableId: string, options?: {
         fields?: Array<keyof TableRecord>;
         db_id?: string;
-    }): Promise<BolticSuccessResponse_2<TableRecord> | BolticErrorResponse_2>;
+    }): Promise<BolticSuccessResponse<TableRecord> | BolticErrorResponse>;
     /**
      * Update an existing table
      */
@@ -1268,28 +1965,15 @@ declare class TablesApiClient {
         description?: string;
         fields?: Array<keyof TableRecord>;
         db_id?: string;
-    }): Promise<BolticSuccessResponse_2<TableRecord> | BolticErrorResponse_2>;
+    }): Promise<BolticSuccessResponse<TableRecord> | BolticErrorResponse>;
     /**
      * Delete a table
      */
     deleteTable(tableId: string, options?: {
         db_id?: string;
-    }): Promise<BolticSuccessResponse_2<{
+    }): Promise<BolticSuccessResponse<{
         message: string;
-    }> | BolticErrorResponse_2>;
-    private buildHeaders;
-    private formatErrorResponse;
-}
-
-declare interface TablesApiClientConfig {
-    apiKey: string;
-    environment?: Environment;
-    region?: Region;
-    timeout?: number;
-    debug?: boolean;
-    retryAttempts?: number;
-    retryDelay?: number;
-    headers?: Record<string, string>;
+    }> | BolticErrorResponse>;
 }
 
 declare interface TableUpdateRequest {
@@ -1298,6 +1982,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;
 }
@@ -1323,10 +2010,169 @@ declare interface TokenInfo_2 {
     isValid: boolean;
 }
 
+/**
+ * Transform raw form fields into a flat JSON object with default/fallback
+ * values for each field.
+ *
+ * Fields like `secret`, `resource`, and `operation` are skipped by default
+ * since they are already handled by the SDK parameters.
+ */
+export declare function transformFormToDefaults(fields: FormField[], skipFields?: Set<string>): Record<string, unknown>;
+
+/**
+ * Transform raw form fields into a JSON Schema object describing the
+ * expected input shape.
+ *
+ * Fields like `secret`, `resource`, and `operation` are skipped by default
+ * since they are already handled by the SDK parameters.
+ */
+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 const VERSION = "1.0.0";
 
 export declare interface WhereCondition {
     [fieldName: string]: unknown | QueryOperator;
 }
 
+/** @deprecated Use `BolticSuccessResponse<T> | BolticErrorResponse` directly */
+export declare type WorkflowApiResponse<T> = BolticSuccessResponse<T> | BolticErrorResponse;
+
+/** @deprecated Use `BolticErrorResponse` directly */
+export declare type WorkflowErrorResponse = BolticErrorResponse;
+
+export declare class WorkflowResource extends BaseResource {
+    private apiClient;
+    constructor(client: BaseClient);
+    /**
+     * Execute a workflow integration activity.
+     *
+     * When `executeOnly` is `true`, returns the immediate API response.
+     * When `executeOnly` is `false` (default), polls until a terminal state
+     * is reached and returns the final execution result.
+     *
+     * @param params - Execution parameters
+     * @returns The execute response or the final polled result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.workflow.executeIntegration({
+     *   data: { type: 'apiActivity', name: 'api1', properties: { method: 'get', endpoint: '...' } },
+     * });
+     *
+     * const fire = await client.workflow.executeIntegration({
+     *   data: { type: 'apiActivity', name: 'api1', properties: { method: 'get', endpoint: '...' } },
+     *   executeOnly: true,
+     * });
+     * ```
+     */
+    executeIntegration(params: ExecuteIntegrationParams): Promise<BolticSuccessResponse<ExecuteActivityResponseData | IntegrationExecutionData> | BolticErrorResponse>;
+    /**
+     * Retrieve the result of a workflow execution by its run/execution ID.
+     *
+     * @param executionId - The execution run ID
+     * @returns The execution data or an error response
+     *
+     * @example
+     * ```typescript
+     * const result = await client.workflow.getIntegrationExecuteById('run-uuid');
+     * ```
+     */
+    getIntegrationExecuteById(executionId: string): Promise<BolticSuccessResponse<IntegrationExecutionData> | BolticErrorResponse>;
+    /**
+     * Fetch the list of available integrations.
+     *
+     * @param params - Optional pagination parameters (`page`, `per_page`)
+     * @returns The integrations list or an error response
+     *
+     * @example
+     * ```typescript
+     * const list = await client.workflow.getIntegrations();
+     * ```
+     */
+    getIntegrations(params?: GetIntegrationsParams): Promise<BolticSuccessResponse<IntegrationsListData> | BolticErrorResponse>;
+    /**
+     * Fetch credentials for a given integration entity.
+     *
+     * @param params - Entity name (required), optional `current_page` and `page_size`
+     * @returns The credentials list or an error response
+     *
+     * @example
+     * ```typescript
+     * const creds = await client.workflow.getCredentials({ entity: 'freshsales' });
+     * ```
+     */
+    getCredentials(params: GetCredentialsParams): Promise<BolticSuccessResponse<CredentialsListData> | BolticErrorResponse>;
+    /**
+     * Fetch the resource/operation schema for an integration.
+     *
+     * Returns the available resources and operations supported by the
+     * specified integration (e.g. which resources like "task", "project"
+     * are available and what operations can be performed on them).
+     *
+     * @param params - Integration slug identifier
+     * @returns The integration resource schema or an error response
+     *
+     * @example
+     * ```typescript
+     * const schema = await client.workflow.getIntegrationResource({
+     *   integration_slug: 'blt-int.asana',
+     * });
+     * ```
+     */
+    getIntegrationResource(params: GetIntegrationResourceParams): Promise<BolticSuccessResponse<IntegrationResourceData> | BolticErrorResponse>;
+    /**
+     * Fetch the form schema (fields) for a specific integration resource + operation.
+     *
+     * By default, returns a flat JSON object with default/fallback values
+     * for each input field. Set `asJsonSchema: true` to get a JSON Schema
+     * object describing the expected input shape instead.
+     *
+     * Fields like `resource` and `operation` are automatically excluded
+     * since they are already handled by the SDK parameters. The `secret`
+     * field is included and populated with the value from `params.secret`.
+     *
+     * @param params - Integration slug, resource, operation, credential secret, and format flag
+     * @returns Transformed form data or an error response
+     *
+     * @example
+     * ```typescript
+     * // Get flat defaults: { name: '', workspace: [], team: '', ... }
+     * const defaults = await client.workflow.getIntegrationForm({
+     *   integration_slug: 'blt-int.asana',
+     *   resource: 'project',
+     *   operation: 'create',
+     *   secret: 'credential-secret-here',
+     * });
+     *
+     * // Get JSON Schema: { type: 'object', properties: { name: { type: 'string', ... } } }
+     * const schema = await client.workflow.getIntegrationForm({
+     *   integration_slug: 'blt-int.asana',
+     *   resource: 'project',
+     *   operation: 'create',
+     *   secret: 'credential-secret-here',
+     *   asJsonSchema: true,
+     * });
+     * ```
+     */
+    getIntegrationForm(params: GetIntegrationFormParams): Promise<BolticSuccessResponse<Record<string, unknown> | IntegrationFormJsonSchema> | BolticErrorResponse>;
+    /**
+     * Internal polling loop.
+     * Repeatedly calls `getExecutionById` until the response `data` object is
+     * non-empty (execution finished) or max attempts are exhausted.
+     */
+    private pollExecution;
+}
+
+/** @deprecated Use `BolticSuccessResponse` directly */
+export declare type WorkflowSuccessResponse<T> = BolticSuccessResponse<T>;
+
 export { }