@boltic/sdk 0.0.1

package/dist/databases/index.d.ts

@@ -0,0 +1,1560 @@
+export declare type AlignmentType = 'left' | 'right' | 'center';
+
+declare type AlignmentType_2 = 'left' | 'center' | 'right';
+
+/**
+ * API error for HTTP/API related failures
+ */
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown;
+    constructor(message: string, statusCode: number, response?: unknown);
+}
+
+/**
+ * Filter structure according to Tables Module PRD and backend buildWhereClause function
+ */
+export 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;
+}
+
+export declare interface AuthHeaders {
+    'x-boltic-token': string;
+    [key: string]: string;
+}
+
+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;
+    getMaxRetries(): number;
+}
+
+declare class BaseClient {
+    private httpAdapter;
+    private authManager;
+    private interceptors;
+    private config;
+    constructor(config: ClientConfig, authManager: AuthManager);
+    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;
+}
+
+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;
+    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<BolticSuccessResponse<TableRecord | null>>;
+        findByName: (name: string) => Promise<BolticSuccessResponse<TableRecord | null>>;
+        findOne: (options: TableQueryOptions) => Promise<BolticSuccessResponse<TableRecord | null>>;
+        update: (name: string, data: TableUpdateRequest) => Promise<BolticSuccessResponse<TableRecord>>;
+        delete: (name: string) => Promise<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>>;
+            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>>;
+        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<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;
+}
+
+export declare interface BolticErrorResponse {
+    data?: {};
+    message?: string;
+    error: {
+        code?: string;
+        message?: string;
+        meta?: string[];
+    };
+}
+
+declare interface BolticErrorResponse_2 {
+    data: {};
+    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;
+}
+
+/**
+ * Build API filters with validation based on backend buildWhereClause
+ */
+export declare function buildApiFilters(whereOrFilters: WhereCondition_2 | ApiFilter[], whereOperator?: 'AND' | 'OR'): {
+    filters: ApiFilter[];
+    whereOperator: string;
+};
+
+export declare interface BulkResponse<T> {
+    success: T[];
+    failed: Array<{
+        item: unknown;
+        error: string;
+    }>;
+    summary: {
+        total: number;
+        successful: number;
+        failed: number;
+    };
+}
+
+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;
+}
+
+/**
+ * Column Builder - provides a fluent interface for building column queries and operations
+ */
+declare class ColumnBuilder {
+    private tableName;
+    private columnResource;
+    private queryOptions;
+    private updateData;
+    constructor(options: ColumnBuilderOptions);
+    /**
+     * Add filter conditions
+     */
+    where(conditions: Partial<ColumnQueryOptions['where']>): ColumnBuilder;
+    /**
+     * Set sorting
+     */
+    orderBy(field: keyof ColumnDetails, direction?: 'asc' | 'desc'): ColumnBuilder;
+    /**
+     * Set limit
+     */
+    limit(count: number): ColumnBuilder;
+    /**
+     * Set offset
+     */
+    offset(count: number): ColumnBuilder;
+    /**
+     * Set fields to select
+     */
+    select(fields: Array<keyof ColumnDetails>): ColumnBuilder;
+    /**
+     * Set data for update operations
+     */
+    set(data: ColumnUpdateRequest): ColumnBuilder;
+    /**
+     * Execute findAll operation
+     */
+    findAll(): Promise<BolticListResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Execute get operation (was findOne) - requires column name
+     */
+    get(): Promise<BolticSuccessResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Execute update operation - requires column name
+     */
+    update(): Promise<BolticSuccessResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Execute delete operation - requires column name
+     */
+    delete(): Promise<BolticSuccessResponse<{
+        success: boolean;
+        message?: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Get the built query options (for debugging)
+     */
+    getQueryOptions(): ColumnQueryOptions;
+    /**
+     * Get the update data (for debugging)
+     */
+    getUpdateData(): ColumnUpdateRequest;
+}
+
+declare interface ColumnBuilderOptions {
+    tableName: string;
+    columnResource: ColumnResource;
+}
+
+export 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_2;
+    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;
+}
+
+export declare class ColumnHelpers {
+    /**
+     * Convert FieldDefinition to ColumnUpdateRequest
+     */
+    static fieldToUpdateRequest(field: FieldDefinition): ColumnUpdateRequest;
+    /**
+     * Apply default values to column definition
+     */
+    static applyDefaultValues(column: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a column definition with proper defaults
+     */
+    static createColumnDefinition(name: string, type: FieldType, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Get column type display name
+     */
+    static getColumnTypeDisplayName(type: FieldType): string;
+}
+
+export 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 class ColumnResource extends BaseResource {
+    private columnsApiClient;
+    private tablesApiClient;
+    constructor(client: BaseClient);
+    /**
+     * Create a single column in a table
+     */
+    create(tableName: string, column: FieldDefinition): Promise<BolticSuccessResponse<ColumnRecord> | BolticErrorResponse>;
+    /**
+     * Process column defaults and auto-generate field_order
+     */
+    private processColumnDefaults;
+    /**
+     * Generate the next available field_order for a table
+     */
+    private generateFieldOrder;
+    /**
+     * Transform SDK ColumnQueryOptions to API request format
+     */
+    private transformColumnQueryToApiRequest;
+    /**
+     * Add multiple columns to existing table
+     */
+    createMany(tableName: string, columns: FieldDefinition[]): Promise<BolticListResponse<ColumnRecord> | BolticErrorResponse>;
+    /**
+     * Find all columns in a table (replaces list functionality)
+     */
+    findAll(tableName: string, options?: ColumnQueryOptions): Promise<BolticListResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Get a single column by name
+     */
+    get(tableName: string, columnName: string): Promise<BolticSuccessResponse<ColumnDetails> | BolticErrorResponse>;
+    findById(tableName: string, columnId: string): Promise<BolticSuccessResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Update a column by name
+     */
+    update(tableName: string, columnName: string, updates: ColumnUpdateRequest): Promise<BolticSuccessResponse<ColumnDetails> | BolticErrorResponse>;
+    /**
+     * Delete a column by name
+     */
+    delete(tableName: string, columnName: string): Promise<BolticSuccessResponse<{
+        success: boolean;
+        message?: string;
+    }> | BolticErrorResponse>;
+    /**
+     * Helper method to get table information by name
+     */
+    private getTableInfo;
+    /**
+     * Helper method to get table ID by name (deprecated, use getTableInfo instead)
+     */
+    private getTableId;
+}
+
+export 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_2;
+    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;
+
+/**
+ * Create a new column builder
+ */
+export declare function createColumnBuilder(options: ColumnBuilderOptions): ColumnBuilder;
+
+export declare function createErrorResponse(error: string, details?: unknown): {
+    error: string;
+    details: unknown;
+};
+
+/**
+ * Creates a structured error object with additional context
+ */
+export declare function createErrorWithContext(message: string, context?: Record<string, unknown>): Error;
+
+/**
+ * Helper function to create a new filter builder
+ */
+export declare function createFilter(): FilterBuilder;
+
+export declare function createMockResponse<T>(data: T, pagination?: PaginationInfo): {
+    data: T;
+    pagination: PaginationInfo | undefined;
+};
+
+export declare interface CreateOperation<TCreate, TResult> {
+    create(data: TCreate): Promise<{
+        data: TResult;
+        error?: string;
+    }>;
+}
+
+/**
+ * Create a new record builder
+ */
+export declare function createRecordBuilder(options: RecordBuilderOptions): RecordBuilder;
+
+/**
+ * Create a new table builder
+ */
+export declare function createTableBuilder(options: TableBuilderOptions, tablesApiClient?: TablesApiClient): TableBuilder;
+
+export declare function createTestClient(options?: MockClientOptions): BolticClient;
+
+export declare interface CrudOperations<TCreate, TUpdate, TResult, TQuery = unknown> extends CreateOperation<TCreate, TResult>, ReadOperation<TQuery, TResult>, UpdateOperation<TUpdate, TResult>, DeleteOperation {
+}
+
+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';
+
+export declare interface DeleteOperation {
+    delete(id: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    delete(options: {
+        where: Record<string, unknown>;
+    }): Promise<{
+        deletedCount: number;
+        error?: string;
+    }>;
+}
+
+export declare const ENV_CONFIGS: Record<Environment, EnvironmentConfig>;
+
+export declare type Environment = 'local' | 'sit' | 'uat' | 'prod';
+
+export declare interface EnvironmentConfig {
+    baseURL: string;
+    timeout: number;
+    retryAttempts?: number;
+    debug?: boolean;
+}
+
+declare type ErrorInterceptor = (error: unknown) => unknown | Promise<unknown>;
+
+export declare interface ErrorResponse {
+    data?: never;
+    error: string;
+    details?: unknown;
+    code?: string;
+}
+
+export declare interface ExecuteSQLApiRequest {
+    query: string;
+}
+
+export 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;
+}
+
+export declare interface ExecutionResult {
+    data: Record<string, unknown>[];
+    count: number;
+    metadata: unknown;
+    pagination?: PaginationInfo;
+}
+
+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';
+
+/**
+ * Comprehensive filter operators based on backend buildWhereClause function
+ */
+export declare const FILTER_OPERATORS: {
+    readonly EQUALS: "=";
+    readonly NOT_EQUALS: "!=";
+    readonly GREATER_THAN: ">";
+    readonly GREATER_THAN_EQUAL: ">=";
+    readonly LESS_THAN: "<";
+    readonly LESS_THAN_EQUAL: "<=";
+    readonly LIKE: "LIKE";
+    readonly ILIKE: "ILIKE";
+    readonly STARTS_WITH: "STARTS WITH";
+    readonly IN: "IN";
+    readonly NOT_IN: "NOT IN";
+    readonly IS_EMPTY: "IS EMPTY";
+    readonly IS_NULL: "IS NULL";
+    readonly IS_NOT_NULL: "IS NOT NULL";
+    readonly BETWEEN: "BETWEEN";
+    readonly ARRAY_CONTAINS: "@>";
+    readonly ARRAY_NOT_CONTAINS: "NOT @>";
+    readonly ANY: "ANY";
+    readonly IS_ONE_OF_ARRAY: "IS ONE OF";
+    readonly DROPDOWN_ITEM_STARTS_WITH: "DROPDOWN ITEM STARTS WITH";
+    readonly WITHIN: "WITHIN";
+};
+
+/**
+ * Create filter helper for building complex filter conditions
+ */
+export declare class FilterBuilder {
+    private filters;
+    equals(field: string, value: unknown): FilterBuilder;
+    notEquals(field: string, value: unknown): FilterBuilder;
+    greaterThan(field: string, value: unknown): FilterBuilder;
+    lessThan(field: string, value: unknown): FilterBuilder;
+    between(field: string, start: unknown, end: unknown): FilterBuilder;
+    in(field: string, values: unknown[]): FilterBuilder;
+    like(field: string, value: unknown): FilterBuilder;
+    startsWith(field: string, value: unknown): FilterBuilder;
+    isEmpty(field: string): FilterBuilder;
+    isNull(field: string): FilterBuilder;
+    arrayContains(field: string, value: unknown): FilterBuilder;
+    build(): ApiFilter[];
+    clear(): FilterBuilder;
+}
+
+/**
+ * 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;
+
+export declare interface HttpAdapter {
+    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+}
+
+export 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;
+}
+
+export 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;
+
+/**
+ * Convert API filters back to SDK where clause
+ */
+export declare function mapFiltersToWhere(filters: ApiFilter[]): WhereCondition_2;
+
+/**
+ * Map SDK where clause to API filters format
+ */
+export declare function mapWhereToFilters(where: WhereCondition_2): ApiFilter[];
+
+export declare interface MockClientOptions {
+    apiKey?: string;
+    environment?: 'local' | 'sit' | 'uat' | 'prod';
+    region?: 'asia-south1' | 'us-central1';
+    mockResponses?: Record<string, unknown>;
+    debug?: boolean;
+}
+
+/**
+ * Convert direct filter array format to SDK format
+ * This handles the case where filters are passed directly as an array
+ */
+export declare function normalizeFilters(filters: ApiFilter[] | Record<string, unknown>[] | WhereCondition_2): ApiFilter[];
+
+export declare interface PaginationInfo {
+    total_count: number;
+    total_pages: number;
+    current_page: number;
+    per_page: number;
+    type: string;
+}
+
+declare interface PaginationInfo_2 {
+    total: number;
+    page: number;
+    limit: number;
+    pages: number;
+}
+
+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;
+}
+
+export declare interface QueryOptions {
+    fields?: string[];
+    sort?: Array<{
+        field: string;
+        order: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    offset?: number;
+    where?: Record<string, unknown>;
+}
+
+export declare interface ReadOperation<TQuery, TResult> {
+    findOne(options: TQuery): Promise<{
+        data: TResult | null;
+        error?: string;
+    }>;
+    findAll(options?: TQuery): Promise<{
+        data: TResult[];
+        pagination?: PaginationInfo;
+        error?: string;
+    }>;
+}
+
+/**
+ * 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;
+}
+
+export declare interface RecordCreateRequest {
+    [fieldName: string]: unknown;
+}
+
+export declare interface RecordData {
+    [fieldName: string]: unknown;
+    fields?: string[];
+}
+
+export declare interface RecordDeleteOptions {
+    record_ids?: string[];
+    filters?: ApiFilter[] | Record<string, unknown>;
+}
+
+export declare interface RecordDeleteResponse {
+    message: string;
+}
+
+export declare interface RecordListResponse {
+    data: RecordWithId[];
+    pagination: {
+        total_count: number;
+        total_pages: number;
+        current_page: number;
+        per_page: number;
+        type: string;
+    };
+}
+
+export 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>;
+    /**
+     * 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;
+}
+
+export declare interface RecordUpdateByIdOptions {
+    id: string;
+    set: RecordData;
+    fields?: string[];
+}
+
+export declare interface RecordUpdateOptions {
+    set: RecordData;
+    filters: ApiFilter[] | Record<string, unknown>[];
+    fields?: string[];
+}
+
+export declare interface RecordUpdateRequest {
+    [fieldName: string]: unknown;
+}
+
+export declare interface RecordWithId extends RecordData {
+    id: string;
+    created_at?: string;
+    updated_at?: string;
+}
+
+export declare type Region = 'asia-south1' | 'us-central1';
+
+export declare const REGION_CONFIGS: Record<Region, Record<Environment, EnvironmentConfig>>;
+
+declare type RequestInterceptor = (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
+
+declare type ResponseInterceptor = (response: HttpResponse) => HttpResponse | Promise<HttpResponse>;
+
+export declare class SchemaHelpers {
+    /**
+     * Create a text field definition
+     */
+    static textField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a number field definition
+     */
+    static numberField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a currency field definition
+     */
+    static currencyField(name: string, currency?: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a dropdown field definition
+     */
+    static dropdownField(name: string, items: string[], options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a vector field definition
+     */
+    static vectorField(name: string, dimension: number, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a JSON field definition
+     */
+    static jsonField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a date-time field definition
+     */
+    static dateTimeField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create an email field definition
+     */
+    static emailField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a long-text field definition
+     */
+    static longTextField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a link field definition
+     */
+    static linkField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a phone number field definition
+     */
+    static phoneNumberField(name: string, format?: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a checkbox field definition
+     */
+    static checkboxField(name: string, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a half-vector field definition
+     */
+    static halfVectorField(name: string, dimension: number, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a sparse vector field definition
+     */
+    static sparseVectorField(name: string, dimension: number, options?: Partial<FieldDefinition>): FieldDefinition;
+    /**
+     * Create a basic schema from field definitions
+     */
+    static createBasicSchema(fields: Array<{
+        name: string;
+        type: FieldType;
+    }>): FieldDefinition[];
+}
+
+export 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>;
+}
+
+export declare interface SuccessResponse<T> {
+    data: T;
+    error?: never;
+    pagination?: PaginationInfo;
+}
+
+export declare interface TableAccessRequest {
+    table_name: string;
+    is_shared: boolean;
+}
+
+/**
+ * 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 half-precision vector field
+     */
+    halfVector(name: string, dimension: number, options?: {
+        nullable?: boolean;
+        description?: string;
+    }): TableBuilder;
+    /**
+     * Add a sparse vector field
+     */
+    sparseVector(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>;
+}
+
+export declare interface TableCreateResponse {
+    id: string;
+    message: string;
+}
+
+export declare interface TableDeleteOptions {
+    where: {
+        id?: string;
+        name?: string;
+    };
+}
+
+declare interface TableListOptions extends TableQueryOptions {
+    page?: number;
+    pageSize?: number;
+    isShared?: boolean;
+}
+
+export declare interface TableListResponse {
+    tables: TableRecord[];
+    pagination: PaginationInfo_2;
+}
+
+export 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>;
+}
+
+export declare interface TableUpdateRequest {
+    name?: string;
+    description?: string;
+    is_shared?: boolean;
+    fields?: Array<keyof TableRecord>;
+}
+
+export declare interface TextToSQLApiRequest {
+    prompt: string;
+    current_query?: string;
+}
+
+export declare interface TextToSQLApiResponse {
+    data: string;
+}
+
+export 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;
+}
+
+export declare interface UpdateOperation<TUpdate, TResult> {
+    update(id: string, data: TUpdate): Promise<{
+        data: TResult;
+        error?: string;
+    }>;
+    update(options: {
+        where: Record<string, unknown>;
+        set: TUpdate;
+    }): Promise<{
+        data: TResult[];
+        error?: string;
+    }>;
+}
+
+/**
+ * Validation error for input validation failures
+ */
+export declare class ValidationError extends Error {
+    readonly failures: ValidationFailure[];
+    constructor(message: string, failures?: ValidationFailure[]);
+}
+
+/**
+ * Utility functions for working with standard Error classes
+ */
+export declare interface ValidationFailure {
+    field: string;
+    message: string;
+}
+
+export declare const VERSION = "1.0.0";
+
+export declare interface WhereCondition {
+    [fieldName: string]: unknown | QueryOperator;
+}
+
+declare interface WhereCondition_2 {
+    [field: string]: unknown;
+}
+
+export { }