@synapcores/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2473 @@
+import { AxiosInstance } from 'axios';
+import { EventEmitter } from 'events';
+export { z } from 'zod';
+
+/**
+ * Type definitions for collections
+ */
+interface Document {
+    id?: string;
+    data: Record<string, any>;
+    score?: number;
+    metadata?: Record<string, any>;
+}
+interface SearchResult {
+    documents: Document[];
+    total: number;
+    tookMs: number;
+    nextOffset?: number;
+}
+interface SearchOptions {
+    query?: string;
+    topK?: number;
+    filter?: Record<string, any>;
+    includeMetadata?: boolean;
+    offset?: number;
+}
+interface VectorSearchOptions$1 {
+    vector: number[];
+    field?: string;
+    topK?: number;
+    filter?: Record<string, any>;
+    distanceMetric?: 'cosine' | 'euclidean' | 'dot_product';
+    includeMetadata?: boolean;
+}
+interface QueryOptions {
+    filter?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+    sort?: Array<{
+        field: string;
+        order: 'asc' | 'desc';
+    }>;
+    projection?: string[];
+}
+interface InsertResult {
+    ids: string[];
+    inserted: number;
+}
+interface UpdateOptions {
+    merge?: boolean;
+}
+type FieldType = 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'json' | 'vector' | 'text' | 'binary';
+interface SchemaField {
+    name: string;
+    type: FieldType | `vector[${number}]`;
+    indexed?: boolean;
+    required?: boolean;
+    unique?: boolean;
+    default?: any;
+    description?: string;
+}
+interface CollectionSchema {
+    fields: SchemaField[];
+    primaryKey?: string;
+    vectorFields?: string[];
+}
+interface CollectionStats {
+    name: string;
+    documentCount: number;
+    sizeBytes: number;
+    indexCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface IndexOptions {
+    field: string;
+    type?: 'btree' | 'hash' | 'vector';
+    options?: Record<string, any>;
+}
+
+/**
+ * Type definitions for real-time subscriptions
+ */
+type ChangeOperation = 'insert' | 'update' | 'delete';
+interface SubscriptionEvent {
+    operation: ChangeOperation;
+    collection: string;
+    document: Document;
+    timestamp: Date;
+    sequence: number;
+}
+interface SubscriptionOptions {
+    filter?: Record<string, any>;
+    onChange?: (event: SubscriptionEvent) => void | Promise<void>;
+}
+
+/**
+ * Real-time subscription support for SynapCores SDK
+ */
+
+declare class Subscription extends EventEmitter {
+    private readonly collection;
+    private readonly options;
+    private ws?;
+    private running;
+    private reconnectTimeout?;
+    private reconnectAttempts;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelay;
+    constructor(collection: Collection, options?: SubscriptionOptions);
+    connect(): Promise<void>;
+    private createConnection;
+    private subscribe;
+    private handleMessage;
+    private scheduleReconnect;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<SubscriptionEvent>;
+}
+
+/**
+ * Collection class for SynapCores SDK
+ */
+
+declare class Collection {
+    private readonly client;
+    readonly name: string;
+    readonly schema?: Record<string, any> | undefined;
+    constructor(client: SynapCores, name: string, schema?: Record<string, any> | undefined);
+    private get basePath();
+    insert(documents: Record<string, any> | Record<string, any>[], _autoEmbed?: boolean): Promise<InsertResult>;
+    get(documentId: string): Promise<Document | null>;
+    update(documentId: string, data: Record<string, any>, options?: UpdateOptions): Promise<Document>;
+    delete(documentId: string | string[]): Promise<{
+        deleted: number;
+    }>;
+    search(options: SearchOptions): Promise<SearchResult>;
+    vectorSearch(options: VectorSearchOptions$1): Promise<SearchResult>;
+    query(options?: QueryOptions): Promise<SearchResult>;
+    count(filter?: Record<string, any>): Promise<number>;
+    stats(): Promise<CollectionStats>;
+    createIndex(options: IndexOptions): Promise<{
+        created: boolean;
+    }>;
+    dropIndex(field: string): Promise<{
+        dropped: boolean;
+    }>;
+    subscribe(options?: SubscriptionOptions): Promise<Subscription>;
+}
+
+/**
+ * Type definitions for AutoML
+ */
+interface ModelInfo {
+    id: string;
+    name: string;
+    task: 'regression' | 'classification' | 'clustering';
+    status: 'training' | 'ready' | 'failed';
+    accuracy?: number;
+    createdAt: Date;
+    updatedAt?: Date;
+    config: Record<string, any>;
+}
+interface TrainOptions {
+    collection: string;
+    target: string;
+    features?: string[];
+    task?: 'auto' | 'regression' | 'classification';
+    name?: string;
+    config?: Record<string, any>;
+    validationSplit?: number;
+    maxTrials?: number;
+    timeoutMinutes?: number;
+}
+interface PredictResult {
+    predictions: any[];
+    confidence?: number[];
+}
+interface EvaluationResult {
+    accuracy?: number;
+    precision?: number;
+    recall?: number;
+    f1Score?: number;
+    mse?: number;
+    rmse?: number;
+    mae?: number;
+    r2?: number;
+    confusionMatrix?: number[][];
+}
+interface AsyncTrainOptions extends TrainOptions {
+    /** Enable async training */
+    async?: boolean;
+    /** Callback URL for completion notification */
+    callback_url?: string;
+    /** Webhook for progress updates */
+    webhook_url?: string;
+}
+interface TrainingJob {
+    /** Job ID */
+    id: string;
+    /** Model name */
+    name: string;
+    /** Training status */
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Current phase */
+    phase?: string;
+    /** Model task type */
+    task: 'regression' | 'classification' | 'clustering' | 'auto';
+    /** Current trial number */
+    current_trial?: number;
+    /** Total trials */
+    total_trials?: number;
+    /** Best accuracy so far */
+    best_accuracy?: number;
+    /** Estimated time remaining (ms) */
+    eta_ms?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Started timestamp */
+    started_at: Date;
+    /** Completed timestamp */
+    completed_at?: Date;
+    /** Model ID (when completed) */
+    model_id?: string;
+}
+interface TrainingMetrics {
+    /** Trial number */
+    trial: number;
+    /** Accuracy */
+    accuracy?: number;
+    /** Loss */
+    loss?: number;
+    /** Additional metrics */
+    metrics?: Record<string, number>;
+    /** Timestamp */
+    timestamp: Date;
+}
+interface ListTrainingJobsOptions {
+    /** Filter by status */
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Page number */
+    page?: number;
+    /** Page size */
+    page_size?: number;
+}
+
+/**
+ * AutoML client for SynapCores SDK
+ */
+
+declare class AutoMLModel {
+    private readonly client;
+    readonly info: ModelInfo;
+    constructor(client: AutoMLClient, info: ModelInfo);
+    get id(): string;
+    get name(): string;
+    predict(data: Record<string, any> | Record<string, any>[]): Promise<any | any[]>;
+    evaluate(testData: string | Record<string, any>[], target?: string): Promise<EvaluationResult>;
+    delete(): Promise<void>;
+}
+declare class AutoMLClient {
+    readonly synapCores: SynapCores;
+    constructor(synapCores: SynapCores);
+    train(options: TrainOptions): Promise<AutoMLModel>;
+    getModel(modelId: string): Promise<AutoMLModel>;
+    listModels(filters?: {
+        task?: string;
+        status?: string;
+    }): Promise<ModelInfo[]>;
+    /**
+     * Start async training job
+     */
+    trainAsync(options: AsyncTrainOptions): Promise<TrainingJob>;
+    /**
+     * Get training job status
+     */
+    getTrainingJob(jobId: string): Promise<TrainingJob>;
+    /**
+     * List training jobs
+     */
+    listTrainingJobs(options?: ListTrainingJobsOptions): Promise<TrainingJob[]>;
+    /**
+     * Cancel a training job
+     */
+    cancelTrainingJob(jobId: string): Promise<void>;
+    /**
+     * Get training metrics for a job
+     */
+    getTrainingMetrics(jobId: string): Promise<TrainingMetrics[]>;
+    /**
+     * Wait for training job to complete
+     */
+    waitForTrainingJob(jobId: string, options?: {
+        pollInterval?: number;
+        timeout?: number;
+        onProgress?: (job: TrainingJob) => void;
+    }): Promise<AutoMLModel>;
+}
+
+/**
+ * Type definitions for NLP operations
+ */
+interface Sentiment {
+    label: 'positive' | 'negative' | 'neutral';
+    score: number;
+    confidence: number;
+}
+interface Entity {
+    text: string;
+    type: string;
+    start: number;
+    end: number;
+    score: number;
+}
+interface NLPAnalysis {
+    sentiment?: Sentiment;
+    entities?: Entity[];
+    summary?: string;
+    keywords?: string[];
+    language?: string;
+}
+interface AnalyzeOptions {
+    text: string | string[];
+    tasks?: Array<'sentiment' | 'entities' | 'summary' | 'keywords'>;
+    language?: string;
+}
+interface SummarizeOptions {
+    text: string;
+    maxLength?: number;
+    minLength?: number;
+}
+interface ClassifyOptions {
+    text: string | string[];
+    categories: string[];
+    multiLabel?: boolean;
+}
+
+/**
+ * NLP client for SynapCores SDK
+ */
+
+declare class NLPClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    analyze(options: AnalyzeOptions): Promise<NLPAnalysis | NLPAnalysis[]>;
+    summarize(options: SummarizeOptions): Promise<string>;
+    extractEntities(text: string, entityTypes?: string[]): Promise<Entity[]>;
+    sentiment(text: string | string[]): Promise<Sentiment | Sentiment[]>;
+    classify(options: ClassifyOptions): Promise<Record<string, number> | Record<string, number>[]>;
+}
+
+/**
+ * Recipe Management Types
+ */
+interface RecipeInfo {
+    /** Recipe ID */
+    id: string;
+    /** Recipe name */
+    name: string;
+    /** Recipe description */
+    description: string;
+    /** Recipe category */
+    category: string;
+    /** Recipe tags */
+    tags: string[];
+    /** Creation timestamp */
+    created_at: Date;
+    /** Last update timestamp */
+    updated_at: Date;
+    /** Author/creator */
+    author?: string;
+    /** Execution count */
+    execution_count?: number;
+}
+interface Recipe extends RecipeInfo {
+    /** Recipe content (markdown) */
+    content: string;
+    /** Recipe parameters */
+    parameters?: RecipeParameter[];
+    /** Recipe version */
+    version?: string;
+}
+interface RecipeParameter {
+    /** Parameter name */
+    name: string;
+    /** Parameter type */
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    /** Parameter description */
+    description?: string;
+    /** Whether parameter is required */
+    required?: boolean;
+    /** Default value */
+    default?: any;
+    /** Validation pattern (for strings) */
+    pattern?: string;
+}
+interface CreateRecipeOptions {
+    /** Recipe name */
+    name: string;
+    /** Recipe description */
+    description: string;
+    /** Recipe category */
+    category: string;
+    /** Recipe content (markdown) */
+    content: string;
+    /** Recipe tags */
+    tags?: string[];
+    /** Recipe parameters */
+    parameters?: RecipeParameter[];
+}
+interface ListRecipesOptions {
+    /** Filter by category */
+    category?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Search query */
+    search?: string;
+    /** Page number */
+    page?: number;
+    /** Page size */
+    page_size?: number;
+}
+interface ExecuteRecipeOptions {
+    /** Recipe ID or name */
+    recipe: string;
+    /** Recipe parameters */
+    parameters?: Record<string, any>;
+    /** Dry run (don't execute, just validate) */
+    dry_run?: boolean;
+}
+interface RecipeExecutionResult {
+    /** Execution ID */
+    id: string;
+    /** Whether execution succeeded */
+    success: boolean;
+    /** Results from SQL execution */
+    results?: any[];
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in milliseconds */
+    execution_time_ms: number;
+    /** Number of statements executed */
+    statements_executed: number;
+}
+interface GenerateRecipeOptions {
+    /** User's intent/description */
+    intent: string;
+    /** Recipe category */
+    category: string;
+    /** Optional context about database schema */
+    context?: string;
+}
+interface GeneratedRecipe {
+    /** Generated recipe name */
+    name: string;
+    /** Generated recipe description */
+    description: string;
+    /** Generated recipe content (markdown) */
+    content: string;
+}
+
+/**
+ * Recipe Management Client for SynapCores SDK
+ */
+
+declare class RecipeClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    /**
+     * Create a new recipe
+     */
+    create(options: CreateRecipeOptions): Promise<Recipe>;
+    /**
+     * List recipes with optional filters
+     */
+    list(options?: ListRecipesOptions): Promise<RecipeInfo[]>;
+    /**
+     * Get a specific recipe by ID
+     */
+    get(id: string): Promise<Recipe>;
+    /**
+     * Update an existing recipe
+     */
+    update(id: string, updates: Partial<CreateRecipeOptions>): Promise<Recipe>;
+    /**
+     * Delete a recipe
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Execute a recipe
+     */
+    execute(options: ExecuteRecipeOptions): Promise<RecipeExecutionResult>;
+    /**
+     * Generate a recipe using AI
+     */
+    generate(options: GenerateRecipeOptions): Promise<GeneratedRecipe>;
+    /**
+     * List available recipe categories
+     */
+    listCategories(): Promise<string[]>;
+}
+
+/**
+ * Schema Introspection Types
+ */
+interface TableInfo$1 {
+    /** Table name */
+    name: string;
+    /** Table type */
+    type: 'table' | 'view' | 'system';
+    /** Number of columns */
+    column_count: number;
+    /** Number of rows (approximate) */
+    row_count?: number;
+    /** Table size in bytes */
+    size_bytes?: number;
+    /** Creation timestamp */
+    created_at?: Date;
+    /** Last update timestamp */
+    updated_at?: Date;
+    /** Table comment/description */
+    comment?: string;
+}
+interface ColumnInfo {
+    /** Column name */
+    name: string;
+    /** Data type */
+    data_type: string;
+    /** Whether nullable */
+    nullable: boolean;
+    /** Default value */
+    default_value?: any;
+    /** Whether primary key */
+    is_primary_key?: boolean;
+    /** Whether unique */
+    is_unique?: boolean;
+    /** Whether indexed */
+    is_indexed?: boolean;
+    /** Foreign key reference */
+    foreign_key?: ForeignKeyReference;
+    /** Column comment/description */
+    comment?: string;
+    /** Column position */
+    ordinal_position?: number;
+}
+interface ForeignKeyReference {
+    /** Referenced table */
+    table: string;
+    /** Referenced column */
+    column: string;
+    /** On delete action */
+    on_delete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    /** On update action */
+    on_update?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+}
+interface IndexInfo {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Index type */
+    type: 'btree' | 'hash' | 'vector' | 'text';
+    /** Indexed columns */
+    columns: string[];
+    /** Whether unique */
+    is_unique: boolean;
+    /** Whether primary key */
+    is_primary: boolean;
+    /** Index size in bytes */
+    size_bytes?: number;
+    /** Creation timestamp */
+    created_at?: Date;
+}
+interface TableSchema {
+    /** Table info */
+    table: TableInfo$1;
+    /** Column definitions */
+    columns: ColumnInfo[];
+    /** Indexes */
+    indexes: IndexInfo[];
+    /** Constraints */
+    constraints: ConstraintInfo[];
+    /** Relationships */
+    relationships: RelationshipInfo[];
+}
+interface ConstraintInfo {
+    /** Constraint name */
+    name: string;
+    /** Constraint type */
+    type: 'PRIMARY KEY' | 'FOREIGN KEY' | 'UNIQUE' | 'CHECK' | 'NOT NULL';
+    /** Columns involved */
+    columns: string[];
+    /** Check expression (for CHECK constraints) */
+    expression?: string;
+    /** Referenced table (for FOREIGN KEY) */
+    referenced_table?: string;
+    /** Referenced columns (for FOREIGN KEY) */
+    referenced_columns?: string[];
+}
+interface RelationshipInfo {
+    /** Relationship type */
+    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+    /** Source table */
+    from_table: string;
+    /** Source column */
+    from_column: string;
+    /** Target table */
+    to_table: string;
+    /** Target column */
+    to_column: string;
+    /** Relationship name */
+    name?: string;
+}
+interface SchemaStatistics {
+    /** Total number of tables */
+    table_count: number;
+    /** Total number of views */
+    view_count: number;
+    /** Total number of indexes */
+    index_count: number;
+    /** Total number of relationships */
+    relationship_count: number;
+    /** Total database size in bytes */
+    total_size_bytes: number;
+    /** Total row count across all tables */
+    total_rows: number;
+    /** Database version */
+    version?: string;
+    /** Last analyzed timestamp */
+    analyzed_at?: Date;
+}
+interface ValidationResult {
+    /** Whether valid */
+    is_valid: boolean;
+    /** Validation errors */
+    errors: ValidationError$2[];
+    /** Validation warnings */
+    warnings: ValidationWarning$1[];
+}
+interface ValidationError$2 {
+    /** Error type */
+    type: string;
+    /** Error message */
+    message: string;
+    /** Location (table.column) */
+    location?: string;
+}
+interface ValidationWarning$1 {
+    /** Warning type */
+    type: string;
+    /** Warning message */
+    message: string;
+    /** Location (table.column) */
+    location?: string;
+    /** Suggested fix */
+    suggestion?: string;
+}
+
+/**
+ * Schema Introspection Client for SynapCores SDK
+ */
+
+declare class SchemaClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    /**
+     * List all tables in the database
+     */
+    listTables(options?: {
+        includeSystem?: boolean;
+    }): Promise<TableInfo$1[]>;
+    /**
+     * Get complete schema for a specific table
+     */
+    getTable(tableName: string): Promise<TableSchema>;
+    /**
+     * Get columns for a specific table
+     */
+    getColumns(tableName: string): Promise<ColumnInfo[]>;
+    /**
+     * Get indexes for a specific table
+     */
+    getIndexes(tableName: string): Promise<IndexInfo[]>;
+    /**
+     * Get all relationships in the database
+     */
+    getRelationships(): Promise<RelationshipInfo[]>;
+    /**
+     * Get schema statistics
+     */
+    getStatistics(): Promise<SchemaStatistics>;
+    /**
+     * Validate a schema definition
+     */
+    validateSchema(schema: object): Promise<ValidationResult>;
+    /**
+     * Compare two schemas
+     */
+    compareSchemas(schema1: string | object, schema2: string | object): Promise<{
+        differences: any[];
+        added: string[];
+        removed: string[];
+        modified: string[];
+    }>;
+    /**
+     * Generate SQL DDL for a table
+     */
+    generateDDL(tableName: string): Promise<string>;
+    /**
+     * Analyze table and update statistics
+     */
+    analyzeTable(tableName: string): Promise<void>;
+}
+
+/**
+ * Data Import/Export Types
+ */
+interface ImportOptions {
+    /** Target table name */
+    table: string;
+    /** Data format */
+    format: 'csv' | 'json' | 'ndjson';
+    /** File path or data content */
+    data: string | Buffer;
+    /** Import mode */
+    mode?: 'insert' | 'upsert' | 'replace';
+    /** Column mapping (source -> target) */
+    column_mapping?: Record<string, string>;
+    /** Skip header row (CSV only) */
+    skip_header?: boolean;
+    /** CSV delimiter (default: comma) */
+    delimiter?: string;
+    /** Batch size for inserts */
+    batch_size?: number;
+    /** Continue on error */
+    continue_on_error?: boolean;
+    /** Primary key columns for upsert mode */
+    primary_keys?: string[];
+}
+interface ImportResult {
+    /** Import job ID */
+    id: string;
+    /** Whether import succeeded */
+    success: boolean;
+    /** Number of rows processed */
+    rows_processed: number;
+    /** Number of rows imported */
+    rows_imported: number;
+    /** Number of rows failed */
+    rows_failed: number;
+    /** Import duration in milliseconds */
+    duration_ms: number;
+    /** Errors encountered */
+    errors?: ImportError[];
+    /** Warnings */
+    warnings?: string[];
+}
+interface ImportError {
+    /** Row number (1-based) */
+    row: number;
+    /** Error message */
+    message: string;
+    /** Raw row data */
+    data?: any;
+}
+interface ExportOptions {
+    /** Source table or query */
+    source: string;
+    /** Export format */
+    format: 'csv' | 'json' | 'ndjson';
+    /** Output destination */
+    destination?: 'file' | 'response';
+    /** Columns to export (default: all) */
+    columns?: string[];
+    /** WHERE clause filter */
+    filter?: string;
+    /** ORDER BY clause */
+    order_by?: string;
+    /** Limit number of rows */
+    limit?: number;
+    /** Include header row (CSV only) */
+    include_header?: boolean;
+    /** CSV delimiter (default: comma) */
+    delimiter?: string;
+    /** Compression (gzip) */
+    compress?: boolean;
+}
+interface ExportResult {
+    /** Export job ID */
+    id: string;
+    /** Whether export succeeded */
+    success: boolean;
+    /** Number of rows exported */
+    rows_exported: number;
+    /** Export duration in milliseconds */
+    duration_ms: number;
+    /** File path (if destination=file) */
+    file_path?: string;
+    /** Exported data (if destination=response) */
+    data?: string | Buffer;
+    /** File size in bytes */
+    size_bytes?: number;
+    /** Download URL (if applicable) */
+    download_url?: string;
+    /** Expiration time for download URL */
+    expires_at?: Date;
+}
+interface ImportJobStatus {
+    /** Job ID */
+    id: string;
+    /** Job status */
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Current phase */
+    phase?: string;
+    /** Rows processed so far */
+    rows_processed?: number;
+    /** Estimated time remaining (ms) */
+    eta_ms?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Started timestamp */
+    started_at?: Date;
+    /** Completed timestamp */
+    completed_at?: Date;
+}
+interface ExportJobStatus {
+    /** Job ID */
+    id: string;
+    /** Job status */
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Current phase */
+    phase?: string;
+    /** Rows exported so far */
+    rows_exported?: number;
+    /** Estimated time remaining (ms) */
+    eta_ms?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Started timestamp */
+    started_at?: Date;
+    /** Completed timestamp */
+    completed_at?: Date;
+}
+interface BulkImportOptions {
+    /** Import jobs to execute */
+    jobs: ImportOptions[];
+    /** Execute jobs in parallel */
+    parallel?: boolean;
+    /** Stop all on first error */
+    stop_on_error?: boolean;
+}
+interface BulkImportResult {
+    /** Bulk operation ID */
+    id: string;
+    /** Whether all imports succeeded */
+    success: boolean;
+    /** Individual job results */
+    results: ImportResult[];
+    /** Total rows imported across all jobs */
+    total_rows_imported: number;
+    /** Total duration in milliseconds */
+    total_duration_ms: number;
+}
+interface DataValidationOptions {
+    /** Target table */
+    table: string;
+    /** Data to validate */
+    data: any[];
+    /** Validation mode */
+    mode?: 'strict' | 'lenient';
+    /** Check foreign keys */
+    check_foreign_keys?: boolean;
+    /** Check unique constraints */
+    check_unique?: boolean;
+}
+interface DataValidationResult {
+    /** Whether data is valid */
+    is_valid: boolean;
+    /** Validation errors */
+    errors: ValidationError$1[];
+    /** Validation warnings */
+    warnings: ValidationWarning[];
+    /** Number of rows validated */
+    rows_validated: number;
+}
+interface ValidationError$1 {
+    /** Row number */
+    row: number;
+    /** Column name */
+    column?: string;
+    /** Error type */
+    type: 'type_mismatch' | 'constraint_violation' | 'foreign_key' | 'null_violation' | 'duplicate';
+    /** Error message */
+    message: string;
+    /** Actual value */
+    value?: any;
+}
+interface ValidationWarning {
+    /** Row number */
+    row: number;
+    /** Column name */
+    column?: string;
+    /** Warning type */
+    type: string;
+    /** Warning message */
+    message: string;
+}
+
+/**
+ * Data Import/Export Client for SynapCores SDK
+ */
+
+declare class ImportExportClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    /**
+     * Import data into a table
+     */
+    import(options: ImportOptions): Promise<ImportResult>;
+    /**
+     * Export data from a table or query
+     */
+    export(options: ExportOptions): Promise<ExportResult>;
+    /**
+     * Get import job status
+     */
+    getImportStatus(jobId: string): Promise<ImportJobStatus>;
+    /**
+     * Get export job status
+     */
+    getExportStatus(jobId: string): Promise<ExportJobStatus>;
+    /**
+     * Cancel an import job
+     */
+    cancelImport(jobId: string): Promise<void>;
+    /**
+     * Cancel an export job
+     */
+    cancelExport(jobId: string): Promise<void>;
+    /**
+     * Import data from multiple sources in bulk
+     */
+    bulkImport(options: BulkImportOptions): Promise<BulkImportResult>;
+    /**
+     * Validate data before import
+     */
+    validateData(options: DataValidationOptions): Promise<DataValidationResult>;
+    /**
+     * Get import template for a table
+     */
+    getImportTemplate(tableName: string, format?: 'csv' | 'json'): Promise<string>;
+    /**
+     * List import/export jobs
+     */
+    listJobs(options?: {
+        type?: 'import' | 'export';
+        status?: string;
+        limit?: number;
+    }): Promise<Array<ImportJobStatus | ExportJobStatus>>;
+    /**
+     * Download exported data
+     */
+    downloadExport(jobId: string): Promise<Buffer>;
+    /**
+     * Stream import data (for large files)
+     */
+    streamImport(options: ImportOptions, onProgress?: (progress: ImportJobStatus) => void): Promise<ImportResult>;
+    /**
+     * Stream export data (for large datasets)
+     */
+    streamExport(options: ExportOptions, onProgress?: (progress: ExportJobStatus) => void): Promise<ExportResult>;
+}
+
+/**
+ * Integration Management Types
+ */
+interface Integration {
+    /** Integration ID */
+    id: string;
+    /** Integration name */
+    name: string;
+    /** Integration type */
+    type: 'webhook' | 'api' | 'database' | 'messaging' | 'storage' | 'custom';
+    /** Integration status */
+    status: 'active' | 'inactive' | 'error';
+    /** Configuration */
+    config: IntegrationConfig;
+    /** Description */
+    description?: string;
+    /** Tags */
+    tags?: string[];
+    /** Creation timestamp */
+    created_at: Date;
+    /** Last update timestamp */
+    updated_at: Date;
+    /** Last successful execution */
+    last_success_at?: Date;
+    /** Last error */
+    last_error?: string;
+    /** Execution count */
+    execution_count?: number;
+}
+interface IntegrationConfig {
+    /** Endpoint URL (for webhook/api) */
+    url?: string;
+    /** HTTP method (for webhook/api) */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Headers */
+    headers?: Record<string, string>;
+    /** Authentication */
+    auth?: AuthConfig;
+    /** Connection string (for database) */
+    connection_string?: string;
+    /** Custom configuration */
+    custom?: Record<string, any>;
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Timeout in milliseconds */
+    timeout_ms?: number;
+}
+interface AuthConfig {
+    /** Auth type */
+    type: 'none' | 'basic' | 'bearer' | 'api_key' | 'oauth2' | 'custom';
+    /** Username (basic auth) */
+    username?: string;
+    /** Password (basic auth) */
+    password?: string;
+    /** Token (bearer auth) */
+    token?: string;
+    /** API key */
+    api_key?: string;
+    /** API key header name */
+    api_key_header?: string;
+    /** OAuth2 configuration */
+    oauth2?: OAuth2Config;
+    /** Custom auth data */
+    custom?: Record<string, any>;
+}
+interface OAuth2Config {
+    /** Client ID */
+    client_id: string;
+    /** Client secret */
+    client_secret: string;
+    /** Token URL */
+    token_url: string;
+    /** Scopes */
+    scopes?: string[];
+    /** Additional parameters */
+    params?: Record<string, string>;
+}
+interface RetryConfig {
+    /** Maximum retry attempts */
+    max_attempts: number;
+    /** Initial delay in milliseconds */
+    initial_delay_ms: number;
+    /** Maximum delay in milliseconds */
+    max_delay_ms: number;
+    /** Backoff multiplier */
+    backoff_multiplier?: number;
+    /** Retry on status codes */
+    retry_on_status?: number[];
+}
+interface CreateIntegrationOptions {
+    /** Integration name */
+    name: string;
+    /** Integration type */
+    type: 'webhook' | 'api' | 'database' | 'messaging' | 'storage' | 'custom';
+    /** Configuration */
+    config: IntegrationConfig;
+    /** Description */
+    description?: string;
+    /** Tags */
+    tags?: string[];
+    /** Auto-activate */
+    activate?: boolean;
+}
+interface ListIntegrationsOptions {
+    /** Filter by type */
+    type?: string;
+    /** Filter by status */
+    status?: 'active' | 'inactive' | 'error';
+    /** Filter by tags */
+    tags?: string[];
+    /** Search query */
+    search?: string;
+    /** Page number */
+    page?: number;
+    /** Page size */
+    page_size?: number;
+}
+interface ExecuteIntegrationOptions {
+    /** Integration ID or name */
+    integration: string;
+    /** Payload data */
+    payload?: any;
+    /** Override configuration */
+    config_override?: Partial<IntegrationConfig>;
+    /** Synchronous execution (wait for response) */
+    sync?: boolean;
+}
+interface IntegrationExecutionResult {
+    /** Execution ID */
+    id: string;
+    /** Whether execution succeeded */
+    success: boolean;
+    /** Response data */
+    response?: any;
+    /** HTTP status code (for webhooks/APIs) */
+    status_code?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in milliseconds */
+    execution_time_ms: number;
+    /** Retry count */
+    retry_count?: number;
+    /** Executed timestamp */
+    executed_at: Date;
+}
+interface IntegrationWebhook {
+    /** Webhook ID */
+    id: string;
+    /** Integration ID */
+    integration_id: string;
+    /** Event type */
+    event: string;
+    /** Webhook URL */
+    url: string;
+    /** Active status */
+    active: boolean;
+    /** Secret for signature verification */
+    secret?: string;
+    /** Created timestamp */
+    created_at: Date;
+}
+interface CreateWebhookOptions {
+    /** Integration ID */
+    integration_id: string;
+    /** Event type to trigger on */
+    event: string;
+    /** Webhook URL */
+    url: string;
+    /** Secret for signature verification */
+    secret?: string;
+    /** Auto-activate */
+    activate?: boolean;
+}
+interface IntegrationEvent {
+    /** Event ID */
+    id: string;
+    /** Integration ID */
+    integration_id: string;
+    /** Event type */
+    event: string;
+    /** Event data */
+    data: any;
+    /** Event timestamp */
+    timestamp: Date;
+    /** Status */
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    /** Error message if failed */
+    error?: string;
+}
+interface IntegrationLog {
+    /** Log ID */
+    id: string;
+    /** Integration ID */
+    integration_id: string;
+    /** Log level */
+    level: 'info' | 'warning' | 'error' | 'debug';
+    /** Log message */
+    message: string;
+    /** Additional data */
+    data?: any;
+    /** Timestamp */
+    timestamp: Date;
+}
+interface IntegrationStats {
+    /** Integration ID */
+    integration_id: string;
+    /** Total executions */
+    total_executions: number;
+    /** Successful executions */
+    successful_executions: number;
+    /** Failed executions */
+    failed_executions: number;
+    /** Average execution time (ms) */
+    avg_execution_time_ms: number;
+    /** Last 24h executions */
+    executions_24h: number;
+    /** Uptime percentage */
+    uptime_percentage: number;
+    /** Last success timestamp */
+    last_success_at?: Date;
+    /** Last error timestamp */
+    last_error_at?: Date;
+}
+interface TestIntegrationOptions {
+    /** Integration ID or name */
+    integration: string;
+    /** Test payload */
+    payload?: any;
+    /** Validate only (don't execute) */
+    validate_only?: boolean;
+}
+interface TestIntegrationResult {
+    /** Whether test succeeded */
+    success: boolean;
+    /** Validation errors */
+    validation_errors?: string[];
+    /** Test response */
+    response?: any;
+    /** Error message */
+    error?: string;
+    /** Latency in milliseconds */
+    latency_ms?: number;
+}
+
+/**
+ * Integration Management Client for SynapCores SDK
+ */
+
+declare class IntegrationClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    /**
+     * Create a new integration
+     */
+    create(options: CreateIntegrationOptions): Promise<Integration>;
+    /**
+     * List integrations with optional filters
+     */
+    list(options?: ListIntegrationsOptions): Promise<Integration[]>;
+    /**
+     * Get a specific integration by ID
+     */
+    get(id: string): Promise<Integration>;
+    /**
+     * Update an existing integration
+     */
+    update(id: string, updates: Partial<CreateIntegrationOptions>): Promise<Integration>;
+    /**
+     * Delete an integration
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Activate an integration
+     */
+    activate(id: string): Promise<Integration>;
+    /**
+     * Deactivate an integration
+     */
+    deactivate(id: string): Promise<Integration>;
+    /**
+     * Execute an integration
+     */
+    execute(options: ExecuteIntegrationOptions): Promise<IntegrationExecutionResult>;
+    /**
+     * Test an integration without executing
+     */
+    test(options: TestIntegrationOptions): Promise<TestIntegrationResult>;
+    /**
+     * Get integration execution history
+     */
+    getExecutionHistory(integrationId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IntegrationExecutionResult[]>;
+    /**
+     * Get integration statistics
+     */
+    getStats(integrationId: string): Promise<IntegrationStats>;
+    /**
+     * Create a webhook for an integration
+     */
+    createWebhook(options: CreateWebhookOptions): Promise<IntegrationWebhook>;
+    /**
+     * List webhooks for an integration
+     */
+    listWebhooks(integrationId: string): Promise<IntegrationWebhook[]>;
+    /**
+     * Delete a webhook
+     */
+    deleteWebhook(webhookId: string): Promise<void>;
+    /**
+     * Get integration events
+     */
+    getEvents(integrationId: string, options?: {
+        limit?: number;
+        status?: string;
+    }): Promise<IntegrationEvent[]>;
+    /**
+     * Get integration logs
+     */
+    getLogs(integrationId: string, options?: {
+        limit?: number;
+        level?: string;
+    }): Promise<IntegrationLog[]>;
+    /**
+     * Retry a failed execution
+     */
+    retryExecution(executionId: string): Promise<IntegrationExecutionResult>;
+    /**
+     * Map raw integration data to Integration type
+     */
+    private mapIntegration;
+}
+
+/**
+ * Backup/Restore Types
+ */
+interface BackupOptions {
+    /** Backup name */
+    name?: string;
+    /** Description */
+    description?: string;
+    /** Backup type */
+    type?: 'full' | 'incremental' | 'differential';
+    /** Tables to include (default: all) */
+    tables?: string[];
+    /** Include indexes */
+    include_indexes?: boolean;
+    /** Include procedures/triggers */
+    include_procedures?: boolean;
+    /** Compression level (0-9, default: 6) */
+    compression?: number;
+    /** Encryption enabled */
+    encrypt?: boolean;
+    /** Encryption key (if encrypt=true) */
+    encryption_key?: string;
+    /** Storage location */
+    storage?: 'local' | 's3' | 'gcs' | 'azure';
+    /** Storage configuration */
+    storage_config?: StorageConfig;
+    /** Tags */
+    tags?: string[];
+}
+interface StorageConfig {
+    /** S3 bucket name */
+    bucket?: string;
+    /** Storage region */
+    region?: string;
+    /** Access key ID */
+    access_key_id?: string;
+    /** Secret access key */
+    secret_access_key?: string;
+    /** Storage path prefix */
+    path_prefix?: string;
+    /** Custom endpoint URL */
+    endpoint?: string;
+    /** Additional configuration */
+    custom?: Record<string, any>;
+}
+interface Backup {
+    /** Backup ID */
+    id: string;
+    /** Backup name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Backup type */
+    type: 'full' | 'incremental' | 'differential';
+    /** Backup status */
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+    /** Size in bytes */
+    size_bytes?: number;
+    /** Compressed size in bytes */
+    compressed_size_bytes?: number;
+    /** Number of tables backed up */
+    table_count?: number;
+    /** Creation timestamp */
+    created_at: Date;
+    /** Completion timestamp */
+    completed_at?: Date;
+    /** Duration in milliseconds */
+    duration_ms?: number;
+    /** Storage location */
+    storage?: string;
+    /** Storage path */
+    storage_path?: string;
+    /** Encrypted */
+    encrypted: boolean;
+    /** Tags */
+    tags?: string[];
+    /** Parent backup ID (for incremental) */
+    parent_backup_id?: string;
+    /** Error message if failed */
+    error?: string;
+}
+interface RestoreOptions {
+    /** Backup ID to restore from */
+    backup_id: string;
+    /** Restore mode */
+    mode?: 'full' | 'partial';
+    /** Tables to restore (for partial restore) */
+    tables?: string[];
+    /** Target database name (if different) */
+    target_database?: string;
+    /** Overwrite existing data */
+    overwrite?: boolean;
+    /** Skip indexes */
+    skip_indexes?: boolean;
+    /** Skip procedures/triggers */
+    skip_procedures?: boolean;
+    /** Decryption key (if backup is encrypted) */
+    decryption_key?: string;
+    /** Point-in-time restore timestamp */
+    point_in_time?: Date;
+    /** Dry run (validate only) */
+    dry_run?: boolean;
+}
+interface RestoreResult {
+    /** Restore job ID */
+    id: string;
+    /** Whether restore succeeded */
+    success: boolean;
+    /** Tables restored */
+    tables_restored?: string[];
+    /** Rows restored */
+    rows_restored?: number;
+    /** Duration in milliseconds */
+    duration_ms: number;
+    /** Error message if failed */
+    error?: string;
+    /** Warnings */
+    warnings?: string[];
+}
+interface BackupStatus {
+    /** Backup ID */
+    id: string;
+    /** Status */
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Current phase */
+    phase?: string;
+    /** Tables processed */
+    tables_processed?: number;
+    /** Total tables */
+    total_tables?: number;
+    /** Bytes processed */
+    bytes_processed?: number;
+    /** Estimated time remaining (ms) */
+    eta_ms?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Started timestamp */
+    started_at?: Date;
+    /** Completed timestamp */
+    completed_at?: Date;
+}
+interface RestoreStatus {
+    /** Restore job ID */
+    id: string;
+    /** Status */
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Current phase */
+    phase?: string;
+    /** Tables processed */
+    tables_processed?: number;
+    /** Total tables */
+    total_tables?: number;
+    /** Rows processed */
+    rows_processed?: number;
+    /** Estimated time remaining (ms) */
+    eta_ms?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Started timestamp */
+    started_at?: Date;
+    /** Completed timestamp */
+    completed_at?: Date;
+}
+interface ListBackupsOptions {
+    /** Filter by type */
+    type?: 'full' | 'incremental' | 'differential';
+    /** Filter by status */
+    status?: string;
+    /** Filter by tags */
+    tags?: string[];
+    /** Sort order */
+    sort?: 'created_at' | 'size' | 'name';
+    /** Sort direction */
+    order?: 'asc' | 'desc';
+    /** Page number */
+    page?: number;
+    /** Page size */
+    page_size?: number;
+}
+interface BackupSchedule {
+    /** Schedule ID */
+    id: string;
+    /** Schedule name */
+    name: string;
+    /** Cron expression */
+    cron: string;
+    /** Backup options */
+    backup_options: BackupOptions;
+    /** Active status */
+    active: boolean;
+    /** Last run timestamp */
+    last_run_at?: Date;
+    /** Next run timestamp */
+    next_run_at?: Date;
+    /** Creation timestamp */
+    created_at: Date;
+    /** Tags */
+    tags?: string[];
+}
+interface CreateScheduleOptions {
+    /** Schedule name */
+    name: string;
+    /** Cron expression */
+    cron: string;
+    /** Backup options */
+    backup_options: BackupOptions;
+    /** Auto-activate */
+    activate?: boolean;
+    /** Tags */
+    tags?: string[];
+}
+interface BackupVerificationResult {
+    /** Whether backup is valid */
+    is_valid: boolean;
+    /** Integrity check passed */
+    integrity_ok: boolean;
+    /** Checksum match */
+    checksum_match?: boolean;
+    /** Tables verified */
+    tables_verified?: number;
+    /** Errors found */
+    errors?: string[];
+    /** Warnings */
+    warnings?: string[];
+    /** Verification timestamp */
+    verified_at: Date;
+}
+interface BackupMetrics {
+    /** Total backups */
+    total_backups: number;
+    /** Total size (bytes) */
+    total_size_bytes: number;
+    /** Successful backups */
+    successful_backups: number;
+    /** Failed backups */
+    failed_backups: number;
+    /** Average backup size (bytes) */
+    avg_backup_size_bytes: number;
+    /** Average backup duration (ms) */
+    avg_duration_ms: number;
+    /** Last backup timestamp */
+    last_backup_at?: Date;
+    /** Next scheduled backup */
+    next_scheduled_at?: Date;
+}
+
+/**
+ * Backup/Restore Client for SynapCores SDK
+ */
+
+declare class BackupClient {
+    private readonly synapCores;
+    constructor(synapCores: SynapCores);
+    /**
+     * Create a new backup
+     */
+    create(options?: BackupOptions): Promise<Backup>;
+    /**
+     * List backups with optional filters
+     */
+    list(options?: ListBackupsOptions): Promise<Backup[]>;
+    /**
+     * Get a specific backup by ID
+     */
+    get(id: string): Promise<Backup>;
+    /**
+     * Delete a backup
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Restore from a backup
+     */
+    restore(options: RestoreOptions): Promise<RestoreResult>;
+    /**
+     * Get backup status
+     */
+    getBackupStatus(backupId: string): Promise<BackupStatus>;
+    /**
+     * Get restore status
+     */
+    getRestoreStatus(restoreId: string): Promise<RestoreStatus>;
+    /**
+     * Cancel a backup in progress
+     */
+    cancelBackup(backupId: string): Promise<void>;
+    /**
+     * Cancel a restore in progress
+     */
+    cancelRestore(restoreId: string): Promise<void>;
+    /**
+     * Download a backup file
+     */
+    download(backupId: string): Promise<Buffer>;
+    /**
+     * Verify backup integrity
+     */
+    verify(backupId: string): Promise<BackupVerificationResult>;
+    /**
+     * Create a backup schedule
+     */
+    createSchedule(options: CreateScheduleOptions): Promise<BackupSchedule>;
+    /**
+     * List backup schedules
+     */
+    listSchedules(): Promise<BackupSchedule[]>;
+    /**
+     * Get a specific schedule
+     */
+    getSchedule(scheduleId: string): Promise<BackupSchedule>;
+    /**
+     * Update a backup schedule
+     */
+    updateSchedule(scheduleId: string, updates: Partial<CreateScheduleOptions>): Promise<BackupSchedule>;
+    /**
+     * Delete a backup schedule
+     */
+    deleteSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Activate a schedule
+     */
+    activateSchedule(scheduleId: string): Promise<BackupSchedule>;
+    /**
+     * Deactivate a schedule
+     */
+    deactivateSchedule(scheduleId: string): Promise<BackupSchedule>;
+    /**
+     * Get backup metrics
+     */
+    getMetrics(): Promise<BackupMetrics>;
+    /**
+     * Map raw backup data to Backup type
+     */
+    private mapBackup;
+}
+
+/**
+ * Type definitions for SynapCores client
+ */
+interface SynapCoresConfig {
+    host?: string;
+    port?: number;
+    apiKey?: string;
+    jwtToken?: string;
+    useHttps?: boolean;
+    timeout?: number;
+    maxRetries?: number;
+    rejectUnauthorized?: boolean;
+}
+interface QueryColumn {
+    name: string;
+    data_type: string;
+    nullable: boolean;
+}
+interface QueryResult {
+    columns: QueryColumn[];
+    rows: any[][];
+    rows_affected?: number;
+    execution_time_ms: number;
+    queryPlan?: Record<string, any>;
+}
+interface EmbedOptions {
+    model?: string;
+}
+interface ColumnDefinition {
+    name: string;
+    dataType: string;
+    constraints?: ColumnConstraint[];
+    defaultValue?: any;
+}
+interface ColumnConstraint {
+    type: 'PRIMARY_KEY' | 'UNIQUE' | 'NOT_NULL' | 'CHECK' | 'FOREIGN_KEY' | 'DEFAULT';
+    expression?: string;
+    referencedTable?: string;
+    referencedColumn?: string;
+}
+interface TableConstraint {
+    type: 'PRIMARY_KEY' | 'UNIQUE' | 'CHECK' | 'FOREIGN_KEY';
+    columns: string[];
+    expression?: string;
+    referencedTable?: string;
+    referencedColumns?: string[];
+}
+interface CreateTableOptions {
+    ifNotExists?: boolean;
+    constraints?: TableConstraint[];
+    partitionBy?: {
+        type: 'RANGE' | 'LIST' | 'HASH';
+        column: string;
+    };
+}
+interface AlterTableOptions {
+    action: 'ADD_COLUMN' | 'DROP_COLUMN' | 'RENAME_COLUMN' | 'ALTER_COLUMN' | 'ADD_CONSTRAINT' | 'DROP_CONSTRAINT';
+    columnName?: string;
+    newColumnName?: string;
+    columnDefinition?: ColumnDefinition;
+    newDataType?: string;
+    constraint?: TableConstraint;
+    constraintName?: string;
+}
+interface IndexDefinition {
+    name: string;
+    tableName: string;
+    columns: Array<{
+        name: string;
+        order?: 'ASC' | 'DESC';
+    }>;
+    unique?: boolean;
+    ifNotExists?: boolean;
+}
+interface TableInfo {
+    name: string;
+    columns: Array<{
+        name: string;
+        type: string;
+        nullable: boolean;
+        defaultValue?: any;
+        isPrimaryKey: boolean;
+        isUnique: boolean;
+    }>;
+    constraints: TableConstraint[];
+    indexes: Array<{
+        name: string;
+        columns: string[];
+        unique: boolean;
+    }>;
+}
+interface TransactionOptions {
+    isolationLevel?: 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
+    readOnly?: boolean;
+    timeout?: number;
+}
+interface TransactionContext {
+    id: string;
+    startTime: Date;
+    isolationLevel: string;
+    readOnly: boolean;
+}
+interface BatchInsertOptions {
+    tableName: string;
+    columns?: string[];
+    rows: Record<string, any>[];
+    onConflict?: 'IGNORE' | 'REPLACE' | 'UPDATE';
+    batchSize?: number;
+}
+interface BatchUpdateOptions {
+    tableName: string;
+    updates: Array<{
+        set: Record<string, any>;
+        where: Record<string, any>;
+    }>;
+    batchSize?: number;
+}
+interface BatchDeleteOptions {
+    tableName: string;
+    whereConditions: Record<string, any>[];
+    batchSize?: number;
+}
+interface BatchResult {
+    totalProcessed: number;
+    successful: number;
+    failed: number;
+    errors?: Array<{
+        index: number;
+        error: string;
+    }>;
+    tookMs: number;
+}
+interface PreparedStatement {
+    id: string;
+    sql: string;
+    parameterCount: number;
+}
+interface PreparedStatementOptions {
+    name?: string;
+    parameterTypes?: string[];
+}
+interface CTEDefinition {
+    name: string;
+    columns?: string[];
+    query: string;
+}
+interface WindowFunctionOptions {
+    partitionBy?: string[];
+    orderBy?: Array<{
+        column: string;
+        direction: 'ASC' | 'DESC';
+    }>;
+    frame?: {
+        type: 'ROWS' | 'RANGE';
+        start: string;
+        end?: string;
+    };
+}
+interface Vector {
+    values: number[];
+    dimensions: number;
+}
+interface VectorArithmeticResult {
+    result: Vector;
+    operation: string;
+    tookMs: number;
+}
+interface VectorSimilarityResult {
+    similarity: number;
+    distance?: number;
+    function: 'cosine' | 'euclidean' | 'inner_product' | 'l2';
+    tookMs: number;
+}
+interface VectorSearchOptions {
+    vector: number[];
+    k?: number;
+    threshold?: number;
+    metric?: 'cosine' | 'euclidean' | 'inner_product' | 'l2';
+    filter?: Record<string, any>;
+}
+interface VectorSearchResult {
+    id: string;
+    vector: number[];
+    similarity: number;
+    distance: number;
+    metadata?: Record<string, any>;
+}
+interface HybridSearchOptions extends VectorSearchOptions {
+    textQuery?: string;
+    sqlFilter?: string;
+    weights?: {
+        vector: number;
+        text: number;
+    };
+}
+interface KNNSearchOptions {
+    queryVector: number[];
+    k: number;
+    tableName: string;
+    vectorColumn: string;
+    metadataColumns?: string[];
+    filter?: Record<string, any>;
+}
+interface RangeSearchOptions {
+    queryVector: number[];
+    threshold: number;
+    tableName: string;
+    vectorColumn: string;
+    metadataColumns?: string[];
+    filter?: Record<string, any>;
+    maxResults?: number;
+}
+interface QueryPerformance {
+    queryId: string;
+    sql: string;
+    executionTimeMs: number;
+    rowsAffected: number;
+    memoryUsageMB: number;
+    indexesUsed: string[];
+    partitionsPruned?: number;
+}
+interface ConnectionPool {
+    active: number;
+    idle: number;
+    total: number;
+    maxConnections: number;
+    waitingRequests: number;
+}
+interface RegisterRequest {
+    username: string;
+    email: string;
+    password: string;
+}
+interface RegisterResponse {
+    id: string;
+    username: string;
+    email: string;
+    is_active: boolean;
+    is_verified: boolean;
+    roles: string[];
+    created_at: string;
+    last_login: string | null;
+}
+interface LoginRequest {
+    username: string;
+    password: string;
+}
+interface LoginResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+}
+interface RefreshResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+}
+interface CreateAPIKeyRequest {
+    name: string;
+    permission: 'ReadOnly' | 'FullAccess';
+    expires_in_days?: number;
+}
+interface APIKeyInfo {
+    id: string;
+    name: string;
+    key_preview: string;
+    permission: 'ReadOnly' | 'FullAccess';
+    is_active: boolean;
+    expires_at: string | null;
+    created_at: string;
+    last_used: string | null;
+    usage_count: number;
+}
+interface CreateAPIKeyResponse {
+    api_key: APIKeyInfo;
+    raw_key: string;
+}
+interface ListAPIKeysResponse {
+    keys: APIKeyInfo[];
+    total: number;
+}
+interface APIKeyStats {
+    total_requests: number;
+    requests_last_24h: number;
+    requests_last_7d: number;
+    requests_last_30d: number;
+    last_request_at: string | null;
+    most_used_endpoints: Array<{
+        endpoint: string;
+        method: string;
+        count: number;
+        percentage: number;
+    }>;
+}
+interface ExecuteQueryRequest {
+    sql: string;
+    parameters?: any[];
+    max_rows?: number;
+    timeout_secs?: number;
+}
+interface BatchQueryRequest {
+    queries: Array<{
+        sql: string;
+        parameters?: any[];
+    }>;
+    transactional?: boolean;
+}
+interface BatchQueryResult {
+    type: 'success' | 'error';
+    data?: QueryResult;
+    error?: {
+        message: string;
+        code: string;
+    };
+}
+interface BatchQueryResponse {
+    results: BatchQueryResult[];
+    total_execution_time_ms: number;
+}
+interface CollectionFieldDefinition {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'vector' | 'image' | 'audio' | 'video';
+    required: boolean;
+    description?: string;
+}
+interface CollectionIndexDefinition {
+    name: string;
+    fields: string[];
+    type: 'btree' | 'hash' | 'vector' | 'text';
+    unique?: boolean;
+}
+interface CollectionSchemaDefinition {
+    fields: CollectionFieldDefinition[];
+    indexes?: CollectionIndexDefinition[];
+}
+interface CreateCollectionRequest {
+    name: string;
+    description?: string;
+    schema?: CollectionSchemaDefinition;
+}
+interface CollectionInfo {
+    id: string;
+    name: string;
+    description?: string;
+    schema?: CollectionSchemaDefinition;
+    documentCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateCollectionResponse {
+    collection: CollectionInfo;
+}
+interface ListCollectionsResponse {
+    collections: CollectionInfo[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+interface UploadMultimediaRequest {
+    file: File | Blob | Buffer;
+    metadata?: Record<string, any>;
+}
+interface MultimediaInfo {
+    id: string;
+    file_name: string;
+    file_type: string;
+    file_size: number;
+    content_type: string;
+    document_id: string;
+    collection: string;
+    storage_path: string;
+    uploaded_at: string;
+    metadata?: Record<string, any>;
+    extracted_text?: string | null;
+    thumbnail_url?: string;
+}
+interface ListMultimediaResponse {
+    items: Array<{
+        id: string;
+        file_name: string;
+        file_type: string;
+        file_size: number;
+        uploaded_at: string;
+    }>;
+    total: number;
+    limit: number;
+    offset: number;
+}
+
+/**
+ * Main client for SynapCores SDK
+ */
+
+declare class SynapCores {
+    private readonly config;
+    private readonly httpClient;
+    private readonly collectionsCache;
+    private currentTransaction;
+    private preparedStatements;
+    readonly automl: AutoMLClient;
+    readonly nlp: NLPClient;
+    readonly recipes: RecipeClient;
+    readonly schema: SchemaClient;
+    readonly import: ImportExportClient;
+    readonly integrations: IntegrationClient;
+    readonly backup: BackupClient;
+    constructor(config?: SynapCoresConfig);
+    private handleError;
+    /**
+     * Create collection (legacy method for backward compatibility)
+     */
+    createCollection(options: {
+        name: string;
+        schema?: Record<string, any>;
+        [key: string]: any;
+    }): Promise<Collection>;
+    /**
+     * Create collection matching the database integration guide format
+     */
+    createCollectionWithSchema(request: CreateCollectionRequest): Promise<Collection>;
+    getCollection(name: string): Promise<Collection>;
+    /**
+     * List collections (legacy method for backward compatibility)
+     */
+    listCollections(): Promise<string[]>;
+    /**
+     * List collections with detailed information matching the database integration guide format
+     */
+    listCollectionsDetailed(options?: {
+        page?: number;
+        pageSize?: number;
+        search?: string;
+        sortBy?: string;
+        sortOrder?: 'asc' | 'desc';
+    }): Promise<ListCollectionsResponse>;
+    getDocuments(collectionName: string, page: number, pageSize: number): Promise<Document[]>;
+    deleteCollection(name: string): Promise<void>;
+    /**
+     * Execute SQL query (legacy method for backward compatibility)
+     * @deprecated Use executeQuery for new code
+     */
+    sql(query: string, params?: Record<string, any>): Promise<QueryResult>;
+    /**
+     * Execute SQL query matching the database integration guide format
+     */
+    executeQuery(request: ExecuteQueryRequest): Promise<QueryResult>;
+    /**
+     * Execute batch queries
+     */
+    executeBatchQueries(request: BatchQueryRequest): Promise<BatchQueryResponse>;
+    embed(text: string | string[], options?: EmbedOptions): Promise<number[] | number[][]>;
+    _getHttpClient(): AxiosInstance;
+    /**
+     * Creates a new table with the specified columns and constraints
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions for the table
+     * @param options - Additional table creation options
+     * @returns Promise resolving to table creation result
+     */
+    createTable(tableName: string, columns: ColumnDefinition[], options?: CreateTableOptions): Promise<QueryResult>;
+    /**
+     * Alters an existing table structure
+     * @param tableName - Name of the table to alter
+     * @param alterOptions - Alteration options and parameters
+     * @returns Promise resolving to alteration result
+     */
+    alterTable(tableName: string, alterOptions: AlterTableOptions): Promise<QueryResult>;
+    /**
+     * Drops an existing table
+     * @param tableName - Name of the table to drop
+     * @param options - Drop options
+     * @returns Promise resolving to drop result
+     */
+    dropTable(tableName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<QueryResult>;
+    /**
+     * Describes a table structure including columns, constraints, and indexes
+     * @param tableName - Name of the table to describe
+     * @returns Promise resolving to table information
+     */
+    describeTable(tableName: string): Promise<TableInfo>;
+    /**
+     * Lists all tables in the current database
+     * @param pattern - Optional pattern to filter table names
+     * @returns Promise resolving to array of table names
+     */
+    showTables(pattern?: string): Promise<string[]>;
+    /**
+     * Creates an index on a table
+     * @param indexDef - Index definition with name, table, columns, and options
+     * @returns Promise resolving to index creation result
+     */
+    createIndex(indexDef: IndexDefinition): Promise<QueryResult>;
+    /**
+     * Drops an existing index
+     * @param indexName - Name of the index to drop
+     * @param options - Drop options
+     * @returns Promise resolving to drop result
+     */
+    dropIndex(indexName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<QueryResult>;
+    /**
+     * Lists all indexes, optionally filtered by table name
+     * @param tableName - Optional table name to filter indexes
+     * @returns Promise resolving to array of index information
+     */
+    showIndexes(tableName?: string): Promise<Array<{
+        name: string;
+        table: string;
+        columns: string[];
+        unique: boolean;
+    }>>;
+    /**
+     * Begins a new transaction
+     * @param options - Transaction options including isolation level
+     * @returns Promise resolving to transaction context
+     */
+    beginTransaction(options?: TransactionOptions): Promise<TransactionContext>;
+    /**
+     * Commits the current transaction
+     * @returns Promise resolving when transaction is committed
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rolls back the current transaction
+     * @returns Promise resolving when transaction is rolled back
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Gets the current transaction context
+     * @returns Current transaction context or null if no transaction
+     */
+    getCurrentTransaction(): TransactionContext | null;
+    /**
+     * Performs batch insert operations
+     * @param options - Batch insert options with table, columns, and rows
+     * @returns Promise resolving to batch operation result
+     */
+    batchInsert(options: BatchInsertOptions): Promise<BatchResult>;
+    /**
+     * Performs batch update operations
+     * @param options - Batch update options with table and update conditions
+     * @returns Promise resolving to batch operation result
+     */
+    batchUpdate(options: BatchUpdateOptions): Promise<BatchResult>;
+    /**
+     * Performs batch delete operations
+     * @param options - Batch delete options with table and where conditions
+     * @returns Promise resolving to batch operation result
+     */
+    batchDelete(options: BatchDeleteOptions): Promise<BatchResult>;
+    /**
+     * Prepares a SQL statement for repeated execution
+     * @param sql - SQL statement to prepare
+     * @param options - Preparation options
+     * @returns Promise resolving to prepared statement
+     */
+    prepareStatement(sql: string, options?: PreparedStatementOptions): Promise<PreparedStatement>;
+    /**
+     * Executes a prepared statement with parameters
+     * @param statementId - ID of the prepared statement or statement name
+     * @param params - Parameters for the prepared statement
+     * @returns Promise resolving to query result
+     */
+    executePrepared(statementId: string, params?: any[]): Promise<QueryResult>;
+    /**
+     * Deallocates a prepared statement
+     * @param statementId - ID of the prepared statement or statement name
+     * @returns Promise resolving when statement is deallocated
+     */
+    deallocatePrepared(statementId: string): Promise<void>;
+    /**
+     * Executes a query with Common Table Expressions (CTEs)
+     * @param ctes - Array of CTE definitions
+     * @param mainQuery - Main query that uses the CTEs
+     * @param params - Optional parameters for the query
+     * @returns Promise resolving to query result
+     */
+    queryWithCTEs(ctes: CTEDefinition[], mainQuery: string, params?: Record<string, any>): Promise<QueryResult>;
+    /**
+     * Executes a query with window functions
+     * @param selectQuery - Base SELECT query
+     * @param windowFunctions - Array of window function definitions
+     * @param params - Optional parameters for the query
+     * @returns Promise resolving to query result
+     */
+    queryWithWindowFunctions(selectQuery: string, windowFunctions: Array<{
+        alias: string;
+        function: string;
+        options: WindowFunctionOptions;
+    }>, params?: Record<string, any>): Promise<QueryResult>;
+    /**
+     * Performs JSON operations on JSON/JSONB columns
+     * @param tableName - Table containing JSON data
+     * @param jsonColumn - Name of the JSON column
+     * @param operation - JSON operation to perform
+     * @param path - JSON path for the operation
+     * @param value - Value for update operations
+     * @param whereClause - Optional WHERE clause
+     * @returns Promise resolving to query result
+     */
+    jsonQuery(tableName: string, jsonColumn: string, operation: 'extract' | 'update' | 'delete' | 'contains', path: string, value?: any, whereClause?: string): Promise<QueryResult>;
+    /**
+     * Performs vector addition
+     * @param vector1 - First vector
+     * @param vector2 - Second vector
+     * @returns Promise resolving to vector addition result
+     */
+    vectorAdd(vector1: number[], vector2: number[]): Promise<VectorArithmeticResult>;
+    /**
+     * Performs vector subtraction
+     * @param vector1 - First vector (minuend)
+     * @param vector2 - Second vector (subtrahend)
+     * @returns Promise resolving to vector subtraction result
+     */
+    vectorSubtract(vector1: number[], vector2: number[]): Promise<VectorArithmeticResult>;
+    /**
+     * Performs scalar multiplication on a vector
+     * @param vector - Input vector
+     * @param scalar - Scalar value to multiply by
+     * @returns Promise resolving to scalar multiplication result
+     */
+    vectorScalarMultiply(vector: number[], scalar: number): Promise<VectorArithmeticResult>;
+    /**
+     * Calculates the dot product of two vectors
+     * @param vector1 - First vector
+     * @param vector2 - Second vector
+     * @returns Promise resolving to dot product result
+     */
+    vectorDotProduct(vector1: number[], vector2: number[]): Promise<{
+        dotProduct: number;
+        tookMs: number;
+    }>;
+    /**
+     * Calculates cosine similarity between two vectors
+     * @param vector1 - First vector
+     * @param vector2 - Second vector
+     * @returns Promise resolving to cosine similarity result
+     */
+    cosineSimilarity(vector1: number[], vector2: number[]): Promise<VectorSimilarityResult>;
+    /**
+     * Calculates L2 (Euclidean) distance between two vectors
+     * @param vector1 - First vector
+     * @param vector2 - Second vector
+     * @returns Promise resolving to L2 distance result
+     */
+    l2Distance(vector1: number[], vector2: number[]): Promise<VectorSimilarityResult>;
+    /**
+     * Calculates inner product between two vectors
+     * @param vector1 - First vector
+     * @param vector2 - Second vector
+     * @returns Promise resolving to inner product result
+     */
+    innerProduct(vector1: number[], vector2: number[]): Promise<VectorSimilarityResult>;
+    /**
+     * Performs K-nearest neighbors vector search
+     * @param options - KNN search options
+     * @returns Promise resolving to KNN search results
+     */
+    knnSearch(options: KNNSearchOptions): Promise<VectorSearchResult[]>;
+    /**
+     * Performs range-based vector similarity search
+     * @param options - Range search options
+     * @returns Promise resolving to range search results
+     */
+    rangeSearch(options: RangeSearchOptions): Promise<VectorSearchResult[]>;
+    /**
+     * Performs hybrid search combining vector similarity and SQL filtering
+     * @param options - Hybrid search options
+     * @returns Promise resolving to hybrid search results
+     */
+    hybridSearch(options: HybridSearchOptions): Promise<VectorSearchResult[]>;
+    /**
+     * Normalizes a vector to unit length
+     * @param vector - Input vector to normalize
+     * @returns Promise resolving to normalized vector
+     */
+    normalizeVector(vector: number[]): Promise<VectorArithmeticResult>;
+    /**
+     * Calculates the magnitude (length) of a vector
+     * @param vector - Input vector
+     * @returns Promise resolving to vector magnitude
+     */
+    vectorMagnitude(vector: number[]): Promise<{
+        magnitude: number;
+        tookMs: number;
+    }>;
+    /**
+     * Register a new user
+     */
+    registerUser(request: RegisterRequest): Promise<RegisterResponse>;
+    /**
+     * Login with username and password
+     */
+    login(request: LoginRequest): Promise<LoginResponse>;
+    /**
+     * Refresh JWT token
+     */
+    refreshToken(): Promise<RefreshResponse>;
+    /**
+     * Set JWT token manually (useful after login)
+     */
+    setJWTToken(token: string): void;
+    /**
+     * Clear authentication (logout)
+     */
+    logout(): void;
+    /**
+     * Create a new API key
+     */
+    createAPIKey(request: CreateAPIKeyRequest): Promise<CreateAPIKeyResponse>;
+    /**
+     * List all API keys
+     */
+    listAPIKeys(): Promise<ListAPIKeysResponse>;
+    /**
+     * Get API key statistics
+     */
+    getAPIKeyStats(keyId: string): Promise<APIKeyStats>;
+    /**
+     * Revoke (delete) an API key
+     */
+    revokeAPIKey(keyId: string): Promise<void>;
+    /**
+     * Upload multimedia file to a document
+     */
+    uploadMultimedia(collection: string, documentId: string, file: File | Blob | Buffer, metadata?: Record<string, any>): Promise<MultimediaInfo>;
+    /**
+     * Get multimedia file URL (for viewing/downloading)
+     */
+    getMultimediaUrl(collection: string, documentId: string, multimediaId: string, download?: boolean): string;
+    /**
+     * Get multimedia thumbnail URL
+     */
+    getMultimediaThumbnailUrl(collection: string, documentId: string, multimediaId: string): string;
+    /**
+     * List multimedia files in a document
+     */
+    listMultimedia(collection: string, documentId: string, limit?: number, offset?: number): Promise<ListMultimediaResponse>;
+    /**
+     * Get multimedia file information
+     */
+    getMultimedia(collection: string, documentId: string, multimediaId: string): Promise<MultimediaInfo>;
+    /**
+     * Delete multimedia file
+     */
+    deleteMultimedia(collection: string, documentId: string, multimediaId: string): Promise<void>;
+}
+
+/**
+ * Error classes for SynapCores SDK
+ */
+declare class SynapCoresError extends Error {
+    readonly code?: string;
+    readonly details?: Record<string, any>;
+    constructor(message: string, code?: string, details?: Record<string, any>);
+}
+declare class ConnectionError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class AuthenticationError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class ValidationError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class NotFoundError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class ServerError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class TimeoutError extends SynapCoresError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class RateLimitError extends SynapCoresError {
+    readonly retryAfter?: number;
+    constructor(message: string, retryAfter?: number, details?: Record<string, any>);
+}
+declare class SQLError extends SynapCoresError {
+    readonly severity: 'ERROR' | 'WARNING' | 'INFO';
+    readonly position?: number;
+    readonly hint?: string;
+    readonly detail?: string;
+    constructor(message: string, code: string, severity?: 'ERROR' | 'WARNING' | 'INFO', position?: number, hint?: string, detail?: string, details?: Record<string, any>);
+}
+declare class VectorError extends SynapCoresError {
+    readonly vectorDimensions?: number;
+    readonly expectedDimensions?: number;
+    readonly operation?: string;
+    constructor(message: string, code: string, vectorDimensions?: number, expectedDimensions?: number, operation?: string, details?: Record<string, any>);
+}
+declare class TransactionError extends SynapCoresError {
+    readonly transactionId?: string;
+    readonly transactionState?: string;
+    constructor(message: string, code: string, transactionId?: string, transactionState?: string, details?: Record<string, any>);
+}
+declare class BatchOperationError extends SynapCoresError {
+    readonly failedItems?: Array<{
+        index: number;
+        error: string;
+    }>;
+    readonly totalProcessed?: number;
+    readonly successfulCount?: number;
+    constructor(message: string, code: string, failedItems?: Array<{
+        index: number;
+        error: string;
+    }>, totalProcessed?: number, successfulCount?: number, details?: Record<string, any>);
+}
+
+/**
+ * SynapCores Node.js/TypeScript SDK
+ *
+ * Official SDK for SynapCores AI-Native Database Management System.
+ */
+
+declare const VERSION = "0.1.0";
+
+export { type APIKeyInfo, type APIKeyStats, type AlterTableOptions, type AnalyzeOptions, type AsyncTrainOptions, type AuthConfig, AuthenticationError, AutoMLClient, AutoMLModel, type Backup, BackupClient, type BackupMetrics, type BackupOptions, type BackupSchedule, type BackupStatus, type BackupVerificationResult, type BatchDeleteOptions, type BatchInsertOptions, BatchOperationError, type BatchQueryRequest, type BatchQueryResponse, type BatchQueryResult, type BatchResult, type BatchUpdateOptions, type BulkImportOptions, type BulkImportResult, type CTEDefinition, type ChangeOperation, Collection, type CollectionFieldDefinition, type CollectionIndexDefinition, type CollectionInfo, type CollectionSchema, type CollectionSchemaDefinition, type CollectionStats, type ColumnConstraint, type ColumnDefinition, type ColumnInfo, ConnectionError, type ConnectionPool, type ConstraintInfo, type CreateAPIKeyRequest, type CreateAPIKeyResponse, type CreateCollectionRequest, type CreateCollectionResponse, type CreateIntegrationOptions, type CreateRecipeOptions, type CreateScheduleOptions, type CreateTableOptions, type CreateWebhookOptions, type DataValidationOptions, type DataValidationResult, type Document, type EmbedOptions, type Entity, type EvaluationResult, type ExecuteIntegrationOptions, type ExecuteQueryRequest, type ExecuteRecipeOptions, type ExportJobStatus, type ExportOptions, type ExportResult, type ForeignKeyReference, type GenerateRecipeOptions, type GeneratedRecipe, type HybridSearchOptions, type ImportError, ImportExportClient, type ImportJobStatus, type ImportOptions, type ImportResult, type ValidationError$1 as ImportValidationError, type ValidationWarning as ImportValidationWarning, type IndexDefinition, type IndexInfo, type InsertResult, type Integration, IntegrationClient, type IntegrationConfig, type IntegrationEvent, type IntegrationExecutionResult, type IntegrationLog, type IntegrationStats, type IntegrationWebhook, type KNNSearchOptions, type ListAPIKeysResponse, type ListBackupsOptions, type ListCollectionsResponse, type ListIntegrationsOptions, type ListMultimediaResponse, type ListRecipesOptions, type ListTrainingJobsOptions, type LoginRequest, type LoginResponse, type ModelInfo, type MultimediaInfo, type NLPAnalysis, NLPClient, NotFoundError, type OAuth2Config, type PredictResult, type PreparedStatement, type PreparedStatementOptions, type QueryColumn, type QueryOptions, type QueryPerformance, type QueryResult, type RangeSearchOptions, RateLimitError, type Recipe, RecipeClient, type RecipeExecutionResult, type RecipeInfo, type RecipeParameter, type RefreshResponse, type RegisterRequest, type RegisterResponse, type RelationshipInfo, type RestoreOptions, type RestoreResult, type RestoreStatus, type RetryConfig, SQLError, SchemaClient, type SchemaStatistics, type ValidationError$2 as SchemaValidationError, type SearchOptions, type SearchResult, type Sentiment, ServerError, type StorageConfig, Subscription, type SubscriptionEvent, type SubscriptionOptions, type SummarizeOptions, SynapCores, type SynapCoresConfig, SynapCoresError, type TableConstraint, type TableInfo, type TableSchema, type TestIntegrationOptions, type TestIntegrationResult, TimeoutError, type TrainOptions, type TrainingJob, type TrainingMetrics, type TransactionContext, TransactionError, type TransactionOptions, type UpdateOptions, type UploadMultimediaRequest, VERSION, ValidationError, type ValidationResult, type ValidationWarning$1 as ValidationWarning, type Vector, type VectorArithmeticResult, VectorError, type VectorSearchOptions, type VectorSearchResult, type VectorSimilarityResult, type WindowFunctionOptions };