@boltic/sdk 0.0.1

package/dist/types/index.d.ts

@@ -0,0 +1,1087 @@
+declare type AlignmentType = 'left' | 'center' | 'right';
+
+/**
+ * Filter structure according to Tables Module PRD and backend buildWhereClause function
+ */
+declare interface ApiFilter {
+    field: string;
+    operator: string;
+    values: unknown[];
+}
+
+export declare type ApiResponse<T> = BolticSuccessResponse<T> | BolticListResponse<T> | BolticErrorResponse;
+
+export declare interface AuthConfig {
+    apiKey: string;
+    tokenRefreshThreshold?: number;
+    maxRetries?: number;
+}
+
+declare interface AuthConfig_2 {
+    apiKey: string;
+    tokenRefreshThreshold?: number;
+    maxRetries?: number;
+}
+
+export declare interface AuthHeaders {
+    'x-boltic-token': string;
+    'x-boltic-service'?: string;
+    [key: string]: string | undefined;
+}
+
+declare interface AuthHeaders_2 {
+    'x-boltic-token': string;
+    [key: string]: string;
+}
+
+export declare class AuthManager {
+    private config;
+    private tokenInfo;
+    constructor(config: AuthConfig);
+    private validateApiKey;
+    getAuthHeaders(): AuthHeaders;
+    updateApiKey(newApiKey: string): void;
+    isAuthenticated(): boolean;
+    validateApiKeyAsync(): Promise<boolean>;
+    getTokenInfo(): TokenInfo | null;
+    getServiceHeaders(service?: string): AuthHeaders;
+    validateForService(): Promise<boolean>;
+}
+
+declare class AuthManager_2 {
+    private config;
+    private tokenInfo;
+    constructor(config: AuthConfig_2);
+    private validateApiKey;
+    getAuthHeaders(): AuthHeaders_2;
+    updateApiKey(newApiKey: string): void;
+    isAuthenticated(): boolean;
+    validateApiKeyAsync(): Promise<boolean>;
+    getTokenInfo(): TokenInfo_2 | null;
+    getMaxRetries(): number;
+    toString(): string;
+    toJSON(): object;
+}
+
+declare class BaseClient {
+    private httpAdapter;
+    private authManager;
+    private interceptors;
+    private config;
+    constructor(config: ClientConfig, authManager: AuthManager_2);
+    private setupDefaultInterceptors;
+    private handleError;
+    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+    get<T = unknown>(url: string, config?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>>;
+    patch<T = unknown>(url: string, data?: unknown, config?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: Partial<HttpRequestConfig>): Promise<HttpResponse<T>>;
+    getInterceptors(): InterceptorManagerImpl;
+    updateConfig(updates: Partial<ClientConfig>): void;
+    getConfig(): ClientConfig;
+}
+
+export declare class BolticClient {
+    private configManager;
+    private authManager;
+    private baseClient;
+    private tableResource;
+    private columnResource;
+    private recordResource;
+    private sqlResource;
+    private currentDatabase;
+    private clientOptions;
+    constructor(apiKey: string, options?: ClientOptions);
+    getCurrentDatabase(): DatabaseContext | null;
+    get tables(): {
+        create: (data: TableCreateRequest) => Promise<BolticSuccessResponse<TableCreateResponse>>;
+        findAll: (options?: TableQueryOptions) => Promise<ApiResponse<TableRecord>>;
+        findById: (id: string) => Promise<BolticErrorResponse | BolticSuccessResponse<TableRecord | null>>;
+        findByName: (name: string) => Promise<BolticErrorResponse | BolticSuccessResponse<TableRecord | null>>;
+        findOne: (options: TableQueryOptions) => Promise<BolticErrorResponse | BolticSuccessResponse<TableRecord | null>>;
+        update: (name: string, data: TableUpdateRequest) => Promise<BolticErrorResponse | BolticSuccessResponse<TableRecord>>;
+        delete: (name: string) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+        message: string;
+        }>>;
+        rename: (oldName: string, newName: string) => Promise<BolticSuccessResponse<TableRecord>>;
+        setAccess: (request: {
+            table_name: string;
+            is_shared: boolean;
+        }) => Promise<BolticSuccessResponse<TableRecord>>;
+    };
+    get columns(): {
+        create: (tableName: string, column: FieldDefinition) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnRecord>>;
+        createMany: (tableName: string, columns: FieldDefinition[]) => Promise<BolticErrorResponse | BolticListResponse<ColumnRecord>>;
+        findAll: (tableName: string, options?: ColumnQueryOptions) => Promise<BolticErrorResponse | BolticListResponse<ColumnDetails>>;
+        findOne: (tableName: string, columnName: string) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnDetails>>;
+        findById: (tableName: string, columnId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnDetails>>;
+        update: (tableName: string, columnName: string, updates: ColumnUpdateRequest) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnDetails>>;
+        delete: (tableName: string, columnName: string) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+        success: boolean;
+        message?: string | undefined;
+        }>>;
+    };
+    table(name: string): TableBuilder;
+    from(tableName: string): {
+        columns: () => {
+            create: (column: FieldDefinition) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnRecord>>;
+            findAll: (options?: ColumnQueryOptions) => Promise<BolticErrorResponse | BolticListResponse<ColumnDetails>>;
+            get: (columnName: string) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnDetails>>;
+            update: (columnName: string, updates: ColumnUpdateRequest) => Promise<BolticErrorResponse | BolticSuccessResponse<ColumnDetails>>;
+            delete: (columnName: string) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+            success: boolean;
+            message?: string | undefined;
+            }>>;
+        };
+        records: () => {
+            insert: (data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+            insertMany: (records: RecordData[], options?: {
+                validation?: boolean;
+            }) => Promise<RecordBulkInsertResponse | BolticErrorResponse>;
+            findOne: (recordId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+            update: (options: RecordUpdateOptions) => Promise<BolticErrorResponse | BolticListResponse<RecordWithId>>;
+            updateById: (recordId: string, data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+            delete: (options: RecordDeleteOptions) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+            message: string;
+            }>>;
+            deleteById: (recordId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+            message: string;
+            }>>;
+        };
+        record: () => RecordBuilder;
+    };
+    get records(): {
+        insert: (tableName: string, data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+        insertMany: (tableName: string, records: RecordData[], options?: {
+            validation?: boolean;
+        }) => Promise<RecordBulkInsertResponse | BolticErrorResponse>;
+        findAll: (tableName: string, options?: RecordQueryOptions) => Promise<BolticErrorResponse | BolticListResponse<RecordWithId>>;
+        findOne: (tableName: string, recordId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+        update: (tableName: string, options: RecordUpdateOptions) => Promise<BolticErrorResponse | BolticListResponse<RecordWithId>>;
+        updateById: (tableName: string, recordId: string, data: RecordData) => Promise<BolticErrorResponse | BolticSuccessResponse<RecordWithId>>;
+        delete: (tableName: string, options: RecordDeleteOptions) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+        message: string;
+        }>>;
+        deleteById: (tableName: string, recordId: string) => Promise<BolticErrorResponse | BolticSuccessResponse<    {
+        message: string;
+        }>>;
+    };
+    record(tableName: string): RecordBuilder;
+    get sql(): {
+        textToSQL: (prompt: string, options?: TextToSQLOptions) => Promise<AsyncIterable<string>>;
+        executeSQL: (query: string) => Promise<BolticErrorResponse | ExecuteSQLApiResponse>;
+    };
+    getSqlResource(): SqlResource;
+    updateApiKey(newApiKey: string): void;
+    updateConfig(updates: Partial<ClientConfig>): void;
+    getConfig(): ClientConfig;
+    validateApiKey(): Promise<boolean>;
+    isAuthenticated(): boolean;
+    getHttpClient(): BaseClient;
+    addRequestInterceptor(interceptor: (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>): number;
+    addResponseInterceptor(onFulfilled?: (response: HttpResponse) => HttpResponse | Promise<HttpResponse>, onRejected?: (error: unknown) => unknown): number;
+    ejectRequestInterceptor(id: number): void;
+    ejectResponseInterceptor(id: number): void;
+    testConnection(): Promise<boolean>;
+    getVersion(): string;
+    getEnvironment(): Environment;
+    getRegion(): string;
+    enableDebug(): void;
+    disableDebug(): void;
+    isDebugEnabled(): boolean;
+    private updateAllResourcesConfig;
+    toString(): string;
+    toJSON(): object;
+}
+
+export declare interface BolticErrorResponse {
+    data?: never;
+    message?: string;
+    error: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+declare interface BolticErrorResponse_2 {
+    data?: never;
+    error: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+export declare interface BolticListResponse<T> {
+    data: T[];
+    pagination?: {
+        total_count: number;
+        total_pages: number;
+        current_page: number;
+        per_page: number;
+        type: string;
+    };
+    message?: string;
+    error?: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+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;
+    error?: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+declare interface BolticSuccessResponse_2<T = unknown> {
+    data: T;
+    message?: string;
+}
+
+declare interface ClientConfig extends EnvironmentConfig {
+    apiKey: string;
+    environment: Environment;
+    region: Region;
+    headers?: Record<string, string>;
+    retryAttempts: number;
+    retryDelay: number;
+    maxRetries: number;
+}
+
+export declare interface ClientOptions extends Partial<EnvironmentConfig> {
+    environment?: Environment;
+    region?: 'asia-south1' | 'us-central1';
+    debug?: boolean;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+
+declare interface ColumnDetails {
+    id: string;
+    name: string;
+    table_id: string;
+    type: FieldType;
+    description?: string;
+    is_nullable: boolean;
+    is_primary_key: boolean;
+    is_unique: boolean;
+    is_indexed: boolean;
+    is_visible: boolean;
+    is_readonly: boolean;
+    field_order: number;
+    default_value?: unknown;
+    created_at: string;
+    updated_at: string;
+    alignment?: AlignmentType;
+    timezone?: string;
+    date_format?: string;
+    time_format?: string;
+    decimals?: number | string;
+    currency_format?: string;
+    selection_source?: string;
+    selectable_items?: string[];
+    multiple_selections?: boolean;
+    phone_format?: string;
+    vector_dimension?: number;
+}
+
+declare interface ColumnQueryOptions {
+    where?: {
+        id?: string;
+        name?: string;
+        table_id?: string;
+        type?: FieldType;
+        is_nullable?: boolean;
+        is_unique?: boolean;
+        is_indexed?: boolean;
+        is_primary_key?: boolean;
+    };
+    fields?: Array<keyof ColumnDetails>;
+    sort?: Array<{
+        field: keyof ColumnDetails;
+        order: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    offset?: number;
+}
+
+declare interface ColumnRecord {
+    id: string;
+}
+
+declare interface ColumnUpdateRequest {
+    name?: string;
+    type?: FieldType;
+    description?: string;
+    is_nullable?: boolean;
+    is_unique?: boolean;
+    is_indexed?: boolean;
+    is_visible?: boolean;
+    is_primary_key?: boolean;
+    is_readonly?: boolean;
+    default_value?: unknown;
+    field_order?: number;
+    fields?: Array<keyof ColumnDetails>;
+    alignment?: AlignmentType;
+    decimals?: DecimalType;
+    currency_format?: string;
+    selection_source?: 'provide-static-list';
+    selectable_items?: string[];
+    multiple_selections?: boolean;
+    phone_format?: PhoneFormatType;
+    date_format?: keyof typeof DateFormatEnum;
+    time_format?: keyof typeof TimeFormatEnum;
+    timezone?: string;
+    vector_dimension?: number;
+}
+
+export declare function createClient(apiKey: string, options?: ClientOptions): BolticClient;
+
+/**
+ * Utility functions for working with standard Error classes
+ */
+/**
+ * Creates a structured error object with additional context
+ */
+export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
+
+declare interface DatabaseContext {
+    databaseName: string;
+}
+
+declare const DateFormatEnum: Readonly<{
+    MMDDYY: "%m/%d/%y";
+    MMDDYYYY: "%m/%d/%Y";
+    MM_DD_YYYY: "%m-%d-%Y";
+    DD_MM_YYYY: "%d-%m-%Y";
+    DDMMYYYY: "%d/%m/%Y";
+    DDMMYY: "%d/%m/%y";
+    YYYY_MM_DD: "%Y-%m-%d";
+    MMMM__DD__YYYY: "%B %d %Y";
+    MMM__DD__YYYY: "%b %d %Y";
+    ddd__MMM__DD__YYYY: "%a %b %d %Y";
+}>;
+
+declare type DecimalType = '00' | '0.0' | '0.00' | '0.000' | '0.0000' | '0.00000' | '0.000000';
+
+declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
+
+declare interface EnvironmentConfig {
+    baseURL: string;
+    timeout: number;
+    retryAttempts?: number;
+    debug?: boolean;
+}
+
+declare type ErrorInterceptor = (error: unknown) => unknown | Promise<unknown>;
+
+declare interface ExecuteSQLApiResponse {
+    data: [
+    Record<string, unknown>[],
+    unknown
+    ];
+    pagination?: {
+        total_count: number;
+        total_pages: number;
+        current_page: number;
+        per_page: number;
+        type: string;
+    };
+    message?: string;
+    error?: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+export declare interface FieldDefinition {
+    name: string;
+    type: FieldType;
+    is_nullable?: boolean;
+    is_primary_key?: boolean;
+    is_unique?: boolean;
+    is_indexed?: boolean;
+    is_visible?: boolean;
+    is_readonly?: boolean;
+    field_order?: number;
+    description?: string;
+    default_value?: unknown;
+    alignment?: 'left' | 'center' | 'right';
+    timezone?: string;
+    date_format?: string;
+    time_format?: string;
+    decimals?: string;
+    currency_format?: string;
+    selection_source?: string;
+    selectable_items?: string[];
+    multiple_selections?: boolean;
+    phone_format?: string;
+    vector_dimension?: number;
+}
+
+export declare type FieldType = 'text' | 'long-text' | 'number' | 'currency' | 'checkbox' | 'dropdown' | 'email' | 'phone-number' | 'link' | 'json' | 'date-time' | 'vector' | 'halfvec' | 'sparsevec';
+
+/**
+ * Formats error for logging/debugging
+ */
+export declare function formatError(error: unknown): string;
+
+/**
+ * Extracts HTTP status code from axios or fetch errors
+ */
+export declare function getHttpStatusCode(error: unknown): number | null;
+
+declare interface HttpRequestConfig {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    params?: Record<string, unknown>;
+    data?: unknown;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+
+declare interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+
+declare interface InterceptorManager {
+    request: {
+        use(interceptor: RequestInterceptor): number;
+        eject(id: number): void;
+    };
+    response: {
+        use(onFulfilled?: ResponseInterceptor, onRejected?: ErrorInterceptor): number;
+        eject(id: number): void;
+    };
+}
+
+declare class InterceptorManagerImpl implements InterceptorManager {
+    private requestInterceptors;
+    private responseInterceptors;
+    private nextId;
+    request: {
+        use: (interceptor: RequestInterceptor) => number;
+        eject: (id: number) => void;
+    };
+    response: {
+        use: (onFulfilled?: ResponseInterceptor, onRejected?: ErrorInterceptor) => number;
+        eject: (id: number) => void;
+    };
+    executeRequestInterceptors(config: HttpRequestConfig): Promise<HttpRequestConfig>;
+    executeResponseInterceptors(response: HttpResponse): Promise<HttpResponse>;
+    executeErrorInterceptors(error: unknown): Promise<unknown>;
+}
+
+export declare function isErrorResponse<T>(response: ApiResponse<T>): response is BolticErrorResponse;
+
+export declare function isListResponse<T>(response: ApiResponse<T>): response is BolticListResponse<T>;
+
+/**
+ * Checks if an error is a network/HTTP related error
+ */
+export declare function isNetworkError(error: unknown): error is Error;
+
+declare type PhoneFormatType = '+91 123 456 7890' | '(123) 456-7890' | '+1 (123) 456-7890' | '+91 12 3456 7890';
+
+export declare interface QueryOperator<T = unknown> {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $like?: string;
+    $ilike?: string;
+    $between?: [T, T];
+    $null?: boolean;
+    $exists?: boolean;
+}
+
+/**
+ * Record Builder - provides a fluent interface for building record queries and operations
+ */
+declare class RecordBuilder {
+    private tableName;
+    private recordResource;
+    private queryOptions;
+    private updateData;
+    constructor(options: RecordBuilderOptions);
+    /**
+     * Add filter conditions
+     */
+    where(conditions: Record<string, unknown>): RecordBuilder;
+    /**
+     * Set sorting
+     */
+    orderBy(field: string, direction?: 'asc' | 'desc'): RecordBuilder;
+    /**
+     * Set limit (using page)
+     */
+    limit(count: number): RecordBuilder;
+    /**
+     * Set offset (using page)
+     */
+    offset(count: number): RecordBuilder;
+    /**
+     * Set fields to select
+     */
+    select(fields: string[]): RecordBuilder;
+    /**
+     * Set data for update operations
+     */
+    set(data: RecordData): RecordBuilder;
+    /**
+     * Set pagination
+     */
+    page(pageNo: number, pageSize?: number): RecordBuilder;
+    /**
+     * Execute list operation (was findAll)
+     */
+    list(): Promise<BolticListResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Execute findAll operation (alias for list)
+     */
+    findAll(): Promise<BolticListResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Execute findOne operation by getting first result from list
+     */
+    findOne(): Promise<BolticSuccessResponse<RecordWithId | null> | BolticErrorResponse>;
+    /**
+     * Build where conditions from filters for API consumption
+     */
+    private buildWhereConditions;
+    /**
+     * Execute update operation - requires filters or record IDs
+     */
+    update(): Promise<BolticListResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Execute update by ID operation
+     */
+    updateById(id: string): Promise<BolticSuccessResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Execute delete by single ID operation
+     */
+    deleteById(id: string): Promise<BolticSuccessResponse<{
+        message: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Execute delete by IDs operation
+     */
+    deleteByIds(ids: string[]): Promise<BolticSuccessResponse<{
+        message: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Execute delete operation using filters
+     */
+    delete(): Promise<BolticSuccessResponse<{
+        message: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Get the built query options (for debugging)
+     */
+    getQueryOptions(): RecordQueryOptions;
+    /**
+     * Get the update data (for debugging)
+     */
+    getUpdateData(): RecordData;
+    /**
+     * Execute insert operation
+     */
+    insert(data: RecordData): Promise<BolticSuccessResponse<RecordWithId> | BolticErrorResponse>;
+}
+
+declare interface RecordBuilderOptions {
+    tableName: string;
+    recordResource: RecordResource;
+}
+
+declare interface RecordBulkInsertOptions {
+    validation?: boolean;
+}
+
+declare interface RecordBulkInsertResponse {
+    data: {
+        records: RecordWithId[];
+        insert_count: number;
+    };
+    message?: string;
+    error?: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+export declare interface RecordData {
+    [fieldName: string]: unknown;
+    fields?: string[];
+}
+
+declare interface RecordDeleteOptions {
+    record_ids?: string[];
+    filters?: ApiFilter[] | Record<string, unknown>;
+}
+
+declare interface RecordQueryOptions {
+    page?: {
+        page_no: number;
+        page_size: number;
+    };
+    filters?: ApiFilter[] | Record<string, unknown>[];
+    sort?: Record<string, unknown>[];
+    fields?: string[];
+}
+
+declare class RecordResource {
+    private apiClient;
+    private tablesApiClient;
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Insert a single record
+     */
+    insert(tableName: string, data: RecordData): Promise<BolticSuccessResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Insert multiple records in bulk
+     */
+    insertMany(tableName: string, records: RecordData[], options?: RecordBulkInsertOptions): Promise<RecordBulkInsertResponse | BolticErrorResponse>;
+    /**
+     * Get a single record by ID
+     */
+    get(tableName: string, recordId: string): Promise<BolticSuccessResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * List records with filtering and pagination
+     */
+    list(tableName: string, options?: RecordQueryOptions): Promise<BolticListResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Update records by filters
+     */
+    update(tableName: string, options: RecordUpdateOptions): Promise<BolticListResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Update a single record by ID
+     */
+    updateById(tableName: string, recordId: string, data: RecordData): Promise<BolticSuccessResponse<RecordWithId> | BolticErrorResponse>;
+    /**
+     * Unified delete method that supports both record IDs and filters
+     */
+    delete(tableName: string, options: RecordDeleteOptions): Promise<BolticSuccessResponse<{
+        message: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Delete a single record by ID
+     */
+    deleteById(tableName: string, recordId: string): Promise<BolticSuccessResponse<{
+        message: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Helper method to get table information by name
+     */
+    private getTableInfo;
+    /**
+     * Helper method to ensure all required fields for a record are present,
+     * filling missing ones with null.
+     */
+    private ensureCompleteRecordData;
+}
+
+declare interface RecordUpdateOptions {
+    set: RecordData;
+    filters: ApiFilter[] | Record<string, unknown>[];
+    fields?: string[];
+}
+
+export declare interface RecordWithId extends RecordData {
+    id: string;
+    created_at?: string;
+    updated_at?: string;
+}
+
+export declare type Region = 'asia-south1' | 'us-central1';
+
+declare type RequestInterceptor = (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
+
+declare type ResponseInterceptor = (response: HttpResponse) => HttpResponse | Promise<HttpResponse>;
+
+export declare interface ServiceAuthConfig extends AuthConfig {
+    service: string;
+    serviceEndpoint?: string;
+}
+
+declare class SqlResource {
+    private sqlApiClient;
+    constructor(client: BaseClient);
+    /**
+     * Convert natural language to SQL query
+     * Returns streaming results for real-time query generation
+     *
+     * @param prompt - Natural language description of the desired query
+     * @param options - Optional parameters including currentQuery for refinement
+     * @returns AsyncIterable<string> for streaming SQL generation
+     *
+     */
+    textToSQL(prompt: string, options?: TextToSQLOptions): Promise<AsyncIterable<string>>;
+    /**
+     * Execute SQL query with built-in safety measures and performance optimization
+     *
+     * @param query - SQL query string to execute
+     * @returns Promise<ExecuteSQLApiResponse> with raw API response following Boltic API Response Structure
+     *
+     */
+    executeSQL(query: string): Promise<ExecuteSQLApiResponse | BolticErrorResponse>;
+}
+
+/**
+ * Table Builder - provides a fluent interface for creating tables
+ */
+declare class TableBuilder {
+    private tableName;
+    private description?;
+    private isPublic;
+    private fields;
+    private tablesApiClient?;
+    constructor(options: TableBuilderOptions, tablesApiClient?: TablesApiClient);
+    /**
+     * Set table name
+     */
+    name(name: string): TableBuilder;
+    /**
+     * Set table description
+     */
+    describe(description: string): TableBuilder;
+    /**
+     * Set if table is public
+     */
+    public(isPublic?: boolean): TableBuilder;
+    /**
+     * Add a text field
+     */
+    text(name: string, options?: {
+        nullable?: boolean;
+        unique?: boolean;
+        indexed?: boolean;
+        defaultValue?: string;
+        description?: string;
+        alignment?: 'left' | 'center' | 'right';
+    }): TableBuilder;
+    /**
+     * Add a long text field
+     */
+    longText(name: string, options?: {
+        nullable?: boolean;
+        description?: string;
+        alignment?: 'left' | 'center' | 'right';
+    }): TableBuilder;
+    /**
+     * Add a number field
+     */
+    number(name: string, options?: {
+        nullable?: boolean;
+        unique?: boolean;
+        indexed?: boolean;
+        defaultValue?: number;
+        description?: string;
+        decimals?: string;
+        alignment?: 'left' | 'center' | 'right';
+    }): TableBuilder;
+    /**
+     * Add a currency field
+     */
+    currency(name: string, options?: {
+        nullable?: boolean;
+        defaultValue?: number;
+        description?: string;
+        currencyFormat?: string;
+        decimals?: string;
+    }): TableBuilder;
+    /**
+     * Add a checkbox field
+     */
+    checkbox(name: string, options?: {
+        nullable?: boolean;
+        defaultValue?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a dropdown field
+     */
+    dropdown(name: string, items: string[], options?: {
+        nullable?: boolean;
+        multiple?: boolean;
+        defaultValue?: string | string[];
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add an email field
+     */
+    email(name: string, options?: {
+        nullable?: boolean;
+        unique?: boolean;
+        indexed?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a phone number field
+     */
+    phone(name: string, options?: {
+        nullable?: boolean;
+        description?: string;
+        format?: string;
+    }): TableBuilder;
+    /**
+     * Add a link field
+     */
+    link(name: string, options?: {
+        nullable?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a JSON field
+     */
+    json(name: string, options?: {
+        nullable?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a date-time field
+     */
+    dateTime(name: string, options?: {
+        nullable?: boolean;
+        description?: string;
+        dateFormat?: string;
+        timeFormat?: string;
+        timezone?: string;
+    }): TableBuilder;
+    /**
+     * Add a vector field
+     */
+    vector(name: string, dimension: number, options?: {
+        nullable?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a custom field
+     */
+    addField(field: FieldDefinition): TableBuilder;
+    /**
+     * Remove a field by name
+     */
+    removeField(name: string): TableBuilder;
+    /**
+     * Get current fields
+     */
+    getFields(): FieldDefinition[];
+    /**
+     * Get current table name
+     */
+    getName(): string;
+    /**
+     * Get current description
+     */
+    getDescription(): string | undefined;
+    /**
+     * Build the table request object
+     */
+    build(): TableCreateRequest;
+    /**
+     * Build and create the table (requires API client)
+     */
+    create(options?: {
+        is_ai_generated_schema?: boolean;
+        is_template?: boolean;
+    }): Promise<BolticSuccessResponse<TableCreateResponse> | BolticErrorResponse>;
+}
+
+declare interface TableBuilderOptions {
+    name: string;
+    description?: string;
+    is_ai_generated_schema?: boolean;
+}
+
+declare interface TableCreateOptions {
+    is_ai_generated_schema?: boolean;
+    is_template?: boolean;
+}
+
+export declare interface TableCreateRequest {
+    name: string;
+    fields: FieldDefinition[];
+    description?: string;
+    is_ai_generated_schema?: boolean;
+    is_template?: boolean;
+    responseFields?: Array<keyof TableRecord>;
+}
+
+declare interface TableCreateResponse {
+    id: string;
+    message: string;
+}
+
+declare interface TableListOptions extends TableQueryOptions {
+    page?: number;
+    pageSize?: number;
+    isShared?: boolean;
+}
+
+declare interface TableQueryOptions {
+    where?: {
+        id?: string;
+        name?: string;
+        db_id?: string;
+        is_public?: boolean;
+        created_by?: string;
+        created_at?: {
+            $gte?: string;
+            $lte?: string;
+            $between?: [string, string];
+        };
+    };
+    fields?: Array<keyof TableRecord>;
+    sort?: Array<{
+        field: keyof TableRecord;
+        order: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    offset?: number;
+}
+
+export declare interface TableRecord {
+    id: string;
+    name: string;
+    account_id: string;
+    internal_table_name: string;
+    internal_db_name: string;
+    db_id?: string;
+    resource_id?: string;
+    description?: string;
+    type?: string;
+    parent_table_id?: string;
+    is_deleted: boolean;
+    is_public: boolean;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    updated_by: string;
+    snapshot_url?: string;
+    account_status: 'active' | 'inactive' | 'deleted';
+    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;
+    /**
+     * Create a new table
+     */
+    createTable(request: TableCreateRequest, options?: TableCreateOptions): Promise<BolticSuccessResponse_2<TableCreateResponse> | BolticErrorResponse_2>;
+    /**
+     * List tables with filtering and pagination
+     */
+    listTables(options?: TableListOptions): Promise<BolticListResponse_2<TableRecord> | BolticErrorResponse_2>;
+    /**
+     * Get a specific table by ID
+     */
+    getTable(tableId: string, options?: {
+        fields?: Array<keyof TableRecord>;
+    }): Promise<BolticSuccessResponse_2<TableRecord> | BolticErrorResponse_2>;
+    /**
+     * Update an existing table
+     */
+    updateTable(tableId: string, updates: {
+        name?: string;
+        description?: string;
+        is_shared?: boolean;
+        fields?: Array<keyof TableRecord>;
+    }): Promise<BolticSuccessResponse_2<TableRecord> | BolticErrorResponse_2>;
+    /**
+     * Delete a table
+     */
+    deleteTable(tableId: string): Promise<BolticSuccessResponse_2<{
+        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>;
+}
+
+declare interface TableUpdateRequest {
+    name?: string;
+    description?: string;
+    is_shared?: boolean;
+    fields?: Array<keyof TableRecord>;
+}
+
+declare interface TextToSQLOptions {
+    currentQuery?: string;
+}
+
+declare const TimeFormatEnum: Readonly<{
+    HH_mm_ss: "%H:%M:%S";
+    HH_mm_ssZ: "%H:%M:%SZ";
+    HH_mm_ss_SSS: "%H:%M:%S.%f";
+    HH_mm_ss__Z: "%H:%M:%S %Z";
+    HH_mm__AMPM: "%I:%M %p";
+    HH_mm_ss__AMPM: "%I:%M:%S %p";
+}>;
+
+export declare interface TokenInfo {
+    token: string;
+    expiresAt?: Date;
+    isValid: boolean;
+}
+
+declare interface TokenInfo_2 {
+    token: string;
+    expiresAt?: Date;
+    isValid: boolean;
+}
+
+export declare const VERSION = "1.0.0";
+
+export declare interface WhereCondition {
+    [fieldName: string]: unknown | QueryOperator;
+}
+
+export { }