@boltic/sdk 0.1.2 → 0.1.3

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,7 @@ export declare class BolticClient {
     private sqlResource;
     private indexResource;
     private databaseResource;
+    private workflowResource;
     private currentDatabase;
     private clientOptions;
     constructor(apiKey: string, options?: ClientOptions);
@@ -183,7 +249,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 +265,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 +286,31 @@ 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>>;
+    };
     getSqlResource(): SqlResource;
     updateApiKey(newApiKey: string): void;
     updateConfig(updates: Partial<ClientConfig>): void;
@@ -253,15 +344,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 +361,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 +371,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 +482,9 @@ export declare function createClient(apiKey: string, options?: ClientOptions): B
  */
 export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
 
+/** Data returned from the get-credentials API */
+export declare type CredentialsListData = Record<string, unknown>;
+
 declare interface DatabaseContext {
     databaseId?: string;
     dbInternalName?: string;
@@ -559,9 +627,9 @@ 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 +638,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 +731,102 @@ 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;
+    };
+}
+
+/** 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;
+}
+
+declare interface HttpAdapter {
+    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+}
+
 declare interface HttpRequestConfig {
     url: string;
     method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
@@ -667,6 +858,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 +913,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 +947,14 @@ declare interface ListIndexesResponse {
     };
 }
 
+export declare interface PaginationInfo {
+    total_count: number;
+    total_pages: number;
+    current_page: number;
+    per_page: number;
+    type: string;
+}
+
 /**
  * Pagination parameters
  */
@@ -755,6 +981,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 +1200,37 @@ 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;
+}
+
+/** 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";
+};
+
+export declare interface ServiceAuthConfig extends AuthConfig_2 {
     service: string;
     serviceEndpoint?: string;
 }
@@ -1236,30 +1499,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 +1524,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 {
@@ -1323,10 +1566,160 @@ 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 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 { }