@synapcores/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3055 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/client.ts
+import axios from "axios";
+
+// src/subscription.ts
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+var Subscription = class extends EventEmitter {
+  constructor(collection, options = {}) {
+    super();
+    this.collection = collection;
+    this.options = options;
+    this.running = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectDelay = 1e3;
+  }
+  async connect() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    await this.createConnection();
+  }
+  async createConnection() {
+    const client = this.collection.client;
+    const protocol = client.config.useHttps ? "wss" : "ws";
+    const url = `${protocol}://${client.config.host}:${client.config.port}/v1/ws`;
+    const headers = {};
+    if (client.config.apiKey) {
+      headers["Authorization"] = `Bearer ${client.config.apiKey}`;
+    }
+    this.ws = new WebSocket(url, { headers });
+    this.ws.on("open", () => {
+      this.reconnectAttempts = 0;
+      this.subscribe();
+    });
+    this.ws.on("message", (data) => {
+      this.handleMessage(data.toString());
+    });
+    this.ws.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.ws.on("close", () => {
+      if (this.running) {
+        this.scheduleReconnect();
+      }
+    });
+    this.ws.on("ping", () => {
+      this.ws?.pong();
+    });
+  }
+  subscribe() {
+    const subscribeMessage = {
+      type: "subscribe",
+      collection: this.collection.name,
+      filter: this.options.filter || {}
+    };
+    this.ws?.send(JSON.stringify(subscribeMessage));
+  }
+  handleMessage(message) {
+    try {
+      const data = JSON.parse(message);
+      if (data.type === "error") {
+        this.emit("error", new Error(data.message));
+        return;
+      }
+      if (data.type === "change") {
+        const event = {
+          operation: data.operation,
+          collection: data.collection,
+          document: data.document,
+          timestamp: new Date(data.timestamp),
+          sequence: data.sequence
+        };
+        this.emit("change", event);
+        if (this.options.onChange) {
+          Promise.resolve(this.options.onChange(event)).catch((error) => {
+            this.emit("error", error);
+          });
+        }
+      }
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.emit("error", new Error("Max reconnection attempts reached"));
+      this.close();
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    this.reconnectTimeout = setTimeout(() => {
+      this.createConnection().catch((error) => {
+        this.emit("error", error);
+      });
+    }, delay);
+  }
+  async close() {
+    this.running = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = void 0;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = void 0;
+    }
+    this.removeAllListeners();
+  }
+  // Async iterator support
+  async *[Symbol.asyncIterator]() {
+    const events = [];
+    let resolver = null;
+    const handleChange = (event) => {
+      if (resolver) {
+        resolver({ done: false, value: event });
+        resolver = null;
+      } else {
+        events.push(event);
+      }
+    };
+    this.on("change", handleChange);
+    try {
+      while (this.running) {
+        if (events.length > 0) {
+          yield events.shift();
+        } else {
+          yield await new Promise((resolve) => {
+            resolver = (result) => {
+              if (!result.done) {
+                resolve(result.value);
+              }
+            };
+          });
+        }
+      }
+    } finally {
+      this.off("change", handleChange);
+    }
+  }
+};
+
+// src/collection.ts
+var Collection = class {
+  constructor(client, name, schema) {
+    this.client = client;
+    this.name = name;
+    this.schema = schema;
+  }
+  get basePath() {
+    return `/collections/${this.name}`;
+  }
+  async insert(documents, _autoEmbed = true) {
+    const isSingle = !Array.isArray(documents);
+    const docs = isSingle ? [documents] : documents;
+    if (isSingle) {
+      const { data } = await this.client._getHttpClient().post(
+        `${this.basePath}/documents`,
+        documents
+        // Send the document directly as the body
+      );
+      return {
+        ids: [data.id],
+        inserted: 1
+      };
+    } else {
+      const formattedDocs = docs.map((doc) => ({
+        ...doc,
+        // Spread document fields at root level
+        id: null
+        // Optional ID field
+      }));
+      const bulkUrl = `${this.basePath}/documents/bulk`;
+      console.log("Calling bulk insert endpoint:", bulkUrl);
+      console.log("Payload:", JSON.stringify({ documents: formattedDocs }, null, 2));
+      const { data } = await this.client._getHttpClient().post(
+        bulkUrl,
+        {
+          documents: formattedDocs
+        }
+      );
+      return {
+        ids: data.ids || [],
+        inserted: data.inserted || docs.length
+      };
+    }
+  }
+  async get(documentId) {
+    try {
+      const { data } = await this.client._getHttpClient().get(
+        `${this.basePath}/documents/${documentId}`
+      );
+      return data;
+    } catch (error) {
+      if (error.code === "NOT_FOUND") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async update(documentId, data, options = {}) {
+    const response = await this.client._getHttpClient().patch(
+      `${this.basePath}/documents/${documentId}`,
+      {
+        data,
+        merge: options.merge !== false
+      }
+    );
+    return response.data;
+  }
+  async delete(documentId) {
+    const ids = Array.isArray(documentId) ? documentId : [documentId];
+    const { data } = await this.client._getHttpClient().request({
+      method: "DELETE",
+      url: `${this.basePath}/documents`,
+      data: { ids }
+    });
+    return { deleted: data.deleted };
+  }
+  async search(options) {
+    const searchUrl = `${this.basePath}/search`;
+    console.log("Calling search endpoint:", searchUrl);
+    console.log("Request body:", {
+      query: options.filter || {},
+      limit: options.topK || 10,
+      offset: options.offset || 0
+    });
+    const { data } = await this.client._getHttpClient().post(
+      searchUrl,
+      {
+        query: options.filter || {},
+        // Use filter as the query
+        limit: options.topK || 10,
+        offset: options.offset || 0
+      }
+    );
+    return {
+      documents: data.documents || data,
+      // Handle different response formats
+      total: data.total,
+      tookMs: data.took_ms,
+      nextOffset: data.next_offset
+    };
+  }
+  async vectorSearch(options) {
+    const { data } = await this.client._getHttpClient().post(
+      `${this.basePath}/vector_search`,
+      {
+        vector: options.vector,
+        field: options.field || "embedding",
+        top_k: options.topK || 10,
+        filter: options.filter,
+        distance_metric: options.distanceMetric || "cosine",
+        include_metadata: options.includeMetadata
+      }
+    );
+    return {
+      documents: data.documents,
+      total: data.total,
+      tookMs: data.took_ms
+    };
+  }
+  async query(options = {}) {
+    const { data } = await this.client._getHttpClient().post(
+      `${this.basePath}/query`,
+      {
+        filter: options.filter || {},
+        limit: options.limit || 100,
+        offset: options.offset || 0,
+        sort: options.sort,
+        projection: options.projection
+      }
+    );
+    return {
+      documents: data.documents,
+      total: data.total,
+      tookMs: data.took_ms,
+      nextOffset: data.next_offset
+    };
+  }
+  async count(filter) {
+    const { data } = await this.client._getHttpClient().post(
+      `${this.basePath}/count`,
+      { filter: filter || {} }
+    );
+    return data.count;
+  }
+  async stats() {
+    const { data } = await this.client._getHttpClient().get(
+      `${this.basePath}/stats`
+    );
+    return {
+      name: data.name,
+      documentCount: data.document_count,
+      sizeBytes: data.size_bytes,
+      indexCount: data.index_count,
+      createdAt: new Date(data.created_at),
+      updatedAt: new Date(data.updated_at)
+    };
+  }
+  async createIndex(options) {
+    const { data } = await this.client._getHttpClient().post(
+      `${this.basePath}/indexes`,
+      {
+        field: options.field,
+        type: options.type || "btree",
+        options: options.options || {}
+      }
+    );
+    return { created: data.created };
+  }
+  async dropIndex(field) {
+    const { data } = await this.client._getHttpClient().delete(
+      `${this.basePath}/indexes/${field}`
+    );
+    return { dropped: data.dropped };
+  }
+  async subscribe(options = {}) {
+    const subscription = new Subscription(this, options);
+    await subscription.connect();
+    return subscription;
+  }
+};
+
+// src/automl.ts
+var AutoMLModel = class {
+  constructor(client, info) {
+    this.client = client;
+    this.info = info;
+  }
+  get id() {
+    return this.info.id;
+  }
+  get name() {
+    return this.info.name;
+  }
+  async predict(data) {
+    const isSingle = !Array.isArray(data);
+    const inputs = isSingle ? [data] : data;
+    const response = await this.client.synapCores._getHttpClient().post(
+      "/ai/predict",
+      {
+        model_id: this.id,
+        inputs
+      }
+    );
+    const predictions = response.data.predictions;
+    return isSingle ? predictions[0] : predictions;
+  }
+  async evaluate(testData, target) {
+    const payload = {
+      model_id: this.id
+    };
+    if (typeof testData === "string") {
+      payload.collection = testData;
+    } else {
+      payload.data = testData;
+      if (target) {
+        payload.target = target;
+      }
+    }
+    const { data } = await this.client.synapCores._getHttpClient().post(
+      "/ai/evaluate",
+      payload
+    );
+    return data;
+  }
+  async delete() {
+    await this.client.synapCores._getHttpClient().delete(
+      `/ai/models/${this.id}`
+    );
+  }
+};
+var AutoMLClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async train(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/train", {
+      collection: options.collection,
+      target: options.target,
+      features: options.features,
+      task: options.task || "auto",
+      name: options.name || `${options.collection}_${options.target}_model`,
+      config: options.config || {},
+      validation_split: options.validationSplit || 0.2,
+      max_trials: options.maxTrials || 10,
+      timeout_minutes: options.timeoutMinutes || 60
+    });
+    const modelInfo = {
+      id: data.id,
+      name: data.name,
+      task: data.task,
+      status: data.status,
+      accuracy: data.accuracy,
+      createdAt: new Date(data.created_at),
+      updatedAt: data.updated_at ? new Date(data.updated_at) : void 0,
+      config: data.config
+    };
+    return new AutoMLModel(this, modelInfo);
+  }
+  async getModel(modelId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/models/${modelId}`
+    );
+    const modelInfo = {
+      id: data.id,
+      name: data.name,
+      task: data.task,
+      status: data.status,
+      accuracy: data.accuracy,
+      createdAt: new Date(data.created_at),
+      updatedAt: data.updated_at ? new Date(data.updated_at) : void 0,
+      config: data.config
+    };
+    return new AutoMLModel(this, modelInfo);
+  }
+  async listModels(filters) {
+    const { data } = await this.synapCores._getHttpClient().get("/ai/models", {
+      params: filters
+    });
+    return data.models.map((model) => ({
+      id: model.id,
+      name: model.name,
+      task: model.task,
+      status: model.status,
+      accuracy: model.accuracy,
+      createdAt: new Date(model.created_at),
+      updatedAt: model.updated_at ? new Date(model.updated_at) : void 0,
+      config: model.config
+    }));
+  }
+  /**
+   * Start async training job
+   */
+  async trainAsync(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/train/async", {
+      collection: options.collection,
+      target: options.target,
+      features: options.features,
+      task: options.task || "auto",
+      name: options.name || `${options.collection}_${options.target}_model`,
+      config: options.config || {},
+      validation_split: options.validationSplit || 0.2,
+      max_trials: options.maxTrials || 10,
+      timeout_minutes: options.timeoutMinutes || 60,
+      callback_url: options.callback_url,
+      webhook_url: options.webhook_url
+    });
+    return {
+      id: data.id || data.job_id,
+      name: data.name,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      task: data.task,
+      current_trial: data.current_trial,
+      total_trials: data.total_trials || options.maxTrials || 10,
+      best_accuracy: data.best_accuracy,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: new Date(data.started_at || Date.now()),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      model_id: data.model_id
+    };
+  }
+  /**
+   * Get training job status
+   */
+  async getTrainingJob(jobId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/train/jobs/${jobId}`
+    );
+    return {
+      id: data.id || jobId,
+      name: data.name,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      task: data.task,
+      current_trial: data.current_trial,
+      total_trials: data.total_trials,
+      best_accuracy: data.best_accuracy,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: new Date(data.started_at),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      model_id: data.model_id
+    };
+  }
+  /**
+   * List training jobs
+   */
+  async listTrainingJobs(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.append("status", options.status);
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/train/jobs?${params.toString()}`
+    );
+    return (data.jobs || data).map((job) => ({
+      id: job.id,
+      name: job.name,
+      status: job.status,
+      progress: job.progress || 0,
+      phase: job.phase,
+      task: job.task,
+      current_trial: job.current_trial,
+      total_trials: job.total_trials,
+      best_accuracy: job.best_accuracy,
+      eta_ms: job.eta_ms || job.estimated_time_remaining_ms,
+      error: job.error,
+      started_at: new Date(job.started_at),
+      completed_at: job.completed_at ? new Date(job.completed_at) : void 0,
+      model_id: job.model_id
+    }));
+  }
+  /**
+   * Cancel a training job
+   */
+  async cancelTrainingJob(jobId) {
+    await this.synapCores._getHttpClient().post(`/ai/train/jobs/${jobId}/cancel`);
+  }
+  /**
+   * Get training metrics for a job
+   */
+  async getTrainingMetrics(jobId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/ai/train/jobs/${jobId}/metrics`
+    );
+    return (data.metrics || data).map((metric) => ({
+      trial: metric.trial,
+      accuracy: metric.accuracy,
+      loss: metric.loss,
+      metrics: metric.metrics,
+      timestamp: new Date(metric.timestamp)
+    }));
+  }
+  /**
+   * Wait for training job to complete
+   */
+  async waitForTrainingJob(jobId, options = {}) {
+    const pollInterval = options.pollInterval || 2e3;
+    const timeout = options.timeout || 36e5;
+    const startTime = Date.now();
+    while (true) {
+      const job = await this.getTrainingJob(jobId);
+      if (options.onProgress) {
+        options.onProgress(job);
+      }
+      if (job.status === "completed") {
+        if (!job.model_id) {
+          throw new Error("Training completed but no model ID returned");
+        }
+        return await this.getModel(job.model_id);
+      }
+      if (job.status === "failed") {
+        throw new Error(`Training failed: ${job.error || "Unknown error"}`);
+      }
+      if (job.status === "cancelled") {
+        throw new Error("Training was cancelled");
+      }
+      if (Date.now() - startTime > timeout) {
+        throw new Error("Timeout waiting for training job to complete");
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+};
+
+// src/nlp.ts
+var NLPClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  async analyze(options) {
+    const isBatch = Array.isArray(options.text);
+    const texts = isBatch ? options.text : [options.text];
+    const { data } = await this.synapCores._getHttpClient().post("/ai/analyze", {
+      texts,
+      tasks: options.tasks || ["sentiment", "entities", "keywords"],
+      language: options.language
+    });
+    const results = data.results.map((r) => ({
+      sentiment: r.sentiment ? {
+        label: r.sentiment.label,
+        score: r.sentiment.score,
+        confidence: r.sentiment.confidence
+      } : void 0,
+      entities: r.entities ? r.entities.map((e) => ({
+        text: e.text,
+        type: e.type,
+        start: e.start,
+        end: e.end,
+        score: e.score
+      })) : void 0,
+      summary: r.summary,
+      keywords: r.keywords,
+      language: r.language
+    }));
+    return isBatch ? results : results[0];
+  }
+  async summarize(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/summarize", {
+      text: options.text,
+      max_length: options.maxLength || 150,
+      min_length: options.minLength || 30
+    });
+    return data.summary;
+  }
+  async extractEntities(text, entityTypes) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/entities", {
+      text,
+      entity_types: entityTypes
+    });
+    return data.entities.map((e) => ({
+      text: e.text,
+      type: e.type,
+      start: e.start,
+      end: e.end,
+      score: e.score
+    }));
+  }
+  async sentiment(text) {
+    const isBatch = Array.isArray(text);
+    const texts = isBatch ? text : [text];
+    const { data } = await this.synapCores._getHttpClient().post("/ai/sentiment", {
+      texts
+    });
+    const results = data.sentiments.map((s) => ({
+      label: s.label,
+      score: s.score,
+      confidence: s.confidence
+    }));
+    return isBatch ? results : results[0];
+  }
+  async classify(options) {
+    const isBatch = Array.isArray(options.text);
+    const texts = isBatch ? options.text : [options.text];
+    const { data } = await this.synapCores._getHttpClient().post("/ai/classify", {
+      texts,
+      categories: options.categories,
+      multi_label: options.multiLabel || false
+    });
+    return isBatch ? data.classifications : data.classifications[0];
+  }
+};
+
+// src/recipes.ts
+var RecipeClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Create a new recipe
+   */
+  async create(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/recipes", {
+      name: options.name,
+      description: options.description,
+      category: options.category,
+      content: options.content,
+      tags: options.tags || [],
+      parameters: options.parameters || []
+    });
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      category: data.category,
+      content: data.content,
+      tags: data.tags || [],
+      parameters: data.parameters || [],
+      created_at: new Date(data.created_at),
+      updated_at: new Date(data.updated_at),
+      author: data.author,
+      execution_count: data.execution_count,
+      version: data.version
+    };
+  }
+  /**
+   * List recipes with optional filters
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.category) params.append("category", options.category);
+    if (options.search) params.append("search", options.search);
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    if (options.tags && options.tags.length > 0) {
+      params.append("tags", options.tags.join(","));
+    }
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/recipes?${params.toString()}`
+    );
+    return (data.recipes || data).map((recipe) => ({
+      id: recipe.id,
+      name: recipe.name,
+      description: recipe.description,
+      category: recipe.category,
+      tags: recipe.tags || [],
+      created_at: new Date(recipe.created_at),
+      updated_at: new Date(recipe.updated_at),
+      author: recipe.author,
+      execution_count: recipe.execution_count
+    }));
+  }
+  /**
+   * Get a specific recipe by ID
+   */
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/recipes/${id}`);
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      category: data.category,
+      content: data.content,
+      tags: data.tags || [],
+      parameters: data.parameters || [],
+      created_at: new Date(data.created_at),
+      updated_at: new Date(data.updated_at),
+      author: data.author,
+      execution_count: data.execution_count,
+      version: data.version
+    };
+  }
+  /**
+   * Update an existing recipe
+   */
+  async update(id, updates) {
+    const { data } = await this.synapCores._getHttpClient().put(`/recipes/${id}`, updates);
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      category: data.category,
+      content: data.content,
+      tags: data.tags || [],
+      parameters: data.parameters || [],
+      created_at: new Date(data.created_at),
+      updated_at: new Date(data.updated_at),
+      author: data.author,
+      execution_count: data.execution_count,
+      version: data.version
+    };
+  }
+  /**
+   * Delete a recipe
+   */
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/recipes/${id}`);
+  }
+  /**
+   * Execute a recipe
+   */
+  async execute(options) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/recipes/${options.recipe}/execute`,
+      {
+        parameters: options.parameters || {},
+        dry_run: options.dry_run || false
+      }
+    );
+    return {
+      id: data.id || data.execution_id,
+      success: data.success,
+      results: data.results,
+      error: data.error,
+      execution_time_ms: data.execution_time_ms || data.took_ms,
+      statements_executed: data.statements_executed || 0
+    };
+  }
+  /**
+   * Generate a recipe using AI
+   */
+  async generate(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/ai/generate-recipe", {
+      intent: options.intent,
+      category: options.category,
+      context: options.context
+    });
+    return {
+      name: data.name,
+      description: data.description,
+      content: data.content
+    };
+  }
+  /**
+   * List available recipe categories
+   */
+  async listCategories() {
+    const { data } = await this.synapCores._getHttpClient().get("/recipes/categories");
+    return data.categories || [];
+  }
+};
+
+// src/schema.ts
+var SchemaClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * List all tables in the database
+   */
+  async listTables(options = {}) {
+    const params = new URLSearchParams();
+    if (options.includeSystem) {
+      params.append("include_system", "true");
+    }
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables?${params.toString()}`
+    );
+    return (data.tables || data).map((table) => ({
+      name: table.name,
+      type: table.type || "table",
+      column_count: table.column_count || 0,
+      row_count: table.row_count,
+      size_bytes: table.size_bytes,
+      created_at: table.created_at ? new Date(table.created_at) : void 0,
+      updated_at: table.updated_at ? new Date(table.updated_at) : void 0,
+      comment: table.comment
+    }));
+  }
+  /**
+   * Get complete schema for a specific table
+   */
+  async getTable(tableName) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables/${tableName}`
+    );
+    return {
+      table: {
+        name: data.name,
+        type: data.type || "table",
+        column_count: data.columns?.length || 0,
+        row_count: data.row_count,
+        size_bytes: data.size_bytes,
+        created_at: data.created_at ? new Date(data.created_at) : void 0,
+        updated_at: data.updated_at ? new Date(data.updated_at) : void 0,
+        comment: data.comment
+      },
+      columns: (data.columns || []).map((col) => ({
+        name: col.name,
+        data_type: col.data_type || col.type,
+        nullable: col.nullable !== false,
+        default_value: col.default_value || col.default,
+        is_primary_key: col.is_primary_key || col.primary_key,
+        is_unique: col.is_unique || col.unique,
+        is_indexed: col.is_indexed || col.indexed,
+        foreign_key: col.foreign_key,
+        comment: col.comment,
+        ordinal_position: col.ordinal_position || col.position
+      })),
+      indexes: (data.indexes || []).map((idx) => ({
+        name: idx.name,
+        table: idx.table || tableName,
+        type: idx.type || "btree",
+        columns: idx.columns || [],
+        is_unique: idx.is_unique || idx.unique || false,
+        is_primary: idx.is_primary || idx.primary || false,
+        size_bytes: idx.size_bytes,
+        created_at: idx.created_at ? new Date(idx.created_at) : void 0
+      })),
+      constraints: data.constraints || [],
+      relationships: (data.relationships || []).map((rel) => ({
+        type: rel.type,
+        from_table: rel.from_table || rel.source_table,
+        from_column: rel.from_column || rel.source_column,
+        to_table: rel.to_table || rel.target_table,
+        to_column: rel.to_column || rel.target_column,
+        name: rel.name
+      }))
+    };
+  }
+  /**
+   * Get columns for a specific table
+   */
+  async getColumns(tableName) {
+    const schema = await this.getTable(tableName);
+    return schema.columns;
+  }
+  /**
+   * Get indexes for a specific table
+   */
+  async getIndexes(tableName) {
+    const schema = await this.getTable(tableName);
+    return schema.indexes;
+  }
+  /**
+   * Get all relationships in the database
+   */
+  async getRelationships() {
+    const { data } = await this.synapCores._getHttpClient().get("/schema/relationships");
+    return (data.relationships || data).map((rel) => ({
+      type: rel.type,
+      from_table: rel.from_table || rel.source_table,
+      from_column: rel.from_column || rel.source_column,
+      to_table: rel.to_table || rel.target_table,
+      to_column: rel.to_column || rel.target_column,
+      name: rel.name
+    }));
+  }
+  /**
+   * Get schema statistics
+   */
+  async getStatistics() {
+    const { data } = await this.synapCores._getHttpClient().get("/schema/statistics");
+    return {
+      table_count: data.table_count || 0,
+      view_count: data.view_count || 0,
+      index_count: data.index_count || 0,
+      relationship_count: data.relationship_count || 0,
+      total_size_bytes: data.total_size_bytes || 0,
+      total_rows: data.total_rows || 0,
+      version: data.version,
+      analyzed_at: data.analyzed_at ? new Date(data.analyzed_at) : void 0
+    };
+  }
+  /**
+   * Validate a schema definition
+   */
+  async validateSchema(schema) {
+    const { data } = await this.synapCores._getHttpClient().post("/schema/validate", {
+      schema
+    });
+    return {
+      is_valid: data.is_valid || data.valid,
+      errors: data.errors || [],
+      warnings: data.warnings || []
+    };
+  }
+  /**
+   * Compare two schemas
+   */
+  async compareSchemas(schema1, schema2) {
+    const { data } = await this.synapCores._getHttpClient().post("/schema/compare", {
+      schema1,
+      schema2
+    });
+    return {
+      differences: data.differences || [],
+      added: data.added || [],
+      removed: data.removed || [],
+      modified: data.modified || []
+    };
+  }
+  /**
+   * Generate SQL DDL for a table
+   */
+  async generateDDL(tableName) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/schema/tables/${tableName}/ddl`
+    );
+    return data.ddl || data.sql;
+  }
+  /**
+   * Analyze table and update statistics
+   */
+  async analyzeTable(tableName) {
+    await this.synapCores._getHttpClient().post(`/schema/tables/${tableName}/analyze`);
+  }
+};
+
+// src/import.ts
+var ImportExportClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Import data into a table
+   */
+  async import(options) {
+    const formData = new FormData();
+    formData.append("table", options.table);
+    formData.append("format", options.format);
+    if (options.mode) formData.append("mode", options.mode);
+    if (options.column_mapping) {
+      formData.append("column_mapping", JSON.stringify(options.column_mapping));
+    }
+    if (options.skip_header !== void 0) {
+      formData.append("skip_header", options.skip_header.toString());
+    }
+    if (options.delimiter) formData.append("delimiter", options.delimiter);
+    if (options.batch_size) formData.append("batch_size", options.batch_size.toString());
+    if (options.continue_on_error !== void 0) {
+      formData.append("continue_on_error", options.continue_on_error.toString());
+    }
+    if (options.primary_keys) {
+      formData.append("primary_keys", JSON.stringify(options.primary_keys));
+    }
+    if (Buffer.isBuffer(options.data)) {
+      formData.append("file", new Blob([options.data]), "data");
+    } else {
+      formData.append("data", options.data);
+    }
+    const { data } = await this.synapCores._getHttpClient().post("/import", formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+    return {
+      id: data.id || data.job_id,
+      success: data.success,
+      rows_processed: data.rows_processed || 0,
+      rows_imported: data.rows_imported || 0,
+      rows_failed: data.rows_failed || 0,
+      duration_ms: data.duration_ms || data.took_ms || 0,
+      errors: data.errors || [],
+      warnings: data.warnings || []
+    };
+  }
+  /**
+   * Export data from a table or query
+   */
+  async export(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/export", {
+      source: options.source,
+      format: options.format,
+      destination: options.destination || "response",
+      columns: options.columns,
+      filter: options.filter,
+      order_by: options.order_by,
+      limit: options.limit,
+      include_header: options.include_header,
+      delimiter: options.delimiter,
+      compress: options.compress
+    });
+    return {
+      id: data.id || data.job_id,
+      success: data.success,
+      rows_exported: data.rows_exported || 0,
+      duration_ms: data.duration_ms || data.took_ms || 0,
+      file_path: data.file_path,
+      data: data.data,
+      size_bytes: data.size_bytes,
+      download_url: data.download_url,
+      expires_at: data.expires_at ? new Date(data.expires_at) : void 0
+    };
+  }
+  /**
+   * Get import job status
+   */
+  async getImportStatus(jobId) {
+    const { data } = await this.synapCores._getHttpClient().get(`/import/${jobId}/status`);
+    return {
+      id: data.id || jobId,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      rows_processed: data.rows_processed,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: data.started_at ? new Date(data.started_at) : void 0,
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
+    };
+  }
+  /**
+   * Get export job status
+   */
+  async getExportStatus(jobId) {
+    const { data } = await this.synapCores._getHttpClient().get(`/export/${jobId}/status`);
+    return {
+      id: data.id || jobId,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      rows_exported: data.rows_exported,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: data.started_at ? new Date(data.started_at) : void 0,
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
+    };
+  }
+  /**
+   * Cancel an import job
+   */
+  async cancelImport(jobId) {
+    await this.synapCores._getHttpClient().post(`/import/${jobId}/cancel`);
+  }
+  /**
+   * Cancel an export job
+   */
+  async cancelExport(jobId) {
+    await this.synapCores._getHttpClient().post(`/export/${jobId}/cancel`);
+  }
+  /**
+   * Import data from multiple sources in bulk
+   */
+  async bulkImport(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/import/bulk", {
+      jobs: options.jobs,
+      parallel: options.parallel || false,
+      stop_on_error: options.stop_on_error || false
+    });
+    return {
+      id: data.id || data.bulk_id,
+      success: data.success,
+      results: data.results || [],
+      total_rows_imported: data.total_rows_imported || 0,
+      total_duration_ms: data.total_duration_ms || data.took_ms || 0
+    };
+  }
+  /**
+   * Validate data before import
+   */
+  async validateData(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/import/validate", {
+      table: options.table,
+      data: options.data,
+      mode: options.mode || "strict",
+      check_foreign_keys: options.check_foreign_keys,
+      check_unique: options.check_unique
+    });
+    return {
+      is_valid: data.is_valid || data.valid,
+      errors: data.errors || [],
+      warnings: data.warnings || [],
+      rows_validated: data.rows_validated || options.data.length
+    };
+  }
+  /**
+   * Get import template for a table
+   */
+  async getImportTemplate(tableName, format = "csv") {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/import/template/${tableName}?format=${format}`
+    );
+    return data.template || data.content || data;
+  }
+  /**
+   * List import/export jobs
+   */
+  async listJobs(options = {}) {
+    const params = new URLSearchParams();
+    if (options.type) params.append("type", options.type);
+    if (options.status) params.append("status", options.status);
+    if (options.limit) params.append("limit", options.limit.toString());
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/import/jobs?${params.toString()}`
+    );
+    return (data.jobs || data).map((job) => ({
+      id: job.id,
+      status: job.status,
+      progress: job.progress || 0,
+      phase: job.phase,
+      rows_processed: job.rows_processed,
+      rows_exported: job.rows_exported,
+      eta_ms: job.eta_ms,
+      error: job.error,
+      started_at: job.started_at ? new Date(job.started_at) : void 0,
+      completed_at: job.completed_at ? new Date(job.completed_at) : void 0
+    }));
+  }
+  /**
+   * Download exported data
+   */
+  async downloadExport(jobId) {
+    const { data } = await this.synapCores._getHttpClient().get(`/export/${jobId}/download`, {
+      responseType: "arraybuffer"
+    });
+    return Buffer.from(data);
+  }
+  /**
+   * Stream import data (for large files)
+   */
+  async streamImport(options, onProgress) {
+    const result = await this.import(options);
+    const jobId = result.id;
+    if (onProgress) {
+      const pollInterval = setInterval(async () => {
+        try {
+          const status = await this.getImportStatus(jobId);
+          onProgress(status);
+          if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
+            clearInterval(pollInterval);
+          }
+        } catch (error) {
+          clearInterval(pollInterval);
+        }
+      }, 1e3);
+    }
+    return result;
+  }
+  /**
+   * Stream export data (for large datasets)
+   */
+  async streamExport(options, onProgress) {
+    const result = await this.export(options);
+    const jobId = result.id;
+    if (onProgress) {
+      const pollInterval = setInterval(async () => {
+        try {
+          const status = await this.getExportStatus(jobId);
+          onProgress(status);
+          if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
+            clearInterval(pollInterval);
+          }
+        } catch (error) {
+          clearInterval(pollInterval);
+        }
+      }, 1e3);
+    }
+    return result;
+  }
+};
+
+// src/integrations.ts
+var IntegrationClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Create a new integration
+   */
+  async create(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/integrations", {
+      name: options.name,
+      type: options.type,
+      config: options.config,
+      description: options.description,
+      tags: options.tags || [],
+      activate: options.activate || false
+    });
+    return this.mapIntegration(data);
+  }
+  /**
+   * List integrations with optional filters
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.type) params.append("type", options.type);
+    if (options.status) params.append("status", options.status);
+    if (options.search) params.append("search", options.search);
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    if (options.tags && options.tags.length > 0) {
+      params.append("tags", options.tags.join(","));
+    }
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations?${params.toString()}`
+    );
+    return (data.integrations || data).map(
+      (integration) => this.mapIntegration(integration)
+    );
+  }
+  /**
+   * Get a specific integration by ID
+   */
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/integrations/${id}`);
+    return this.mapIntegration(data);
+  }
+  /**
+   * Update an existing integration
+   */
+  async update(id, updates) {
+    const { data } = await this.synapCores._getHttpClient().put(
+      `/integrations/${id}`,
+      updates
+    );
+    return this.mapIntegration(data);
+  }
+  /**
+   * Delete an integration
+   */
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/integrations/${id}`);
+  }
+  /**
+   * Activate an integration
+   */
+  async activate(id) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/integrations/${id}/activate`
+    );
+    return this.mapIntegration(data);
+  }
+  /**
+   * Deactivate an integration
+   */
+  async deactivate(id) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/integrations/${id}/deactivate`
+    );
+    return this.mapIntegration(data);
+  }
+  /**
+   * Execute an integration
+   */
+  async execute(options) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/integrations/${options.integration}/execute`,
+      {
+        payload: options.payload,
+        config_override: options.config_override,
+        sync: options.sync !== false
+      }
+    );
+    return {
+      id: data.id || data.execution_id,
+      success: data.success,
+      response: data.response,
+      status_code: data.status_code,
+      error: data.error,
+      execution_time_ms: data.execution_time_ms || data.took_ms || 0,
+      retry_count: data.retry_count || 0,
+      executed_at: data.executed_at ? new Date(data.executed_at) : /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Test an integration without executing
+   */
+  async test(options) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/integrations/${options.integration}/test`,
+      {
+        payload: options.payload,
+        validate_only: options.validate_only || false
+      }
+    );
+    return {
+      success: data.success,
+      validation_errors: data.validation_errors || [],
+      response: data.response,
+      error: data.error,
+      latency_ms: data.latency_ms
+    };
+  }
+  /**
+   * Get integration execution history
+   */
+  async getExecutionHistory(integrationId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${integrationId}/executions?${params.toString()}`
+    );
+    return (data.executions || data).map((exec) => ({
+      id: exec.id || exec.execution_id,
+      success: exec.success,
+      response: exec.response,
+      status_code: exec.status_code,
+      error: exec.error,
+      execution_time_ms: exec.execution_time_ms || exec.took_ms || 0,
+      retry_count: exec.retry_count || 0,
+      executed_at: exec.executed_at ? new Date(exec.executed_at) : /* @__PURE__ */ new Date()
+    }));
+  }
+  /**
+   * Get integration statistics
+   */
+  async getStats(integrationId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${integrationId}/stats`
+    );
+    return {
+      integration_id: integrationId,
+      total_executions: data.total_executions || 0,
+      successful_executions: data.successful_executions || 0,
+      failed_executions: data.failed_executions || 0,
+      avg_execution_time_ms: data.avg_execution_time_ms || 0,
+      executions_24h: data.executions_24h || 0,
+      uptime_percentage: data.uptime_percentage || 0,
+      last_success_at: data.last_success_at ? new Date(data.last_success_at) : void 0,
+      last_error_at: data.last_error_at ? new Date(data.last_error_at) : void 0
+    };
+  }
+  /**
+   * Create a webhook for an integration
+   */
+  async createWebhook(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/integrations/webhooks", {
+      integration_id: options.integration_id,
+      event: options.event,
+      url: options.url,
+      secret: options.secret,
+      activate: options.activate !== false
+    });
+    return {
+      id: data.id,
+      integration_id: data.integration_id,
+      event: data.event,
+      url: data.url,
+      active: data.active,
+      secret: data.secret,
+      created_at: new Date(data.created_at)
+    };
+  }
+  /**
+   * List webhooks for an integration
+   */
+  async listWebhooks(integrationId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${integrationId}/webhooks`
+    );
+    return (data.webhooks || data).map((webhook) => ({
+      id: webhook.id,
+      integration_id: webhook.integration_id,
+      event: webhook.event,
+      url: webhook.url,
+      active: webhook.active,
+      secret: webhook.secret,
+      created_at: new Date(webhook.created_at)
+    }));
+  }
+  /**
+   * Delete a webhook
+   */
+  async deleteWebhook(webhookId) {
+    await this.synapCores._getHttpClient().delete(`/integrations/webhooks/${webhookId}`);
+  }
+  /**
+   * Get integration events
+   */
+  async getEvents(integrationId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.status) params.append("status", options.status);
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${integrationId}/events?${params.toString()}`
+    );
+    return (data.events || data).map((event) => ({
+      id: event.id,
+      integration_id: event.integration_id,
+      event: event.event,
+      data: event.data,
+      timestamp: new Date(event.timestamp),
+      status: event.status,
+      error: event.error
+    }));
+  }
+  /**
+   * Get integration logs
+   */
+  async getLogs(integrationId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.level) params.append("level", options.level);
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/integrations/${integrationId}/logs?${params.toString()}`
+    );
+    return (data.logs || data).map((log) => ({
+      id: log.id,
+      integration_id: log.integration_id,
+      level: log.level,
+      message: log.message,
+      data: log.data,
+      timestamp: new Date(log.timestamp)
+    }));
+  }
+  /**
+   * Retry a failed execution
+   */
+  async retryExecution(executionId) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/integrations/executions/${executionId}/retry`
+    );
+    return {
+      id: data.id || data.execution_id,
+      success: data.success,
+      response: data.response,
+      status_code: data.status_code,
+      error: data.error,
+      execution_time_ms: data.execution_time_ms || data.took_ms || 0,
+      retry_count: data.retry_count || 0,
+      executed_at: data.executed_at ? new Date(data.executed_at) : /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Map raw integration data to Integration type
+   */
+  mapIntegration(data) {
+    return {
+      id: data.id,
+      name: data.name,
+      type: data.type,
+      status: data.status,
+      config: data.config,
+      description: data.description,
+      tags: data.tags || [],
+      created_at: new Date(data.created_at),
+      updated_at: new Date(data.updated_at),
+      last_success_at: data.last_success_at ? new Date(data.last_success_at) : void 0,
+      last_error: data.last_error,
+      execution_count: data.execution_count
+    };
+  }
+};
+
+// src/backup.ts
+var BackupClient = class {
+  constructor(synapCores) {
+    this.synapCores = synapCores;
+  }
+  /**
+   * Create a new backup
+   */
+  async create(options = {}) {
+    const { data } = await this.synapCores._getHttpClient().post("/backups", {
+      name: options.name,
+      description: options.description,
+      type: options.type || "full",
+      tables: options.tables,
+      include_indexes: options.include_indexes !== false,
+      include_procedures: options.include_procedures !== false,
+      compression: options.compression || 6,
+      encrypt: options.encrypt || false,
+      encryption_key: options.encryption_key,
+      storage: options.storage || "local",
+      storage_config: options.storage_config,
+      tags: options.tags || []
+    });
+    return this.mapBackup(data);
+  }
+  /**
+   * List backups with optional filters
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.type) params.append("type", options.type);
+    if (options.status) params.append("status", options.status);
+    if (options.sort) params.append("sort", options.sort);
+    if (options.order) params.append("order", options.order);
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    if (options.tags && options.tags.length > 0) {
+      params.append("tags", options.tags.join(","));
+    }
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/backups?${params.toString()}`
+    );
+    return (data.backups || data).map((backup) => this.mapBackup(backup));
+  }
+  /**
+   * Get a specific backup by ID
+   */
+  async get(id) {
+    const { data } = await this.synapCores._getHttpClient().get(`/backups/${id}`);
+    return this.mapBackup(data);
+  }
+  /**
+   * Delete a backup
+   */
+  async delete(id) {
+    await this.synapCores._getHttpClient().delete(`/backups/${id}`);
+  }
+  /**
+   * Restore from a backup
+   */
+  async restore(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/backups/restore", {
+      backup_id: options.backup_id,
+      mode: options.mode || "full",
+      tables: options.tables,
+      target_database: options.target_database,
+      overwrite: options.overwrite || false,
+      skip_indexes: options.skip_indexes || false,
+      skip_procedures: options.skip_procedures || false,
+      decryption_key: options.decryption_key,
+      point_in_time: options.point_in_time?.toISOString(),
+      dry_run: options.dry_run || false
+    });
+    return {
+      id: data.id || data.restore_id,
+      success: data.success,
+      tables_restored: data.tables_restored || [],
+      rows_restored: data.rows_restored || 0,
+      duration_ms: data.duration_ms || data.took_ms || 0,
+      error: data.error,
+      warnings: data.warnings || []
+    };
+  }
+  /**
+   * Get backup status
+   */
+  async getBackupStatus(backupId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/backups/${backupId}/status`
+    );
+    return {
+      id: data.id || backupId,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      tables_processed: data.tables_processed,
+      total_tables: data.total_tables,
+      bytes_processed: data.bytes_processed,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: data.started_at ? new Date(data.started_at) : void 0,
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
+    };
+  }
+  /**
+   * Get restore status
+   */
+  async getRestoreStatus(restoreId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/backups/restore/${restoreId}/status`
+    );
+    return {
+      id: data.id || restoreId,
+      status: data.status,
+      progress: data.progress || 0,
+      phase: data.phase,
+      tables_processed: data.tables_processed,
+      total_tables: data.total_tables,
+      rows_processed: data.rows_processed,
+      eta_ms: data.eta_ms || data.estimated_time_remaining_ms,
+      error: data.error,
+      started_at: data.started_at ? new Date(data.started_at) : void 0,
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0
+    };
+  }
+  /**
+   * Cancel a backup in progress
+   */
+  async cancelBackup(backupId) {
+    await this.synapCores._getHttpClient().post(`/backups/${backupId}/cancel`);
+  }
+  /**
+   * Cancel a restore in progress
+   */
+  async cancelRestore(restoreId) {
+    await this.synapCores._getHttpClient().post(`/backups/restore/${restoreId}/cancel`);
+  }
+  /**
+   * Download a backup file
+   */
+  async download(backupId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/backups/${backupId}/download`,
+      {
+        responseType: "arraybuffer"
+      }
+    );
+    return Buffer.from(data);
+  }
+  /**
+   * Verify backup integrity
+   */
+  async verify(backupId) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/backups/${backupId}/verify`
+    );
+    return {
+      is_valid: data.is_valid || data.valid,
+      integrity_ok: data.integrity_ok || data.integrity,
+      checksum_match: data.checksum_match,
+      tables_verified: data.tables_verified || 0,
+      errors: data.errors || [],
+      warnings: data.warnings || [],
+      verified_at: data.verified_at ? new Date(data.verified_at) : /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create a backup schedule
+   */
+  async createSchedule(options) {
+    const { data } = await this.synapCores._getHttpClient().post("/backups/schedules", {
+      name: options.name,
+      cron: options.cron,
+      backup_options: options.backup_options,
+      activate: options.activate !== false,
+      tags: options.tags || []
+    });
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  /**
+   * List backup schedules
+   */
+  async listSchedules() {
+    const { data } = await this.synapCores._getHttpClient().get("/backups/schedules");
+    return (data.schedules || data).map((schedule) => ({
+      id: schedule.id,
+      name: schedule.name,
+      cron: schedule.cron,
+      backup_options: schedule.backup_options,
+      active: schedule.active,
+      last_run_at: schedule.last_run_at ? new Date(schedule.last_run_at) : void 0,
+      next_run_at: schedule.next_run_at ? new Date(schedule.next_run_at) : void 0,
+      created_at: new Date(schedule.created_at),
+      tags: schedule.tags || []
+    }));
+  }
+  /**
+   * Get a specific schedule
+   */
+  async getSchedule(scheduleId) {
+    const { data } = await this.synapCores._getHttpClient().get(
+      `/backups/schedules/${scheduleId}`
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  /**
+   * Update a backup schedule
+   */
+  async updateSchedule(scheduleId, updates) {
+    const { data } = await this.synapCores._getHttpClient().put(
+      `/backups/schedules/${scheduleId}`,
+      updates
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  /**
+   * Delete a backup schedule
+   */
+  async deleteSchedule(scheduleId) {
+    await this.synapCores._getHttpClient().delete(`/backups/schedules/${scheduleId}`);
+  }
+  /**
+   * Activate a schedule
+   */
+  async activateSchedule(scheduleId) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/backups/schedules/${scheduleId}/activate`
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  /**
+   * Deactivate a schedule
+   */
+  async deactivateSchedule(scheduleId) {
+    const { data } = await this.synapCores._getHttpClient().post(
+      `/backups/schedules/${scheduleId}/deactivate`
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      cron: data.cron,
+      backup_options: data.backup_options,
+      active: data.active,
+      last_run_at: data.last_run_at ? new Date(data.last_run_at) : void 0,
+      next_run_at: data.next_run_at ? new Date(data.next_run_at) : void 0,
+      created_at: new Date(data.created_at),
+      tags: data.tags || []
+    };
+  }
+  /**
+   * Get backup metrics
+   */
+  async getMetrics() {
+    const { data } = await this.synapCores._getHttpClient().get("/backups/metrics");
+    return {
+      total_backups: data.total_backups || 0,
+      total_size_bytes: data.total_size_bytes || 0,
+      successful_backups: data.successful_backups || 0,
+      failed_backups: data.failed_backups || 0,
+      avg_backup_size_bytes: data.avg_backup_size_bytes || 0,
+      avg_duration_ms: data.avg_duration_ms || 0,
+      last_backup_at: data.last_backup_at ? new Date(data.last_backup_at) : void 0,
+      next_scheduled_at: data.next_scheduled_at ? new Date(data.next_scheduled_at) : void 0
+    };
+  }
+  /**
+   * Map raw backup data to Backup type
+   */
+  mapBackup(data) {
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      type: data.type,
+      status: data.status,
+      size_bytes: data.size_bytes,
+      compressed_size_bytes: data.compressed_size_bytes,
+      table_count: data.table_count,
+      created_at: new Date(data.created_at),
+      completed_at: data.completed_at ? new Date(data.completed_at) : void 0,
+      duration_ms: data.duration_ms || data.took_ms,
+      storage: data.storage,
+      storage_path: data.storage_path,
+      encrypted: data.encrypted || false,
+      tags: data.tags || [],
+      parent_backup_id: data.parent_backup_id,
+      error: data.error
+    };
+  }
+};
+
+// src/errors.ts
+var SynapCoresError = class _SynapCoresError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = "SynapCoresError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SynapCoresError);
+    }
+  }
+};
+var ConnectionError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "CONNECTION_ERROR", details);
+    this.name = "ConnectionError";
+  }
+};
+var AuthenticationError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "NOT_FOUND", details);
+    this.name = "NotFoundError";
+  }
+};
+var ServerError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "SERVER_ERROR", details);
+    this.name = "ServerError";
+  }
+};
+var TimeoutError = class extends SynapCoresError {
+  constructor(message, details) {
+    super(message, "TIMEOUT_ERROR", details);
+    this.name = "TimeoutError";
+  }
+};
+var RateLimitError = class extends SynapCoresError {
+  constructor(message, retryAfter, details) {
+    super(message, "RATE_LIMIT_ERROR", details);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var SQLError = class extends SynapCoresError {
+  constructor(message, code, severity = "ERROR", position, hint, detail, details) {
+    super(message, code, details);
+    this.name = "SQLError";
+    this.severity = severity;
+    this.position = position;
+    this.hint = hint;
+    this.detail = detail;
+  }
+};
+var VectorError = class extends SynapCoresError {
+  constructor(message, code, vectorDimensions, expectedDimensions, operation, details) {
+    super(message, code, details);
+    this.name = "VectorError";
+    this.vectorDimensions = vectorDimensions;
+    this.expectedDimensions = expectedDimensions;
+    this.operation = operation;
+  }
+};
+var TransactionError = class extends SynapCoresError {
+  constructor(message, code, transactionId, transactionState, details) {
+    super(message, code, details);
+    this.name = "TransactionError";
+    this.transactionId = transactionId;
+    this.transactionState = transactionState;
+  }
+};
+var BatchOperationError = class extends SynapCoresError {
+  constructor(message, code, failedItems, totalProcessed, successfulCount, details) {
+    super(message, code, details);
+    this.name = "BatchOperationError";
+    this.failedItems = failedItems;
+    this.totalProcessed = totalProcessed;
+    this.successfulCount = successfulCount;
+  }
+};
+
+// src/client.ts
+var SynapCores = class {
+  constructor(config = {}) {
+    this.collectionsCache = /* @__PURE__ */ new Map();
+    this.currentTransaction = null;
+    this.preparedStatements = /* @__PURE__ */ new Map();
+    this.config = {
+      host: config.host || "localhost",
+      port: config.port || 8080,
+      apiKey: config.apiKey || "",
+      jwtToken: config.jwtToken || "",
+      useHttps: config.useHttps || false,
+      timeout: config.timeout || 3e4,
+      maxRetries: config.maxRetries || 3,
+      rejectUnauthorized: config.rejectUnauthorized !== void 0 ? config.rejectUnauthorized : true
+    };
+    if (this.config.apiKey && !this.config.apiKey.startsWith("ak_") && !this.config.apiKey.startsWith("aidb_")) {
+      throw new Error(
+        "Invalid API key format. API keys should start with 'ak_' or 'aidb_' prefix. Please create a valid API key from your AIDB dashboard."
+      );
+    }
+    const protocol = this.config.useHttps ? "https" : "http";
+    const baseURL = `${protocol}://${this.config.host}:${this.config.port}/v1`;
+    const httpsAgent = this.config.useHttps && !this.config.rejectUnauthorized ? new (__require("https")).Agent({ rejectUnauthorized: false }) : void 0;
+    const authHeader = {};
+    if (this.config.jwtToken) {
+      authHeader["Authorization"] = `Bearer ${this.config.jwtToken}`;
+    } else if (this.config.apiKey) {
+      authHeader["X-API-Key"] = this.config.apiKey;
+    }
+    this.httpClient = axios.create({
+      baseURL,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "synapcores-nodejs/0.1.0",
+        ...authHeader
+      },
+      ...httpsAgent && { httpsAgent }
+    });
+    this.httpClient.interceptors.response.use(
+      (response) => response,
+      (error) => this.handleError(error)
+    );
+    this.automl = new AutoMLClient(this);
+    this.nlp = new NLPClient(this);
+    this.recipes = new RecipeClient(this);
+    this.schema = new SchemaClient(this);
+    this.import = new ImportExportClient(this);
+    this.integrations = new IntegrationClient(this);
+    this.backup = new BackupClient(this);
+  }
+  handleError(error) {
+    if (!error.response) {
+      const message = error.code === "ECONNREFUSED" ? `Failed to connect to SynapCores server at ${error.config?.baseURL}. Connection refused.` : `Failed to connect to SynapCores server: ${error.message}`;
+      throw new ConnectionError(message);
+    }
+    const { status, data } = error.response;
+    const errorData = data;
+    const errorInfo = errorData?.error || errorData;
+    const errorCode = errorInfo?.code;
+    const errorMessage = errorInfo?.message || errorData?.message || "An error occurred";
+    const errorDetails = errorInfo?.details || errorData?.details || errorData;
+    switch (status) {
+      case 400:
+        throw new ValidationError(
+          errorMessage,
+          errorDetails
+        );
+      case 401:
+        throw new AuthenticationError(
+          errorMessage,
+          errorDetails
+        );
+      case 403:
+        throw new AuthenticationError(
+          errorMessage,
+          errorDetails
+        );
+      case 404:
+        throw new NotFoundError(
+          errorMessage,
+          errorDetails
+        );
+      case 409:
+        throw new ValidationError(
+          errorMessage,
+          errorDetails
+        );
+      case 413:
+        throw new ValidationError(
+          errorMessage || "Payload too large",
+          errorDetails
+        );
+      case 422:
+        throw new ValidationError(
+          errorMessage,
+          errorDetails?.errors || errorDetails
+        );
+      case 429:
+        const retryAfter = error.response.headers["retry-after"];
+        throw new RateLimitError(
+          errorMessage,
+          retryAfter ? parseInt(retryAfter) : void 0,
+          errorDetails
+        );
+      case 500:
+        throw new ServerError(
+          errorMessage || "Internal server error",
+          errorDetails
+        );
+      case 503:
+        throw new ServerError(
+          errorMessage || "Service unavailable",
+          errorDetails
+        );
+      default:
+        if (status >= 500) {
+          throw new ServerError(
+            errorMessage || `Server error: ${status}`,
+            errorDetails
+          );
+        }
+        throw new SynapCoresError(
+          errorMessage || `Unexpected error: ${status}`,
+          errorCode || "UNEXPECTED_ERROR",
+          errorDetails
+        );
+    }
+  }
+  /**
+   * Create collection (legacy method for backward compatibility)
+   */
+  async createCollection(options) {
+    const request = {
+      name: options.name,
+      description: options.description,
+      schema: options.schema
+    };
+    return this.createCollectionWithSchema(request);
+  }
+  /**
+   * Create collection matching the database integration guide format
+   */
+  async createCollectionWithSchema(request) {
+    const { data } = await this.httpClient.post("/collections", {
+      name: request.name,
+      description: request.description,
+      schema: request.schema
+    });
+    const collection = new Collection(this, request.name, data.collection.schema);
+    this.collectionsCache.set(request.name, collection);
+    return collection;
+  }
+  async getCollection(name) {
+    if (this.collectionsCache.has(name)) {
+      return this.collectionsCache.get(name);
+    }
+    const { data } = await this.httpClient.get(`/collections/${name}`);
+    const collection = new Collection(this, name, data.schema);
+    this.collectionsCache.set(name, collection);
+    return collection;
+  }
+  /**
+   * List collections (legacy method for backward compatibility)
+   */
+  async listCollections() {
+    const result = await this.listCollectionsDetailed();
+    return result.collections.map((c) => c.name);
+  }
+  /**
+   * List collections with detailed information matching the database integration guide format
+   */
+  async listCollectionsDetailed(options) {
+    const params = new URLSearchParams();
+    if (options?.page) params.append("page", options.page.toString());
+    if (options?.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options?.search) params.append("search", options.search);
+    if (options?.sortBy) params.append("sortBy", options.sortBy);
+    if (options?.sortOrder) params.append("sortOrder", options.sortOrder);
+    const { data } = await this.httpClient.get(
+      `/collections${params.toString() ? `?${params.toString()}` : ""}`
+    );
+    return data;
+  }
+  async getDocuments(collectionName, page, pageSize) {
+    const { data } = await this.httpClient.get(
+      `/collections/${collectionName}/documents?page=${page}&pageSize=${pageSize}`
+    );
+    return data;
+  }
+  async deleteCollection(name) {
+    await this.httpClient.delete(`/collections/${name}`);
+    this.collectionsCache.delete(name);
+  }
+  /**
+   * Execute SQL query (legacy method for backward compatibility)
+   * @deprecated Use executeQuery for new code
+   */
+  async sql(query, params) {
+    return this.executeQuery({
+      sql: query,
+      parameters: params ? Object.values(params) : []
+    });
+  }
+  /**
+   * Execute SQL query matching the database integration guide format
+   */
+  async executeQuery(request) {
+    const { data } = await this.httpClient.post("/query/execute", {
+      sql: request.sql,
+      parameters: request.parameters || [],
+      max_rows: request.max_rows || 1e3,
+      timeout_secs: request.timeout_secs || 300
+    });
+    return {
+      columns: data.columns || [],
+      rows: data.rows || [],
+      rows_affected: data.rows_affected,
+      execution_time_ms: data.execution_time_ms || 0,
+      queryPlan: data.query_plan
+    };
+  }
+  /**
+   * Execute batch queries
+   */
+  async executeBatchQueries(request) {
+    const { data } = await this.httpClient.post("/query/execute/batch", {
+      queries: request.queries,
+      transactional: request.transactional || false
+    });
+    return {
+      results: data.results || [],
+      total_execution_time_ms: data.total_execution_time_ms || 0
+    };
+  }
+  async embed(text, options = {}) {
+    const isBatch = Array.isArray(text);
+    const texts = isBatch ? text : [text];
+    const { data } = await this.httpClient.post("/ai/embed", {
+      texts,
+      model: options.model || "default"
+    });
+    return isBatch ? data.embeddings : data.embeddings[0];
+  }
+  // Internal method for HTTP client access
+  _getHttpClient() {
+    return this.httpClient;
+  }
+  // =================================================================
+  // TABLE MANAGEMENT OPERATIONS
+  // =================================================================
+  /**
+   * 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
+   */
+  async createTable(tableName, columns, options = {}) {
+    let sql = `CREATE TABLE ${options.ifNotExists ? "IF NOT EXISTS" : ""} ${tableName} (`;
+    const columnDefs = columns.map((col) => {
+      let def = `${col.name} ${col.dataType}`;
+      if (col.constraints) {
+        for (const constraint of col.constraints) {
+          switch (constraint.type) {
+            case "PRIMARY_KEY":
+              def += " PRIMARY KEY";
+              break;
+            case "UNIQUE":
+              def += " UNIQUE";
+              break;
+            case "NOT_NULL":
+              def += " NOT NULL";
+              break;
+            case "CHECK":
+              def += ` CHECK (${constraint.expression})`;
+              break;
+            case "FOREIGN_KEY":
+              def += ` REFERENCES ${constraint.referencedTable}(${constraint.referencedColumn})`;
+              break;
+            case "DEFAULT":
+              def += ` DEFAULT ${col.defaultValue}`;
+              break;
+          }
+        }
+      }
+      return def;
+    }).join(", ");
+    sql += columnDefs;
+    if (options.constraints) {
+      const constraintDefs = options.constraints.map((constraint) => {
+        switch (constraint.type) {
+          case "PRIMARY_KEY":
+            return `PRIMARY KEY (${constraint.columns.join(", ")})`;
+          case "UNIQUE":
+            return `UNIQUE (${constraint.columns.join(", ")})`;
+          case "CHECK":
+            return `CHECK (${constraint.expression})`;
+          case "FOREIGN_KEY":
+            return `FOREIGN KEY (${constraint.columns.join(", ")}) REFERENCES ${constraint.referencedTable}(${constraint.referencedColumns?.join(", ")})`;
+          default:
+            return "";
+        }
+      }).filter((def) => def);
+      if (constraintDefs.length > 0) {
+        sql += ", " + constraintDefs.join(", ");
+      }
+    }
+    sql += ")";
+    if (options.partitionBy) {
+      sql += ` PARTITION BY ${options.partitionBy.type} (${options.partitionBy.column})`;
+    }
+    return this.sql(sql);
+  }
+  /**
+   * 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
+   */
+  async alterTable(tableName, alterOptions) {
+    let sql = `ALTER TABLE ${tableName} `;
+    switch (alterOptions.action) {
+      case "ADD_COLUMN":
+        if (!alterOptions.columnDefinition) {
+          throw new ValidationError("Column definition required for ADD_COLUMN");
+        }
+        sql += `ADD COLUMN ${alterOptions.columnDefinition.name} ${alterOptions.columnDefinition.dataType}`;
+        break;
+      case "DROP_COLUMN":
+        sql += `DROP COLUMN ${alterOptions.columnName}`;
+        break;
+      case "RENAME_COLUMN":
+        sql += `RENAME COLUMN ${alterOptions.columnName} TO ${alterOptions.newColumnName}`;
+        break;
+      case "ALTER_COLUMN":
+        sql += `ALTER COLUMN ${alterOptions.columnName} TYPE ${alterOptions.newDataType}`;
+        break;
+      case "ADD_CONSTRAINT":
+        if (!alterOptions.constraint) {
+          throw new ValidationError("Constraint required for ADD_CONSTRAINT");
+        }
+        sql += `ADD CONSTRAINT ${alterOptions.constraint.type.toLowerCase()}_constraint`;
+        break;
+      case "DROP_CONSTRAINT":
+        sql += `DROP CONSTRAINT ${alterOptions.constraintName}`;
+        break;
+    }
+    return this.sql(sql);
+  }
+  /**
+   * Drops an existing table
+   * @param tableName - Name of the table to drop
+   * @param options - Drop options
+   * @returns Promise resolving to drop result
+   */
+  async dropTable(tableName, options = {}) {
+    let sql = `DROP TABLE ${options.ifExists ? "IF EXISTS" : ""} ${tableName}`;
+    if (options.cascade) {
+      sql += " CASCADE";
+    }
+    return this.sql(sql);
+  }
+  /**
+   * Describes a table structure including columns, constraints, and indexes
+   * @param tableName - Name of the table to describe
+   * @returns Promise resolving to table information
+   */
+  async describeTable(tableName) {
+    const { data } = await this.httpClient.get(`/table/${tableName}/info`);
+    return data;
+  }
+  /**
+   * Lists all tables in the current database
+   * @param pattern - Optional pattern to filter table names
+   * @returns Promise resolving to array of table names
+   */
+  async showTables(pattern) {
+    const sql = pattern ? `SHOW TABLES LIKE '${pattern}'` : "SHOW TABLES";
+    const result = await this.sql(sql);
+    return result.rows.map((row) => Object.values(row)[0]);
+  }
+  // =================================================================
+  // INDEX MANAGEMENT OPERATIONS
+  // =================================================================
+  /**
+   * Creates an index on a table
+   * @param indexDef - Index definition with name, table, columns, and options
+   * @returns Promise resolving to index creation result
+   */
+  async createIndex(indexDef) {
+    const columns = indexDef.columns.map((col) => `${col.name} ${col.order || "ASC"}`).join(", ");
+    const sql = `CREATE ${indexDef.unique ? "UNIQUE" : ""} INDEX ${indexDef.ifNotExists ? "IF NOT EXISTS" : ""} ${indexDef.name} ON ${indexDef.tableName} (${columns})`;
+    return this.sql(sql);
+  }
+  /**
+   * Drops an existing index
+   * @param indexName - Name of the index to drop
+   * @param options - Drop options
+   * @returns Promise resolving to drop result
+   */
+  async dropIndex(indexName, options = {}) {
+    const sql = `DROP INDEX ${options.ifExists ? "IF EXISTS" : ""} ${indexName}`;
+    return this.sql(sql);
+  }
+  /**
+   * Lists all indexes, optionally filtered by table name
+   * @param tableName - Optional table name to filter indexes
+   * @returns Promise resolving to array of index information
+   */
+  async showIndexes(tableName) {
+    const sql = tableName ? `SHOW INDEXES FROM ${tableName}` : "SHOW INDEXES";
+    const result = await this.sql(sql);
+    const indexNameIdx = result.columns.findIndex((c) => c.name === "index_name" || c.name === "name");
+    const tableNameIdx = result.columns.findIndex((c) => c.name === "table_name" || c.name === "table");
+    const columnsIdx = result.columns.findIndex((c) => c.name === "columns" || c.name === "column");
+    const uniqueIdx = result.columns.findIndex((c) => c.name === "is_unique" || c.name === "unique");
+    return result.rows.map((row) => {
+      const indexName = indexNameIdx >= 0 ? row[indexNameIdx] : "";
+      const table = tableNameIdx >= 0 ? row[tableNameIdx] : "";
+      const columnsStr = columnsIdx >= 0 ? row[columnsIdx] : "";
+      const isUnique = uniqueIdx >= 0 ? row[uniqueIdx] : false;
+      return {
+        name: String(indexName),
+        table: String(table),
+        columns: typeof columnsStr === "string" ? columnsStr.split(",") : [],
+        unique: Boolean(isUnique)
+      };
+    });
+  }
+  // =================================================================
+  // TRANSACTION SUPPORT
+  // =================================================================
+  /**
+   * Begins a new transaction
+   * @param options - Transaction options including isolation level
+   * @returns Promise resolving to transaction context
+   */
+  async beginTransaction(options = {}) {
+    if (this.currentTransaction) {
+      throw new Error("Transaction already in progress");
+    }
+    let sql = "BEGIN TRANSACTION";
+    if (options.isolationLevel) {
+      sql += ` ISOLATION LEVEL ${options.isolationLevel}`;
+    }
+    if (options.readOnly) {
+      sql += " READ ONLY";
+    }
+    await this.sql(sql);
+    this.currentTransaction = {
+      id: Math.random().toString(36).substring(7),
+      startTime: /* @__PURE__ */ new Date(),
+      isolationLevel: options.isolationLevel || "READ_COMMITTED",
+      readOnly: options.readOnly || false
+    };
+    if (options.timeout) {
+      setTimeout(() => {
+        if (this.currentTransaction) {
+          this.rollbackTransaction().catch(console.error);
+        }
+      }, options.timeout);
+    }
+    return this.currentTransaction;
+  }
+  /**
+   * Commits the current transaction
+   * @returns Promise resolving when transaction is committed
+   */
+  async commitTransaction() {
+    if (!this.currentTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    await this.sql("COMMIT");
+    this.currentTransaction = null;
+  }
+  /**
+   * Rolls back the current transaction
+   * @returns Promise resolving when transaction is rolled back
+   */
+  async rollbackTransaction() {
+    if (!this.currentTransaction) {
+      throw new Error("No transaction in progress");
+    }
+    await this.sql("ROLLBACK");
+    this.currentTransaction = null;
+  }
+  /**
+   * Gets the current transaction context
+   * @returns Current transaction context or null if no transaction
+   */
+  getCurrentTransaction() {
+    return this.currentTransaction;
+  }
+  // =================================================================
+  // BATCH OPERATIONS
+  // =================================================================
+  /**
+   * Performs batch insert operations
+   * @param options - Batch insert options with table, columns, and rows
+   * @returns Promise resolving to batch operation result
+   */
+  async batchInsert(options) {
+    const { data } = await this.httpClient.post("/batch/insert", {
+      table_name: options.tableName,
+      columns: options.columns,
+      rows: options.rows,
+      on_conflict: options.onConflict,
+      batch_size: options.batchSize || 1e3
+    });
+    return {
+      totalProcessed: data.total_processed,
+      successful: data.successful,
+      failed: data.failed,
+      errors: data.errors,
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Performs batch update operations
+   * @param options - Batch update options with table and update conditions
+   * @returns Promise resolving to batch operation result
+   */
+  async batchUpdate(options) {
+    const { data } = await this.httpClient.post("/batch/update", {
+      table_name: options.tableName,
+      updates: options.updates,
+      batch_size: options.batchSize || 1e3
+    });
+    return {
+      totalProcessed: data.total_processed,
+      successful: data.successful,
+      failed: data.failed,
+      errors: data.errors,
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Performs batch delete operations
+   * @param options - Batch delete options with table and where conditions
+   * @returns Promise resolving to batch operation result
+   */
+  async batchDelete(options) {
+    const { data } = await this.httpClient.post("/batch/delete", {
+      table_name: options.tableName,
+      where_conditions: options.whereConditions,
+      batch_size: options.batchSize || 1e3
+    });
+    return {
+      totalProcessed: data.total_processed,
+      successful: data.successful,
+      failed: data.failed,
+      errors: data.errors,
+      tookMs: data.took_ms
+    };
+  }
+  // =================================================================
+  // ADVANCED SQL FEATURES
+  // =================================================================
+  /**
+   * Prepares a SQL statement for repeated execution
+   * @param sql - SQL statement to prepare
+   * @param options - Preparation options
+   * @returns Promise resolving to prepared statement
+   */
+  async prepareStatement(sql, options = {}) {
+    const { data } = await this.httpClient.post("/prepare", {
+      sql,
+      name: options.name,
+      parameter_types: options.parameterTypes
+    });
+    const prepared = {
+      id: data.statement_id,
+      sql,
+      parameterCount: data.parameter_count
+    };
+    if (options.name) {
+      this.preparedStatements.set(options.name, prepared);
+    }
+    return prepared;
+  }
+  /**
+   * 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
+   */
+  async executePrepared(statementId, params = []) {
+    if (this.preparedStatements.has(statementId)) {
+      statementId = this.preparedStatements.get(statementId).id;
+    }
+    const { data } = await this.httpClient.post("/execute-prepared", {
+      statement_id: statementId,
+      parameters: params
+    });
+    return {
+      columns: data.columns || [],
+      rows: data.rows || [],
+      rows_affected: data.rows_affected,
+      execution_time_ms: data.execution_time_ms || data.took_ms || 0,
+      queryPlan: data.query_plan
+    };
+  }
+  /**
+   * Deallocates a prepared statement
+   * @param statementId - ID of the prepared statement or statement name
+   * @returns Promise resolving when statement is deallocated
+   */
+  async deallocatePrepared(statementId) {
+    if (this.preparedStatements.has(statementId)) {
+      const prepared = this.preparedStatements.get(statementId);
+      await this.httpClient.delete(`/prepare/${prepared.id}`);
+      this.preparedStatements.delete(statementId);
+    } else {
+      await this.httpClient.delete(`/prepare/${statementId}`);
+    }
+  }
+  /**
+   * 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
+   */
+  async queryWithCTEs(ctes, mainQuery, params) {
+    const cteSQL = ctes.map((cte) => {
+      const columns = cte.columns ? `(${cte.columns.join(", ")})` : "";
+      return `${cte.name}${columns} AS (${cte.query})`;
+    }).join(", ");
+    const sql = `WITH ${cteSQL} ${mainQuery}`;
+    return this.sql(sql, params);
+  }
+  /**
+   * 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
+   */
+  async queryWithWindowFunctions(selectQuery, windowFunctions, params) {
+    const windowClauses = windowFunctions.map((wf) => {
+      let clause = `${wf.function} OVER (`;
+      if (wf.options.partitionBy) {
+        clause += `PARTITION BY ${wf.options.partitionBy.join(", ")}`;
+      }
+      if (wf.options.orderBy) {
+        const orderBy = wf.options.orderBy.map((order) => `${order.column} ${order.direction}`).join(", ");
+        clause += ` ORDER BY ${orderBy}`;
+      }
+      if (wf.options.frame) {
+        clause += ` ${wf.options.frame.type} BETWEEN ${wf.options.frame.start}`;
+        if (wf.options.frame.end) {
+          clause += ` AND ${wf.options.frame.end}`;
+        }
+      }
+      clause += `) AS ${wf.alias}`;
+      return clause;
+    }).join(", ");
+    const sql = `${selectQuery}, ${windowClauses}`;
+    return this.sql(sql, params);
+  }
+  /**
+   * 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
+   */
+  async jsonQuery(tableName, jsonColumn, operation, path, value, whereClause) {
+    let sql;
+    switch (operation) {
+      case "extract":
+        sql = `SELECT ${jsonColumn}->>'${path}' as extracted_value FROM ${tableName}`;
+        break;
+      case "update":
+        sql = `UPDATE ${tableName} SET ${jsonColumn} = jsonb_set(${jsonColumn}, '{${path}}', '${JSON.stringify(value)}')`;
+        break;
+      case "delete":
+        sql = `UPDATE ${tableName} SET ${jsonColumn} = ${jsonColumn} - '${path}'`;
+        break;
+      case "contains":
+        sql = `SELECT * FROM ${tableName} WHERE ${jsonColumn} @> '{"${path}": ${JSON.stringify(value)}}'`;
+        break;
+    }
+    if (whereClause && operation !== "contains") {
+      sql += ` WHERE ${whereClause}`;
+    }
+    return this.sql(sql);
+  }
+  // =================================================================
+  // VECTOR OPERATIONS
+  // =================================================================
+  /**
+   * Performs vector addition
+   * @param vector1 - First vector
+   * @param vector2 - Second vector
+   * @returns Promise resolving to vector addition result
+   */
+  async vectorAdd(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/add", {
+      vector1,
+      vector2
+    });
+    return {
+      result: { values: data.result, dimensions: data.result.length },
+      operation: "addition",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Performs vector subtraction
+   * @param vector1 - First vector (minuend)
+   * @param vector2 - Second vector (subtrahend)
+   * @returns Promise resolving to vector subtraction result
+   */
+  async vectorSubtract(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/subtract", {
+      vector1,
+      vector2
+    });
+    return {
+      result: { values: data.result, dimensions: data.result.length },
+      operation: "subtraction",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Performs scalar multiplication on a vector
+   * @param vector - Input vector
+   * @param scalar - Scalar value to multiply by
+   * @returns Promise resolving to scalar multiplication result
+   */
+  async vectorScalarMultiply(vector, scalar) {
+    const { data } = await this.httpClient.post("/vectors/scalar-multiply", {
+      vector,
+      scalar
+    });
+    return {
+      result: { values: data.result, dimensions: data.result.length },
+      operation: "scalar_multiplication",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Calculates the dot product of two vectors
+   * @param vector1 - First vector
+   * @param vector2 - Second vector
+   * @returns Promise resolving to dot product result
+   */
+  async vectorDotProduct(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/dot-product", {
+      vector1,
+      vector2
+    });
+    return {
+      dotProduct: data.dot_product,
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Calculates cosine similarity between two vectors
+   * @param vector1 - First vector
+   * @param vector2 - Second vector
+   * @returns Promise resolving to cosine similarity result
+   */
+  async cosineSimilarity(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/cosine-similarity", {
+      vector1,
+      vector2
+    });
+    return {
+      similarity: data.similarity,
+      function: "cosine",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Calculates L2 (Euclidean) distance between two vectors
+   * @param vector1 - First vector
+   * @param vector2 - Second vector
+   * @returns Promise resolving to L2 distance result
+   */
+  async l2Distance(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/l2-distance", {
+      vector1,
+      vector2
+    });
+    return {
+      distance: data.distance,
+      similarity: data.distance,
+      // Include similarity for compatibility
+      function: "l2",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Calculates inner product between two vectors
+   * @param vector1 - First vector
+   * @param vector2 - Second vector
+   * @returns Promise resolving to inner product result
+   */
+  async innerProduct(vector1, vector2) {
+    if (vector1.length !== vector2.length) {
+      throw new VectorError("Vector dimensions must match", "DIMENSION_MISMATCH");
+    }
+    const { data } = await this.httpClient.post("/vectors/inner-product", {
+      vector1,
+      vector2
+    });
+    return {
+      similarity: data.inner_product,
+      function: "inner_product",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Performs K-nearest neighbors vector search
+   * @param options - KNN search options
+   * @returns Promise resolving to KNN search results
+   */
+  async knnSearch(options) {
+    const { data } = await this.httpClient.post("/vectors/knn-search", {
+      query_vector: options.queryVector,
+      k: options.k,
+      table_name: options.tableName,
+      vector_column: options.vectorColumn,
+      metadata_columns: options.metadataColumns,
+      filter: options.filter
+    });
+    return data.results.map((result) => ({
+      id: result.id,
+      vector: result.vector,
+      similarity: result.similarity,
+      distance: result.distance,
+      metadata: result.metadata
+    }));
+  }
+  /**
+   * Performs range-based vector similarity search
+   * @param options - Range search options
+   * @returns Promise resolving to range search results
+   */
+  async rangeSearch(options) {
+    const { data } = await this.httpClient.post("/vectors/range-search", {
+      query_vector: options.queryVector,
+      threshold: options.threshold,
+      table_name: options.tableName,
+      vector_column: options.vectorColumn,
+      metadata_columns: options.metadataColumns,
+      filter: options.filter,
+      max_results: options.maxResults
+    });
+    return data.results.map((result) => ({
+      id: result.id,
+      vector: result.vector,
+      similarity: result.similarity,
+      distance: result.distance,
+      metadata: result.metadata
+    }));
+  }
+  /**
+   * Performs hybrid search combining vector similarity and SQL filtering
+   * @param options - Hybrid search options
+   * @returns Promise resolving to hybrid search results
+   */
+  async hybridSearch(options) {
+    const { data } = await this.httpClient.post("/vectors/hybrid-search", {
+      vector: options.vector,
+      text_query: options.textQuery,
+      sql_filter: options.sqlFilter,
+      k: options.k,
+      threshold: options.threshold,
+      metric: options.metric,
+      filter: options.filter,
+      weights: options.weights
+    });
+    return data.results.map((result) => ({
+      id: result.id,
+      vector: result.vector,
+      similarity: result.similarity,
+      distance: result.distance,
+      metadata: result.metadata
+    }));
+  }
+  /**
+   * Normalizes a vector to unit length
+   * @param vector - Input vector to normalize
+   * @returns Promise resolving to normalized vector
+   */
+  async normalizeVector(vector) {
+    const { data } = await this.httpClient.post("/vectors/normalize", {
+      vector
+    });
+    return {
+      result: { values: data.result, dimensions: data.result.length },
+      operation: "normalization",
+      tookMs: data.took_ms
+    };
+  }
+  /**
+   * Calculates the magnitude (length) of a vector
+   * @param vector - Input vector
+   * @returns Promise resolving to vector magnitude
+   */
+  async vectorMagnitude(vector) {
+    const { data } = await this.httpClient.post("/vectors/magnitude", {
+      vector
+    });
+    return {
+      magnitude: data.magnitude,
+      tookMs: data.took_ms
+    };
+  }
+  // =================================================================
+  // AUTHENTICATION & USER MANAGEMENT
+  // =================================================================
+  /**
+   * Register a new user
+   */
+  async registerUser(request) {
+    const { data } = await this.httpClient.post("/auth/register", {
+      username: request.username,
+      email: request.email,
+      password: request.password
+    });
+    return data;
+  }
+  /**
+   * Login with username and password
+   */
+  async login(request) {
+    const { data } = await this.httpClient.post("/auth/login", {
+      username: request.username,
+      password: request.password
+    });
+    if (data.access_token) {
+      this.config.jwtToken = data.access_token;
+      this.httpClient.defaults.headers["Authorization"] = `Bearer ${data.access_token}`;
+      delete this.httpClient.defaults.headers["X-API-Key"];
+    }
+    return data;
+  }
+  /**
+   * Refresh JWT token
+   */
+  async refreshToken() {
+    const { data } = await this.httpClient.post("/auth/refresh");
+    if (data.access_token) {
+      this.config.jwtToken = data.access_token;
+      this.httpClient.defaults.headers["Authorization"] = `Bearer ${data.access_token}`;
+      delete this.httpClient.defaults.headers["X-API-Key"];
+    }
+    return data;
+  }
+  /**
+   * Set JWT token manually (useful after login)
+   */
+  setJWTToken(token) {
+    this.config.jwtToken = token;
+    this.httpClient.defaults.headers["Authorization"] = `Bearer ${token}`;
+    delete this.httpClient.defaults.headers["X-API-Key"];
+  }
+  /**
+   * Clear authentication (logout)
+   */
+  logout() {
+    this.config.jwtToken = "";
+    delete this.httpClient.defaults.headers["Authorization"];
+    delete this.httpClient.defaults.headers["X-API-Key"];
+  }
+  // =================================================================
+  // API KEY MANAGEMENT
+  // =================================================================
+  /**
+   * Create a new API key
+   */
+  async createAPIKey(request) {
+    const { data } = await this.httpClient.post("/api-keys", {
+      name: request.name,
+      permission: request.permission,
+      expires_in_days: request.expires_in_days
+    });
+    return data;
+  }
+  /**
+   * List all API keys
+   */
+  async listAPIKeys() {
+    const { data } = await this.httpClient.get("/api-keys");
+    return data;
+  }
+  /**
+   * Get API key statistics
+   */
+  async getAPIKeyStats(keyId) {
+    const { data } = await this.httpClient.get(`/api-keys/${keyId}/stats`);
+    return data;
+  }
+  /**
+   * Revoke (delete) an API key
+   */
+  async revokeAPIKey(keyId) {
+    await this.httpClient.delete(`/api-keys/${keyId}`);
+  }
+  // =================================================================
+  // MULTIMEDIA MANAGEMENT
+  // =================================================================
+  /**
+   * Upload multimedia file to a document
+   */
+  async uploadMultimedia(collection, documentId, file, metadata) {
+    let FormDataClass;
+    try {
+      FormDataClass = __require("form-data");
+    } catch {
+      FormDataClass = FormData;
+    }
+    const formData = new FormDataClass();
+    if (Buffer.isBuffer(file)) {
+      formData.append("file", file, { filename: "upload" });
+    } else {
+      formData.append("file", file);
+    }
+    if (metadata) {
+      formData.append("metadata", JSON.stringify(metadata));
+    }
+    const headers = {};
+    if (typeof formData.getHeaders === "function") {
+      Object.assign(headers, formData.getHeaders());
+    }
+    const { data } = await this.httpClient.post(
+      `/multimedia/${collection}/documents/${documentId}/multimedia`,
+      formData,
+      {
+        headers
+      }
+    );
+    return data;
+  }
+  /**
+   * Get multimedia file URL (for viewing/downloading)
+   */
+  getMultimediaUrl(collection, documentId, multimediaId, download = false) {
+    const protocol = this.config.useHttps ? "https" : "http";
+    const baseUrl = `${protocol}://${this.config.host}:${this.config.port}/v1`;
+    return `${baseUrl}/multimedia/${collection}/documents/${documentId}/multimedia/${multimediaId}${download ? "?download=true" : ""}`;
+  }
+  /**
+   * Get multimedia thumbnail URL
+   */
+  getMultimediaThumbnailUrl(collection, documentId, multimediaId) {
+    const protocol = this.config.useHttps ? "https" : "http";
+    const baseUrl = `${protocol}://${this.config.host}:${this.config.port}/v1`;
+    return `${baseUrl}/multimedia/${collection}/documents/${documentId}/multimedia/${multimediaId}/thumbnail`;
+  }
+  /**
+   * List multimedia files in a document
+   */
+  async listMultimedia(collection, documentId, limit = 50, offset = 0) {
+    const { data } = await this.httpClient.get(
+      `/multimedia/${collection}/documents/${documentId}/multimedia?limit=${limit}&offset=${offset}`
+    );
+    return data;
+  }
+  /**
+   * Get multimedia file information
+   */
+  async getMultimedia(collection, documentId, multimediaId) {
+    const { data } = await this.httpClient.get(
+      `/multimedia/${collection}/documents/${documentId}/multimedia/${multimediaId}`
+    );
+    return data;
+  }
+  /**
+   * Delete multimedia file
+   */
+  async deleteMultimedia(collection, documentId, multimediaId) {
+    await this.httpClient.delete(`/multimedia/${collection}/documents/${documentId}/multimedia/${multimediaId}`);
+  }
+};
+
+// src/index.ts
+import { z } from "zod";
+var VERSION = "0.1.0";
+export {
+  AuthenticationError,
+  AutoMLClient,
+  AutoMLModel,
+  BackupClient,
+  BatchOperationError,
+  Collection,
+  ConnectionError,
+  ImportExportClient,
+  IntegrationClient,
+  NLPClient,
+  NotFoundError,
+  RateLimitError,
+  RecipeClient,
+  SQLError,
+  SchemaClient,
+  ServerError,
+  Subscription,
+  SynapCores,
+  SynapCoresError,
+  TimeoutError,
+  TransactionError,
+  VERSION,
+  ValidationError,
+  VectorError,
+  z
+};
+//# sourceMappingURL=index.mjs.map