@boltic/sdk 0.0.1

package/dist/sdk.js

@@ -0,0 +1,3972 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function createErrorWithContext$1(message, context) {
+  const error = new Error(message);
+  if (context) {
+    error.context = context;
+  }
+  return error;
+}
+function isNetworkError(error) {
+  return error instanceof Error && (error.message.includes("network") || error.message.includes("fetch") || error.message.includes("timeout") || error.name === "AbortError");
+}
+function getHttpStatusCode$1(error) {
+  if (error && typeof error === "object") {
+    if ("response" in error && error.response && typeof error.response === "object") {
+      const response = error.response;
+      if ("status" in response && typeof response.status === "number") {
+        return response.status;
+      }
+    }
+    if ("status" in error && typeof error.status === "number") {
+      return error.status;
+    }
+  }
+  return null;
+}
+function formatError$1(error) {
+  if (error instanceof Error) {
+    const context = error.context;
+    const statusCode = getHttpStatusCode$1(error);
+    let formatted = `${error.name}: ${error.message}`;
+    if (statusCode) {
+      formatted += ` (HTTP ${statusCode})`;
+    }
+    if (context) {
+      formatted += `
+Context: ${JSON.stringify(context, null, 2)}`;
+    }
+    return formatted;
+  }
+  return String(error);
+}
+let AuthManager$1 = class AuthManager {
+  constructor(config) {
+    this.tokenInfo = null;
+    this.config = config;
+    this.validateApiKey(config.apiKey);
+  }
+  validateApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw createErrorWithContext$1(
+        "API key is required and must be a non-empty string",
+        {
+          name: "AuthenticationError",
+          code: "INVALID_API_KEY"
+        }
+      );
+    }
+    if (apiKey.length < 10) {
+      throw createErrorWithContext$1(
+        "API key appears to be invalid (too short)",
+        {
+          name: "AuthenticationError",
+          code: "INVALID_API_KEY_FORMAT"
+        }
+      );
+    }
+  }
+  getAuthHeaders() {
+    return {
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  updateApiKey(newApiKey) {
+    this.validateApiKey(newApiKey);
+    this.config.apiKey = newApiKey;
+    this.tokenInfo = null;
+  }
+  isAuthenticated() {
+    return !!this.config.apiKey;
+  }
+  async validateApiKeyAsync() {
+    try {
+      this.validateApiKey(this.config.apiKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getTokenInfo() {
+    return this.tokenInfo ? { ...this.tokenInfo } : null;
+  }
+  // Generic method to get headers for any Boltic service
+  getServiceHeaders(service) {
+    const headers = this.getAuthHeaders();
+    if (service) {
+      headers["x-boltic-service"] = service;
+    }
+    return headers;
+  }
+  // Method to validate API key for specific service
+  async validateForService() {
+    try {
+      const isValid = await this.validateApiKeyAsync();
+      if (isValid) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+class ValidationError extends Error {
+  constructor(message, failures = []) {
+    super(message);
+    this.name = "ValidationError";
+    this.failures = failures;
+  }
+}
+class ApiError extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+}
+function createErrorWithContext(message, context) {
+  const error = new Error(message);
+  if (context) {
+    error.context = context;
+  }
+  return error;
+}
+function getHttpStatusCode(error) {
+  if (error && typeof error === "object") {
+    if ("response" in error && error.response && typeof error.response === "object") {
+      const response = error.response;
+      if ("status" in response && typeof response.status === "number") {
+        return response.status;
+      }
+    }
+    if ("status" in error && typeof error.status === "number") {
+      return error.status;
+    }
+  }
+  return null;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const context = error.context;
+    const statusCode = getHttpStatusCode(error);
+    let formatted = `${error.name}: ${error.message}`;
+    if (statusCode) {
+      formatted += ` (HTTP ${statusCode})`;
+    }
+    if (context) {
+      formatted += `
+Context: ${JSON.stringify(context, null, 2)}`;
+    }
+    return formatted;
+  }
+  return String(error);
+}
+class AuthManager2 {
+  constructor(config) {
+    this.tokenInfo = null;
+    this.config = {
+      maxRetries: 3,
+      ...config
+    };
+    this.validateApiKey(config.apiKey);
+  }
+  validateApiKey(apiKey) {
+    if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw createErrorWithContext(
+        "API key is required and must be a non-empty string",
+        {
+          name: "AuthenticationError",
+          code: "INVALID_API_KEY"
+        }
+      );
+    }
+    if (apiKey.length < 10) {
+      throw createErrorWithContext(
+        "API key appears to be invalid (too short)",
+        {
+          name: "AuthenticationError",
+          code: "INVALID_API_KEY_FORMAT"
+        }
+      );
+    }
+  }
+  getAuthHeaders() {
+    return {
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  updateApiKey(newApiKey) {
+    this.validateApiKey(newApiKey);
+    this.config.apiKey = newApiKey;
+    this.tokenInfo = null;
+  }
+  isAuthenticated() {
+    return !!this.config.apiKey;
+  }
+  async validateApiKeyAsync() {
+    try {
+      this.validateApiKey(this.config.apiKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getTokenInfo() {
+    return this.tokenInfo ? { ...this.tokenInfo } : null;
+  }
+  getMaxRetries() {
+    return this.config.maxRetries || 3;
+  }
+  // Security methods to prevent API key exposure
+  toString() {
+    return `AuthManager { authenticated: ${this.isAuthenticated()}, maxRetries: ${this.getMaxRetries()} }`;
+  }
+  toJSON() {
+    return {
+      authenticated: this.isAuthenticated(),
+      maxRetries: this.getMaxRetries()
+    };
+  }
+  // Custom inspect method for Node.js console logging
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+class AxiosAdapter {
+  constructor() {
+    try {
+      this.axios = require("axios");
+    } catch (error) {
+      throw createErrorWithContext(
+        "Axios is required for Node.js < 18. Please install axios: npm install axios",
+        { error }
+      );
+    }
+  }
+  async request(config) {
+    try {
+      const axiosConfig = {
+        url: config.url,
+        method: config.method.toLowerCase(),
+        headers: config.headers,
+        params: config.params,
+        data: config.data,
+        timeout: config.timeout,
+        signal: config.signal,
+        validateStatus: () => true
+        // Don't throw on non-2xx status codes
+      };
+      const response = await this.axios(axiosConfig);
+      return {
+        data: response.data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers || {}
+      };
+    } catch (error) {
+      const axiosError = error;
+      if (axiosError.code === "ECONNABORTED" || axiosError.message?.includes("timeout")) {
+        throw createErrorWithContext("Request timeout", {
+          url: config.url,
+          method: config.method,
+          timeout: config.timeout
+        });
+      }
+      if (axiosError.code === "ERR_NETWORK" || axiosError.code === "ENOTFOUND" || axiosError.code === "ECONNREFUSED" || axiosError.code === "EHOSTUNREACH" || axiosError.code === "ETIMEDOUT" || axiosError.code === "ERR_INTERNET_DISCONNECTED" || axiosError.message?.includes("network") || axiosError.message?.includes("internet") || axiosError.message?.includes("connection") || axiosError.message?.includes("resolve")) {
+        throw createErrorWithContext(
+          "Network connection failed. Please check your internet connection or VPN settings.",
+          {
+            url: config.url,
+            method: config.method,
+            networkError: true,
+            errorCode: axiosError.code,
+            originalMessage: axiosError.message
+          }
+        );
+      }
+      if (axiosError.name === "AbortError" || axiosError.code === "ERR_CANCELED") {
+        throw createErrorWithContext("Request was aborted", {
+          url: config.url,
+          method: config.method
+        });
+      }
+      throw createErrorWithContext(
+        `HTTP request failed: ${axiosError.message || "Unknown error"}`,
+        {
+          url: config.url,
+          method: config.method,
+          originalError: error
+        }
+      );
+    }
+  }
+}
+class FetchAdapter {
+  async request(config) {
+    const url = new URL(config.url);
+    if (config.params) {
+      Object.entries(config.params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    const init = {
+      method: config.method,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers
+      },
+      signal: config.signal
+    };
+    if (config.data && ["POST", "PUT", "PATCH", "DELETE"].includes(config.method)) {
+      init.body = JSON.stringify(config.data);
+    }
+    try {
+      const controller = new AbortController();
+      let timeoutId;
+      if (config.timeout) {
+        timeoutId = setTimeout(() => controller.abort(), config.timeout);
+        init.signal = config.signal ? (() => {
+          const combinedController = new AbortController();
+          config.signal.addEventListener(
+            "abort",
+            () => combinedController.abort()
+          );
+          controller.signal.addEventListener(
+            "abort",
+            () => combinedController.abort()
+          );
+          return combinedController.signal;
+        })() : controller.signal;
+      }
+      const response = await fetch(url.toString(), init);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      const contentType = response.headers.get("content-type");
+      let data;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      const httpResponse = {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      };
+      return httpResponse;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw createErrorWithContext("Request was aborted", {
+          type: "AbortError",
+          url: config.url,
+          method: config.method
+        });
+      }
+      if (error instanceof Error) {
+        const errorMessage = error.message.toLowerCase();
+        if (error.name === "TypeError" && (errorMessage.includes("network") || errorMessage.includes("fetch") || errorMessage.includes("failed to fetch") || errorMessage.includes("internet") || errorMessage.includes("connection") || errorMessage.includes("resolve") || errorMessage.includes("unreachable"))) {
+          throw createErrorWithContext(
+            "Network connection failed. Please check your internet connection or VPN settings.",
+            {
+              url: config.url,
+              method: config.method,
+              networkError: true,
+              originalMessage: error.message
+            }
+          );
+        }
+      }
+      throw createErrorWithContext(
+        `HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          url: config.url,
+          method: config.method,
+          originalError: error
+        }
+      );
+    }
+  }
+}
+function createHttpAdapter() {
+  if (typeof fetch !== "undefined") {
+    return new FetchAdapter();
+  }
+  try {
+    return new AxiosAdapter();
+  } catch (error) {
+    throw createErrorWithContext(
+      "No suitable HTTP adapter found. Please use Node.js >= 18 or install axios: npm install axios",
+      { error }
+    );
+  }
+}
+class InterceptorManagerImpl {
+  constructor() {
+    this.requestInterceptors = /* @__PURE__ */ new Map();
+    this.responseInterceptors = /* @__PURE__ */ new Map();
+    this.nextId = 0;
+    this.request = {
+      use: (interceptor) => {
+        const id = this.nextId++;
+        this.requestInterceptors.set(id, interceptor);
+        return id;
+      },
+      eject: (id) => {
+        this.requestInterceptors.delete(id);
+      }
+    };
+    this.response = {
+      use: (onFulfilled, onRejected) => {
+        const id = this.nextId++;
+        this.responseInterceptors.set(id, {
+          fulfilled: onFulfilled,
+          rejected: onRejected
+        });
+        return id;
+      },
+      eject: (id) => {
+        this.responseInterceptors.delete(id);
+      }
+    };
+  }
+  async executeRequestInterceptors(config) {
+    let result = config;
+    for (const interceptor of this.requestInterceptors.values()) {
+      result = await interceptor(result);
+    }
+    return result;
+  }
+  async executeResponseInterceptors(response) {
+    let result = response;
+    for (const { fulfilled } of this.responseInterceptors.values()) {
+      if (fulfilled) {
+        result = await fulfilled(result);
+      }
+    }
+    return result;
+  }
+  async executeErrorInterceptors(error) {
+    let result = error;
+    for (const { rejected } of this.responseInterceptors.values()) {
+      if (rejected) {
+        result = await rejected(result);
+      }
+    }
+    return result;
+  }
+}
+class BaseClient {
+  constructor(config, authManager) {
+    this.config = config;
+    this.authManager = authManager;
+    this.httpAdapter = createHttpAdapter();
+    this.interceptors = new InterceptorManagerImpl();
+    this.setupDefaultInterceptors();
+  }
+  setupDefaultInterceptors() {
+    this.interceptors.request.use((config) => {
+      const authHeaders = this.authManager.getAuthHeaders();
+      config.headers = {
+        ...config.headers,
+        ...authHeaders,
+        ...this.config.headers
+      };
+      return config;
+    });
+    this.interceptors.response.use(
+      (response) => {
+        if (this.config.debug) {
+          console.log("HTTP Response:", response);
+        }
+        return response;
+      },
+      (error) => {
+        return this.handleError(error);
+      }
+    );
+  }
+  handleError(error) {
+    if (this.config.debug) {
+      console.error("HTTP Error:", error);
+    }
+    if (error instanceof Error && error.context) {
+      throw error;
+    }
+    const statusCode = getHttpStatusCode(error);
+    if (!statusCode) {
+      throw createErrorWithContext("Network request failed", {
+        name: "NetworkError",
+        originalError: error
+      });
+    }
+    const errorData = error.response?.data || error.data;
+    const message = errorData?.message || errorData?.error || `HTTP ${statusCode} error`;
+    throw createErrorWithContext(message, {
+      name: "ApiError",
+      statusCode,
+      response: errorData,
+      isClientError: statusCode >= 400 && statusCode < 500,
+      isServerError: statusCode >= 500,
+      isAuthError: statusCode === 401 || statusCode === 403,
+      isNotFoundError: statusCode === 404,
+      isRateLimitError: statusCode === 429
+    });
+  }
+  async request(config) {
+    let lastError;
+    const maxRetries = this.config.maxRetries;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        if (!config.url.startsWith("http")) {
+          config.url = `${this.config.baseURL}${config.url}`;
+        }
+        if (!config.timeout) {
+          config.timeout = this.config.timeout;
+        }
+        const requestConfig = await this.interceptors.executeRequestInterceptors(config);
+        const response = await this.httpAdapter.request(requestConfig);
+        if (response.status >= 400) {
+          const error = createErrorWithContext(
+            `HTTP ${response.status} error`,
+            {
+              name: "ApiError",
+              statusCode: response.status,
+              response: response.data,
+              statusText: response.statusText
+            }
+          );
+          throw await this.interceptors.executeErrorInterceptors(error);
+        }
+        return await this.interceptors.executeResponseInterceptors(
+          response
+        );
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries) {
+          break;
+        }
+        const statusCode = getHttpStatusCode(error);
+        if (statusCode && statusCode >= 400 && statusCode < 500) {
+          break;
+        }
+        if (attempt < maxRetries) {
+          const delay = this.config.retryDelay * Math.pow(2, attempt);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw await this.interceptors.executeErrorInterceptors(lastError);
+  }
+  get(url, config) {
+    return this.request({ ...config, method: "GET", url });
+  }
+  post(url, data, config) {
+    return this.request({ ...config, method: "POST", url, data });
+  }
+  put(url, data, config) {
+    return this.request({ ...config, method: "PUT", url, data });
+  }
+  patch(url, data, config) {
+    return this.request({ ...config, method: "PATCH", url, data });
+  }
+  delete(url, config) {
+    return this.request({ ...config, method: "DELETE", url });
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+}
+const REGION_CONFIGS = {
+  "asia-south1": {
+    local: {
+      baseURL: "http://localhost:8000",
+      timeout: 3e4,
+      debug: true
+    },
+    sit: {
+      baseURL: "https://asia-south1.api.fcz0.de/service/sdk/boltic-tables",
+      timeout: 15e3
+    },
+    uat: {
+      baseURL: "https://asia-south1.api.uat.fcz0.de/service/sdk/boltic-tables",
+      timeout: 15e3
+    },
+    prod: {
+      baseURL: "https://asia-south1.api.boltic.io/service/sdk/boltic-tables",
+      timeout: 1e4
+    }
+  },
+  "us-central1": {
+    local: {
+      baseURL: "http://localhost:8000",
+      timeout: 3e4,
+      debug: true
+    },
+    sit: {
+      baseURL: "https://us-central1.api.fcz0.de/service/sdk/boltic-tables",
+      timeout: 15e3
+    },
+    uat: {
+      baseURL: "https://us-central1.api.uat.fcz0.de/service/sdk/boltic-tables",
+      timeout: 15e3
+    },
+    prod: {
+      baseURL: "https://us-central1.api.boltic.io/service/sdk/boltic-tables",
+      timeout: 1e4
+    }
+  }
+};
+class ConfigManager {
+  constructor(apiKey, environment = "prod", region = "asia-south1", overrides) {
+    const envConfig = REGION_CONFIGS[region][environment];
+    this.config = {
+      apiKey,
+      environment,
+      region,
+      retryAttempts: 3,
+      retryDelay: 1e3,
+      maxRetries: 3,
+      debug: false,
+      headers: {},
+      ...envConfig,
+      ...overrides
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  // Security methods to prevent API key exposure
+  toString() {
+    return `ConfigManager { environment: "${this.config.environment}", region: "${this.config.region}", debug: ${this.config.debug} }`;
+  }
+  toJSON() {
+    const safeConfig = { ...this.config };
+    delete safeConfig.apiKey;
+    return safeConfig;
+  }
+  // Custom inspect method for Node.js console logging
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+function filterObjectFields(obj, fields) {
+  if (!fields || fields.length === 0) {
+    return obj;
+  }
+  const filtered = {};
+  for (const field of fields) {
+    if (field in obj) {
+      filtered[field] = obj[field];
+    }
+  }
+  return filtered;
+}
+function filterArrayFields(arr, fields) {
+  if (!fields || fields.length === 0) {
+    return arr;
+  }
+  return arr.map((obj) => filterObjectFields(obj, fields));
+}
+const COLUMN_ENDPOINTS = {
+  list: {
+    path: "/tables/{table_id}/fields/list",
+    method: "POST",
+    authenticated: true,
+    rateLimit: { requests: 200, window: 6e4 }
+  },
+  create: {
+    path: "/tables/{table_id}/fields",
+    method: "POST",
+    authenticated: true
+  },
+  get: {
+    path: "/tables/{table_id}/fields/{field_id}",
+    method: "GET",
+    authenticated: true,
+    rateLimit: { requests: 300, window: 6e4 }
+  },
+  update: {
+    path: "/tables/{table_id}/fields/{field_id}",
+    method: "PATCH",
+    authenticated: true
+  },
+  delete: {
+    path: "/tables/{table_id}/fields/{field_id}",
+    method: "DELETE",
+    authenticated: true
+  }
+};
+const buildEndpointPath$1 = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  });
+  const unreplacedParams = path.match(/\{([^}]+)\}/g);
+  if (unreplacedParams) {
+    throw new Error(`Missing path parameters: ${unreplacedParams.join(", ")}`);
+  }
+  return path;
+};
+const DateFormatEnum = Object.freeze({
+  MMDDYY: "%m/%d/%y",
+  MMDDYYYY: "%m/%d/%Y",
+  MM_DD_YYYY: "%m-%d-%Y",
+  DD_MM_YYYY: "%d-%m-%Y",
+  DDMMYYYY: "%d/%m/%Y",
+  DDMMYY: "%d/%m/%y",
+  YYYY_MM_DD: "%Y-%m-%d",
+  MMMM__DD__YYYY: "%B %d %Y",
+  MMM__DD__YYYY: "%b %d %Y",
+  ddd__MMM__DD__YYYY: "%a %b %d %Y"
+});
+const TimeFormatEnum = Object.freeze({
+  HH_mm_ss: "%H:%M:%S",
+  HH_mm_ssZ: "%H:%M:%SZ",
+  HH_mm_ss_SSS: "%H:%M:%S.%f",
+  HH_mm_ss__Z: "%H:%M:%S %Z",
+  HH_mm__AMPM: "%I:%M %p",
+  // 12-hour format with AM/PM
+  HH_mm_ss__AMPM: "%I:%M:%S %p"
+});
+function transformColumnCreateRequest(request) {
+  if (!request || typeof request !== "object") {
+    throw new Error("Invalid request: single column data is required");
+  }
+  if (!request.name || !request.type) {
+    throw new Error("Column name and type are required");
+  }
+  return transformFieldDefinition$1(request);
+}
+function transformFieldDefinition$1(field) {
+  return {
+    name: field.name,
+    type: field.type,
+    is_nullable: field.is_nullable ?? true,
+    is_primary_key: field.is_primary_key ?? false,
+    is_unique: field.is_unique ?? false,
+    is_visible: field.is_visible ?? true,
+    is_readonly: field.is_readonly ?? false,
+    is_indexed: field.is_indexed ?? false,
+    field_order: field.field_order ?? 1,
+    alignment: field.alignment ?? "left",
+    timezone: field.timezone ?? void 0,
+    date_format: field.date_format ? transformDateFormat(field.date_format) : void 0,
+    time_format: field.time_format ? transformTimeFormat(field.time_format) : void 0,
+    decimals: field.decimals ?? void 0,
+    currency_format: field.currency_format ?? void 0,
+    selection_source: field.type === "dropdown" && !field.selection_source ? "provide-static-list" : field.selection_source ?? void 0,
+    selectable_items: field.selectable_items ?? void 0,
+    multiple_selections: field.multiple_selections ?? void 0,
+    phone_format: field.phone_format ?? void 0,
+    vector_dimension: field.vector_dimension ?? void 0,
+    description: field.description ?? void 0,
+    default_value: field.default_value ?? void 0
+  };
+}
+function transformColumnUpdateRequest(updates) {
+  const apiRequest = {};
+  if (updates.name !== void 0) apiRequest.name = updates.name;
+  if (updates.type !== void 0) apiRequest.type = updates.type;
+  if (updates.description !== void 0)
+    apiRequest.description = updates.description;
+  if (updates.is_nullable !== void 0)
+    apiRequest.is_nullable = updates.is_nullable;
+  if (updates.is_unique !== void 0) apiRequest.is_unique = updates.is_unique;
+  if (updates.is_primary_key !== void 0)
+    apiRequest.is_primary_key = updates.is_primary_key;
+  if (updates.is_indexed !== void 0)
+    apiRequest.is_indexed = updates.is_indexed;
+  if (updates.is_visible !== void 0)
+    apiRequest.is_visible = updates.is_visible;
+  if (updates.is_readonly !== void 0)
+    apiRequest.is_readonly = updates.is_readonly;
+  if (updates.default_value !== void 0)
+    apiRequest.default_value = updates.default_value;
+  if (updates.field_order !== void 0)
+    apiRequest.field_order = updates.field_order;
+  if (updates.alignment !== void 0) apiRequest.alignment = updates.alignment;
+  if (updates.decimals !== void 0) apiRequest.decimals = updates.decimals;
+  if (updates.currency_format !== void 0)
+    apiRequest.currency_format = updates.currency_format;
+  if (updates.type === "dropdown") {
+    apiRequest.selection_source = "provide-static-list";
+  } else if (updates.selectable_items !== void 0) {
+    apiRequest.selection_source = "provide-static-list";
+  } else if (updates.selection_source !== void 0) {
+    apiRequest.selection_source = updates.selection_source;
+  }
+  if (updates.selectable_items !== void 0)
+    apiRequest.selectable_items = updates.selectable_items;
+  if (updates.multiple_selections !== void 0)
+    apiRequest.multiple_selections = updates.multiple_selections;
+  if (updates.phone_format !== void 0)
+    apiRequest.phone_format = updates.phone_format;
+  if (updates.timezone !== void 0) apiRequest.timezone = updates.timezone;
+  if (updates.vector_dimension !== void 0)
+    apiRequest.vector_dimension = updates.vector_dimension;
+  if (updates.date_format !== void 0) {
+    apiRequest.date_format = transformDateFormat(updates.date_format);
+  }
+  if (updates.time_format !== void 0) {
+    apiRequest.time_format = transformTimeFormat(updates.time_format);
+  }
+  return apiRequest;
+}
+function transformDateFormat(dateFormat) {
+  return DateFormatEnum[dateFormat] || dateFormat;
+}
+function transformTimeFormat(timeFormat) {
+  return TimeFormatEnum[timeFormat] || timeFormat;
+}
+class ColumnsApiClient {
+  constructor(apiKey, config = {}) {
+    this.config = { apiKey, ...config };
+    this.httpAdapter = createHttpAdapter();
+    const environment = config.environment || "prod";
+    const region = config.region || "asia-south1";
+    this.baseURL = this.getBaseURL(environment, region);
+  }
+  getBaseURL(environment, region) {
+    const regionConfig = REGION_CONFIGS[region];
+    if (!regionConfig) {
+      throw new Error(`Unsupported region: ${region}`);
+    }
+    const envConfig = regionConfig[environment];
+    if (!envConfig) {
+      throw new Error(
+        `Unsupported environment: ${environment} for region: ${region}`
+      );
+    }
+    return `${envConfig.baseURL}/v1`;
+  }
+  /**
+   * Create a single column in a table
+   */
+  async createColumn(tableId, request) {
+    try {
+      const endpoint = COLUMN_ENDPOINTS.create;
+      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, { table_id: tableId })}`;
+      const transformedRequest = transformColumnCreateRequest(request);
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: transformedRequest,
+        timeout: this.config.timeout
+      });
+      if (this.config.debug) {
+        console.log(
+          "Column API Response:",
+          JSON.stringify(response.data, null, 2)
+        );
+      }
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Create multiple columns in a table (one by one)
+   */
+  async createColumns(tableId, request) {
+    try {
+      const columns = request.columns;
+      const createdColumns = [];
+      for (const column of columns) {
+        const result = await this.createColumn(tableId, column);
+        if ("error" in result) {
+          return result;
+        }
+        createdColumns.push(result.data);
+      }
+      if (request.fields && createdColumns.length > 0) {
+        const filteredColumns = filterArrayFields(
+          createdColumns,
+          request.fields
+        );
+        createdColumns.splice(0, createdColumns.length, ...filteredColumns);
+      }
+      return {
+        data: createdColumns,
+        message: "Columns created successfully"
+      };
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * List columns in a table with filtering and pagination
+   */
+  async listColumns(tableId, options = {}) {
+    try {
+      const endpoint = COLUMN_ENDPOINTS.list;
+      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, { table_id: tableId })}?no_cache=true`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: options,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (options.fields && responseData.data) {
+        responseData.data = filterArrayFields(
+          responseData.data,
+          options.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Get a single column by ID
+   */
+  async getColumn(tableId, columnId, options = {}) {
+    try {
+      const endpoint = COLUMN_ENDPOINTS.get;
+      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, {
+        table_id: tableId,
+        field_id: columnId
+      })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      if (this.config.debug) {
+        console.log(
+          "Column API Response:",
+          JSON.stringify(response.data, null, 2)
+        );
+      }
+      const responseData = response.data;
+      if (options.fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          options.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Update a column
+   */
+  async updateColumn(tableId, columnId, updates) {
+    try {
+      const endpoint = COLUMN_ENDPOINTS.update;
+      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, {
+        table_id: tableId,
+        field_id: columnId
+      })}`;
+      const transformedUpdates = transformColumnUpdateRequest(updates);
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: transformedUpdates,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (updates.fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          updates.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Delete a column
+   */
+  async deleteColumn(tableId, columnId) {
+    try {
+      const endpoint = COLUMN_ENDPOINTS.delete;
+      const url = `${this.baseURL}${buildEndpointPath$1(endpoint, {
+        table_id: tableId,
+        field_id: columnId
+      })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Find column by name in a table
+   */
+  async findColumnByName(tableId, columnName) {
+    try {
+      const apiRequest = {
+        page: { page_no: 1, page_size: 1 },
+        filters: [
+          {
+            field: "name",
+            operator: "=",
+            values: [columnName]
+          }
+        ],
+        sort: []
+      };
+      const listResult = await this.listColumns(
+        tableId,
+        apiRequest
+      );
+      if ("error" in listResult) {
+        return listResult;
+      }
+      const column = listResult.data[0] || null;
+      return {
+        data: column,
+        message: column ? "Column found" : "Column not found"
+      };
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Helper function to convert ColumnDetails to ColumnUpdateRequest format
+   */
+  convertColumnDetailsToUpdateRequest(columnDetails) {
+    return {
+      name: columnDetails.name,
+      type: columnDetails.type,
+      description: columnDetails.description,
+      is_nullable: columnDetails.is_nullable,
+      is_unique: columnDetails.is_unique,
+      is_indexed: columnDetails.is_indexed,
+      is_visible: columnDetails.is_visible,
+      is_primary_key: columnDetails.is_primary_key,
+      is_readonly: columnDetails.is_readonly,
+      default_value: columnDetails.default_value,
+      field_order: columnDetails.field_order,
+      alignment: columnDetails.alignment,
+      decimals: columnDetails.decimals,
+      currency_format: columnDetails.currency_format,
+      selection_source: columnDetails.selection_source,
+      selectable_items: columnDetails.selectable_items,
+      multiple_selections: columnDetails.multiple_selections,
+      phone_format: columnDetails.phone_format,
+      date_format: columnDetails.date_format,
+      time_format: columnDetails.time_format,
+      timezone: columnDetails.timezone,
+      vector_dimension: columnDetails.vector_dimension
+    };
+  }
+  /**
+   * Update a column by name
+   */
+  async updateColumnByName(tableId, columnName, updates) {
+    try {
+      const findResult = await this.findColumnByName(tableId, columnName);
+      if ("error" in findResult) {
+        return findResult;
+      }
+      if (!findResult.data) {
+        return {
+          error: {
+            code: "COLUMN_NOT_FOUND",
+            message: `Column '${columnName}' not found in table`,
+            meta: ["404"]
+          }
+        };
+      }
+      const existingColumnAsUpdate = this.convertColumnDetailsToUpdateRequest(
+        findResult.data
+      );
+      const mergedUpdates = {
+        ...existingColumnAsUpdate,
+        ...updates
+      };
+      return await this.updateColumn(
+        tableId,
+        findResult.data.id,
+        mergedUpdates
+      );
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Delete column by name
+   */
+  async deleteColumnByName(tableId, columnName) {
+    try {
+      const findResult = await this.findColumnByName(tableId, columnName);
+      if ("error" in findResult) {
+        return findResult;
+      }
+      if (!findResult.data) {
+        return {
+          error: {
+            code: "COLUMN_NOT_FOUND",
+            message: `Column '${columnName}' not found in table`,
+            meta: ["Column not found"]
+          }
+        };
+      }
+      return await this.deleteColumn(tableId, findResult.data.id);
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  formatErrorResponse(error) {
+    if (this.config.debug) {
+      console.error("Columns API Error:", error);
+    }
+    if (error && typeof error === "object" && "response" in error) {
+      const apiError = error;
+      if (apiError.response?.data?.error) {
+        return apiError.response.data;
+      }
+      return {
+        error: {
+          code: "API_ERROR",
+          message: error.message || "Unknown API error",
+          meta: [`Status: ${apiError.response?.status || "unknown"}`]
+        }
+      };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error.message,
+          meta: ["Client-side error occurred"]
+        }
+      };
+    }
+    return {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: "An unexpected error occurred",
+        meta: ["Unknown error type"]
+      }
+    };
+  }
+}
+const TABLE_ENDPOINTS = {
+  list: {
+    path: "/tables/list",
+    method: "POST",
+    authenticated: true,
+    rateLimit: { requests: 200, window: 6e4 }
+  },
+  create: {
+    path: "/tables",
+    method: "POST",
+    authenticated: true
+  },
+  get: {
+    path: "/tables/{table_id}",
+    method: "GET",
+    authenticated: true,
+    rateLimit: { requests: 300, window: 6e4 }
+  },
+  update: {
+    path: "/tables/{table_id}",
+    method: "PATCH",
+    authenticated: true
+  },
+  delete: {
+    path: "/tables/{table_id}",
+    method: "DELETE",
+    authenticated: true
+  }
+};
+const buildEndpointPath = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  });
+  const unreplacedParams = path.match(/\{([^}]+)\}/g);
+  if (unreplacedParams) {
+    throw new Error(`Missing path parameters: ${unreplacedParams.join(", ")}`);
+  }
+  return path;
+};
+const FILTER_OPERATORS = {
+  // Relational operators
+  EQUALS: "=",
+  NOT_EQUALS: "!=",
+  GREATER_THAN: ">",
+  GREATER_THAN_EQUAL: ">=",
+  LESS_THAN: "<",
+  LESS_THAN_EQUAL: "<=",
+  // String operators
+  LIKE: "LIKE",
+  // contains (case-sensitive)
+  ILIKE: "ILIKE",
+  // contains (case-insensitive)
+  STARTS_WITH: "STARTS WITH",
+  // Array/Set operators
+  IN: "IN",
+  // is one of
+  NOT_IN: "NOT IN",
+  // is not one of
+  // Special operators
+  IS_EMPTY: "IS EMPTY",
+  IS_NULL: "IS NULL",
+  IS_NOT_NULL: "IS NOT NULL",
+  BETWEEN: "BETWEEN",
+  // Dropdown/Array specific operators
+  ARRAY_CONTAINS: "@>",
+  // is exactly for dropdown
+  ARRAY_NOT_CONTAINS: "NOT @>",
+  // is different from for dropdown
+  ANY: "ANY",
+  // contains (case-sensitive) for dropdown
+  IS_ONE_OF_ARRAY: "IS ONE OF",
+  // is one of for dropdown
+  DROPDOWN_ITEM_STARTS_WITH: "DROPDOWN ITEM STARTS WITH",
+  // Date operators
+  WITHIN: "WITHIN"
+  // date range operator
+};
+const OPERATOR_MAPPING = {
+  // Basic comparisons
+  $eq: FILTER_OPERATORS.EQUALS,
+  $ne: FILTER_OPERATORS.NOT_EQUALS,
+  $gt: FILTER_OPERATORS.GREATER_THAN,
+  $gte: FILTER_OPERATORS.GREATER_THAN_EQUAL,
+  $lt: FILTER_OPERATORS.LESS_THAN,
+  $lte: FILTER_OPERATORS.LESS_THAN_EQUAL,
+  // String operations
+  $like: FILTER_OPERATORS.LIKE,
+  $ilike: FILTER_OPERATORS.ILIKE,
+  $startsWith: FILTER_OPERATORS.STARTS_WITH,
+  // Array operations
+  $in: FILTER_OPERATORS.IN,
+  $notIn: FILTER_OPERATORS.NOT_IN,
+  // Special operations
+  $between: FILTER_OPERATORS.BETWEEN,
+  $isEmpty: FILTER_OPERATORS.IS_EMPTY,
+  $isNull: FILTER_OPERATORS.IS_NULL,
+  $isNotNull: FILTER_OPERATORS.IS_NOT_NULL,
+  // Array/dropdown operations
+  $arrayContains: FILTER_OPERATORS.ARRAY_CONTAINS,
+  $arrayNotContains: FILTER_OPERATORS.ARRAY_NOT_CONTAINS,
+  $any: FILTER_OPERATORS.ANY,
+  $isOneOfArray: FILTER_OPERATORS.IS_ONE_OF_ARRAY,
+  $dropdownItemStartsWith: FILTER_OPERATORS.DROPDOWN_ITEM_STARTS_WITH,
+  // Date operations
+  $within: FILTER_OPERATORS.WITHIN
+};
+function mapWhereToFilters(where) {
+  const filters = [];
+  Object.entries(where).forEach(([field, condition]) => {
+    if (typeof condition !== "object" || Array.isArray(condition) || condition === null) {
+      filters.push({
+        field,
+        operator: FILTER_OPERATORS.EQUALS,
+        values: [condition]
+      });
+      return;
+    }
+    Object.entries(condition).forEach(([operator, value]) => {
+      const apiOperator = OPERATOR_MAPPING[operator];
+      if (!apiOperator) {
+        throw new Error(`Unsupported operator: ${operator}`);
+      }
+      let values;
+      if (apiOperator === FILTER_OPERATORS.BETWEEN && Array.isArray(value) && value.length === 2) {
+        values = value;
+      } else if ((apiOperator === FILTER_OPERATORS.IN || apiOperator === FILTER_OPERATORS.NOT_IN || apiOperator === FILTER_OPERATORS.IS_ONE_OF_ARRAY) && Array.isArray(value)) {
+        values = value;
+      } else if (apiOperator === FILTER_OPERATORS.IS_NULL || apiOperator === FILTER_OPERATORS.IS_NOT_NULL || apiOperator === FILTER_OPERATORS.IS_EMPTY) {
+        values = [];
+      } else {
+        values = [value];
+      }
+      filters.push({
+        field,
+        operator: apiOperator,
+        values
+      });
+    });
+  });
+  return filters;
+}
+function transformTableCreateRequest(request, options = {}) {
+  return {
+    name: request.name,
+    description: request.description,
+    fields: request.fields.map(transformFieldDefinition),
+    is_ai_generated_schema: options.is_ai_generated_schema || false,
+    is_template: options.is_template || false
+  };
+}
+function transformFieldDefinition(field) {
+  return {
+    name: field.name,
+    type: field.type,
+    is_nullable: field.is_nullable ?? true,
+    is_primary_key: field.is_primary_key ?? false,
+    is_unique: field.is_unique ?? false,
+    is_indexed: field.is_indexed ?? false,
+    is_visible: field.is_visible ?? true,
+    is_readonly: field.is_readonly ?? false,
+    field_order: field.field_order ?? 1,
+    alignment: field.alignment ?? "left",
+    timezone: field.timezone ?? void 0,
+    date_format: field.date_format ?? void 0,
+    time_format: field.time_format ?? void 0,
+    decimals: field.decimals ?? void 0,
+    currency_format: field.currency_format ?? void 0,
+    selection_source: field.type === "dropdown" && !field.selection_source ? "provide-static-list" : field.selection_source ?? void 0,
+    selectable_items: field.selectable_items ?? void 0,
+    multiple_selections: field.multiple_selections ?? false,
+    phone_format: field.phone_format ?? void 0,
+    vector_dimension: field.vector_dimension ?? void 0,
+    description: field.description,
+    default_value: field.default_value
+  };
+}
+class TablesApiClient {
+  constructor(apiKey, config = {}) {
+    this.config = { apiKey, ...config };
+    this.httpAdapter = createHttpAdapter();
+    const environment = config.environment || "prod";
+    const region = config.region || "asia-south1";
+    this.baseURL = this.getBaseURL(environment, region);
+  }
+  getBaseURL(environment, region) {
+    const regionConfig = REGION_CONFIGS[region];
+    if (!regionConfig) {
+      throw new Error(`Unsupported region: ${region}`);
+    }
+    const envConfig = regionConfig[environment];
+    if (!envConfig) {
+      throw new Error(
+        `Unsupported environment: ${environment} for region: ${region}`
+      );
+    }
+    return `${envConfig.baseURL}/v1`;
+  }
+  /**
+   * Create a new table
+   */
+  async createTable(request, options = {}) {
+    try {
+      const endpoint = TABLE_ENDPOINTS.create;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const transformedRequest = transformTableCreateRequest(request, options);
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: transformedRequest,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * List tables with filtering and pagination
+   */
+  async listTables(options = {}) {
+    try {
+      const endpoint = TABLE_ENDPOINTS.list;
+      const url = `${this.baseURL}${endpoint.path}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: options,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (options.fields && responseData.data) {
+        responseData.data = filterArrayFields(
+          responseData.data,
+          options.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Get a specific table by ID
+   */
+  async getTable(tableId, options = {}) {
+    try {
+      const endpoint = TABLE_ENDPOINTS.get;
+      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (options.fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          options.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Update an existing table
+   */
+  async updateTable(tableId, updates) {
+    try {
+      const { fields, ...updateData } = updates;
+      const endpoint = TABLE_ENDPOINTS.update;
+      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: updateData,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Delete a table
+   */
+  async deleteTable(tableId) {
+    try {
+      const endpoint = TABLE_ENDPOINTS.delete;
+      const url = `${this.baseURL}${buildEndpointPath(endpoint, { table_id: tableId })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  // Private helper methods
+  buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  formatErrorResponse(error) {
+    if (this.config.debug) {
+      console.error("Tables API Error:", error);
+    }
+    if (error && typeof error === "object" && "response" in error) {
+      const apiError = error;
+      if (apiError.response?.data?.error) {
+        return apiError.response.data;
+      }
+      return {
+        error: {
+          code: "API_ERROR",
+          message: error.message || "Unknown API error",
+          meta: [`Status: ${apiError.response?.status || "unknown"}`]
+        }
+      };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error.message,
+          meta: ["Client-side error occurred"]
+        }
+      };
+    }
+    return {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: "An unexpected error occurred",
+        meta: ["Unknown error type"]
+      }
+    };
+  }
+}
+function isErrorResponse(response) {
+  return "error" in response && response.error !== void 0;
+}
+function isListResponse(response) {
+  return "pagination" in response;
+}
+class BaseResource {
+  constructor(client, basePath) {
+    this.client = client;
+    this.basePath = basePath;
+  }
+  // Public getter for basePath
+  getBasePath() {
+    return this.basePath;
+  }
+  async makeRequest(method, path, data, options) {
+    const url = `${this.basePath}${path}`;
+    try {
+      let response;
+      switch (method) {
+        case "GET":
+          response = await this.client.get(url, {
+            params: options?.params
+          });
+          break;
+        case "POST":
+          response = await this.client.post(url, data, {
+            params: options?.params
+          });
+          break;
+        case "PUT":
+          response = await this.client.put(url, data, {
+            params: options?.params
+          });
+          break;
+        case "PATCH":
+          response = await this.client.patch(url, data, {
+            params: options?.params
+          });
+          break;
+        case "DELETE":
+          response = await this.client.delete(url, {
+            params: options?.params
+          });
+          break;
+      }
+      return response.data;
+    } catch (error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: formatError(error),
+          meta: ["Request failed"]
+        }
+      };
+    }
+  }
+  buildQueryParams(options = {}) {
+    const params = {};
+    if (options.fields?.length) {
+      params.fields = options.fields.join(",");
+    }
+    if (options.sort?.length) {
+      params.sort = options.sort.map((s) => `${s.field}:${s.order}`).join(",");
+    }
+    if (options.limit !== void 0) {
+      params.limit = options.limit;
+    }
+    if (options.offset !== void 0) {
+      params.offset = options.offset;
+    }
+    if (options.where) {
+      Object.entries(options.where).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          params[`where[${key}]`] = typeof value === "object" ? JSON.stringify(value) : value;
+        }
+      });
+    }
+    return params;
+  }
+  handleResponse(response) {
+    if ("error" in response) {
+      if (this.client.getConfig().debug) {
+        console.error("API Error:", response.error);
+      }
+    }
+    return response;
+  }
+}
+class TableResource extends BaseResource {
+  constructor(client) {
+    super(client, "/v1/tables");
+    const config = client.getConfig();
+    this.tablesApiClient = new TablesApiClient(config.apiKey, {
+      environment: config.environment,
+      timeout: config.timeout,
+      debug: config.debug,
+      retryAttempts: config.retryAttempts,
+      retryDelay: config.retryDelay,
+      headers: config.headers
+    });
+  }
+  /**
+   * Create a new table
+   */
+  async create(data) {
+    try {
+      const processedData = { ...data };
+      if (data.fields && data.fields.length > 0) {
+        processedData.fields = await this.processFieldsDefaults(data.fields);
+      }
+      const result = await this.tablesApiClient.createTable(processedData);
+      if (isErrorResponse(result)) {
+        throw new ApiError(
+          result.error.message || "Create table failed",
+          400,
+          result.error
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Process fields with defaults for table creation
+   */
+  async processFieldsDefaults(fields) {
+    const processedFields = [];
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
+      const processedField = { ...field };
+      if (processedField.is_primary_key === void 0) {
+        processedField.is_primary_key = false;
+      }
+      if (processedField.is_unique === void 0) {
+        processedField.is_unique = false;
+      }
+      if (processedField.is_nullable === void 0) {
+        processedField.is_nullable = true;
+      }
+      if (processedField.is_indexed === void 0) {
+        processedField.is_indexed = false;
+      }
+      if (processedField.field_order === void 0) {
+        processedField.field_order = i + 1;
+      }
+      if (processedField.field_order <= 0 || processedField.field_order >= 2147483647) {
+        throw new Error(
+          "Field order must be a number greater than 0 and less than 2147483647"
+        );
+      }
+      processedFields.push(processedField);
+    }
+    return processedFields;
+  }
+  /**
+   * Transform SDK TableQueryOptions to API request format
+   */
+  transformTableQueryToApiRequest(options) {
+    const apiRequest = {
+      page: {
+        page_no: 1,
+        page_size: options.limit || 100
+      },
+      filters: [],
+      sort: []
+    };
+    if (options.offset && options.limit) {
+      const pageNo = Math.floor(options.offset / options.limit) + 1;
+      apiRequest.page.page_no = pageNo;
+    }
+    if (options.where) {
+      Object.entries(options.where).forEach(([field, value]) => {
+        if (value !== void 0 && value !== null) {
+          apiRequest.filters.push({
+            field,
+            operator: "=",
+            values: [value]
+          });
+        }
+      });
+    }
+    if (options.sort) {
+      apiRequest.sort = options.sort.map((s) => ({
+        field: s.field,
+        direction: s.order
+      }));
+    }
+    return apiRequest;
+  }
+  /**
+   * Find all tables with optional filtering
+   */
+  async findAll(options = {}) {
+    try {
+      const apiRequest = this.transformTableQueryToApiRequest(options);
+      const result = await this.tablesApiClient.listTables(
+        apiRequest
+      );
+      if (isErrorResponse(result)) {
+        throw new ApiError(
+          result.error.message || "List tables failed",
+          400,
+          result.error
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Find a single table by ID or name
+   */
+  async findOne(options) {
+    try {
+      if (!options.where?.id && !options.where?.name) {
+        throw new ValidationError(
+          "Either id or name must be provided in where clause"
+        );
+      }
+      if (options.where?.id) {
+        const result = await this.tablesApiClient.getTable(
+          options.where.id
+        );
+        if (isErrorResponse(result)) {
+          if (result.error.code === "TABLE_NOT_FOUND") {
+            return {
+              data: null,
+              message: "Table not found"
+            };
+          }
+          throw new ApiError(
+            result.error.message || "Get table failed",
+            400,
+            result.error
+          );
+        }
+        return result;
+      } else {
+        const apiRequest = {
+          page: { page_no: 1, page_size: 1 },
+          filters: [
+            {
+              field: "name",
+              operator: "=",
+              values: [options.where.name]
+            }
+          ],
+          sort: []
+        };
+        const listResult = await this.tablesApiClient.listTables(
+          apiRequest
+        );
+        if (isErrorResponse(listResult)) {
+          throw new ApiError(
+            listResult.error.message || "Find table by name failed",
+            400,
+            listResult.error
+          );
+        }
+        const table = isListResponse(listResult) ? listResult.data[0] : null;
+        return {
+          data: table || null,
+          message: table ? "Table found" : "Table not found"
+        };
+      }
+    } catch (error) {
+      throw error instanceof ApiError || error instanceof ValidationError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Find a single table by name
+   */
+  async findByName(name) {
+    return this.findOne({ where: { name } });
+  }
+  /**
+   * Find a single table by ID
+   */
+  async findById(id) {
+    return this.findOne({ where: { id } });
+  }
+  /**
+   * Update a table by name
+   */
+  async update(name, data) {
+    try {
+      const tableResult = await this.findByName(name);
+      if (!tableResult.data) {
+        throw new ApiError(`Table '${name}' not found`, 404);
+      }
+      if (tableResult.data.snapshot_url) {
+        throw new ApiError(
+          `Cannot update snapshot table '${name}'. Snapshots are read-only and cannot be modified.`,
+          400
+        );
+      }
+      const result = await this.tablesApiClient.updateTable(
+        tableResult.data.id,
+        data
+      );
+      if (isErrorResponse(result)) {
+        throw new ApiError(
+          result.error.message || "Update table failed",
+          400,
+          result.error
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Delete a table by name
+   */
+  async delete(name) {
+    try {
+      const tableResult = await this.findByName(name);
+      if (!tableResult.data) {
+        throw new ApiError(`Table '${name}' not found`, 404);
+      }
+      if (tableResult.data.snapshot_url) {
+        throw new ApiError(
+          `Cannot delete snapshot table '${name}'. Snapshots are read-only and cannot be deleted.`,
+          400
+        );
+      }
+      const result = await this.tablesApiClient.deleteTable(
+        tableResult.data.id
+      );
+      if (isErrorResponse(result)) {
+        throw new ApiError(
+          result.error.message || "Delete table failed",
+          400,
+          result.error
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Rename a table
+   */
+  async rename(oldName, newName) {
+    try {
+      const result = await this.update(oldName, {
+        name: newName
+      });
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  /**
+   * Set table access permissions
+   */
+  async setAccess(request) {
+    try {
+      const result = await this.update(request.table_name, {
+        is_shared: request.is_shared
+      });
+      return result;
+    } catch (error) {
+      throw error instanceof ApiError ? error : new ApiError(this.formatError(error), 500);
+    }
+  }
+  // Helper method to format generic errors
+  formatError(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "An unexpected error occurred";
+  }
+}
+class ColumnResource extends BaseResource {
+  constructor(client) {
+    super(client, "/v1/tables");
+    const config = client.getConfig();
+    this.columnsApiClient = new ColumnsApiClient(config.apiKey, {
+      environment: config.environment,
+      timeout: config.timeout,
+      debug: config.debug,
+      retryAttempts: config.retryAttempts,
+      retryDelay: config.retryDelay,
+      headers: config.headers
+    });
+    this.tablesApiClient = new TablesApiClient(config.apiKey, {
+      environment: config.environment,
+      timeout: config.timeout,
+      debug: config.debug,
+      retryAttempts: config.retryAttempts,
+      retryDelay: config.retryDelay,
+      headers: config.headers
+    });
+  }
+  /**
+   * Create a single column in a table
+   */
+  async create(tableName, column) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const processedColumn = await this.processColumnDefaults(
+        tableInfo.id,
+        column
+      );
+      const result = await this.columnsApiClient.createColumn(
+        tableInfo.id,
+        processedColumn
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "CREATE_COLUMN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Process column defaults and auto-generate field_order
+   */
+  async processColumnDefaults(tableId, column) {
+    const processedColumn = { ...column };
+    if (processedColumn.is_primary_key === void 0) {
+      processedColumn.is_primary_key = false;
+    }
+    if (processedColumn.is_unique === void 0) {
+      processedColumn.is_unique = false;
+    }
+    if (processedColumn.is_nullable === void 0) {
+      processedColumn.is_nullable = true;
+    }
+    if (processedColumn.is_indexed === void 0) {
+      processedColumn.is_indexed = false;
+    }
+    if (processedColumn.field_order === void 0) {
+      processedColumn.field_order = await this.generateFieldOrder(tableId);
+    }
+    if (processedColumn.field_order <= 0 || processedColumn.field_order >= 2147483647) {
+      throw new Error(
+        "Field order must be a number greater than 0 and less than 2147483647"
+      );
+    }
+    return processedColumn;
+  }
+  /**
+   * Generate the next available field_order for a table
+   */
+  async generateFieldOrder(tableId) {
+    try {
+      const existingColumns = await this.columnsApiClient.listColumns(tableId);
+      let maxOrder = 0;
+      if (!isErrorResponse(existingColumns) && existingColumns.data && Array.isArray(existingColumns.data)) {
+        for (const col of existingColumns.data) {
+          if (col.field_order && col.field_order > maxOrder) {
+            maxOrder = col.field_order;
+          }
+        }
+      }
+      return maxOrder + 1;
+    } catch (error) {
+      return Math.floor(Date.now() / 1e3) % 2147483647;
+    }
+  }
+  /**
+   * Transform SDK ColumnQueryOptions to API request format
+   */
+  transformColumnQueryToApiRequest(options) {
+    const apiRequest = {
+      page: {
+        page_no: 1,
+        page_size: options.limit || 100
+      },
+      filters: [],
+      sort: []
+    };
+    if (options.offset && options.limit) {
+      const pageNo = Math.floor(options.offset / options.limit) + 1;
+      apiRequest.page.page_no = pageNo;
+    }
+    if (options.where) {
+      Object.entries(options.where).forEach(([field, value]) => {
+        if (value !== void 0 && value !== null) {
+          apiRequest.filters.push({
+            field,
+            operator: "=",
+            values: [value]
+          });
+        }
+      });
+    }
+    if (options.sort) {
+      apiRequest.sort = options.sort.map((s) => ({
+        field: s.field,
+        direction: s.order
+      }));
+    }
+    return apiRequest;
+  }
+  /**
+   * Add multiple columns to existing table
+   */
+  async createMany(tableName, columns) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const processedColumns = [];
+      for (const column of columns) {
+        const processedColumn = await this.processColumnDefaults(
+          tableInfo.id,
+          column
+        );
+        processedColumns.push(processedColumn);
+      }
+      const result = await this.columnsApiClient.createColumns(tableInfo.id, {
+        columns: processedColumns
+      });
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "CREATE_COLUMNS_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Find all columns in a table (replaces list functionality)
+   */
+  async findAll(tableName, options = {}) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const apiRequest = this.transformColumnQueryToApiRequest(options);
+      const result = await this.columnsApiClient.listColumns(
+        tableInfo.id,
+        apiRequest
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "LIST_COLUMNS_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Get a single column by name
+   */
+  async get(tableName, columnName) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.columnsApiClient.findColumnByName(
+        tableInfo.id,
+        columnName
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      if (!result.data) {
+        return {
+          error: {
+            code: "COLUMN_NOT_FOUND",
+            message: `Column '${columnName}' not found in table '${tableName}'`
+          }
+        };
+      }
+      return {
+        data: result.data,
+        message: "Column found successfully"
+      };
+    } catch (error) {
+      return {
+        error: {
+          code: "GET_COLUMN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  async findById(tableName, columnId) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.columnsApiClient.getColumn(
+        tableInfo.id,
+        columnId
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "FIND_COLUMN_BY_ID_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Update a column by name
+   */
+  async update(tableName, columnName, updates) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.columnsApiClient.updateColumnByName(
+        tableInfo.id,
+        columnName,
+        updates
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "UPDATE_COLUMN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Delete a column by name
+   */
+  async delete(tableName, columnName) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.columnsApiClient.deleteColumnByName(
+        tableInfo.id,
+        columnName
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return {
+        data: {
+          success: true,
+          message: "Column deleted successfully"
+        }
+      };
+    } catch (error) {
+      return {
+        error: {
+          code: "DELETE_COLUMN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Helper method to get table information by name
+   */
+  async getTableInfo(tableName) {
+    try {
+      const tableResource = new TableResource(this.client);
+      const tableResult = await tableResource.findByName(tableName);
+      if (tableResult.data) {
+        return {
+          id: tableResult.data.id,
+          snapshot_url: tableResult.data.snapshot_url
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error("Error getting table info:", error);
+      return null;
+    }
+  }
+  /**
+   * Helper method to get table ID by name (deprecated, use getTableInfo instead)
+   */
+  async getTableId(tableName) {
+    const tableInfo = await this.getTableInfo(tableName);
+    return tableInfo?.id || null;
+  }
+}
+const RECORD_ENDPOINTS = {
+  insert: {
+    path: "/tables/{table_id}/records",
+    method: "POST",
+    authenticated: true
+  },
+  insertMany: {
+    path: "/tables/{table_id}/records/bulk-insert",
+    method: "POST",
+    authenticated: true
+  },
+  list: {
+    path: "/tables/{table_id}/records/list",
+    method: "POST",
+    authenticated: true,
+    rateLimit: { requests: 200, window: 6e4 }
+  },
+  get: {
+    path: "/tables/{table_id}/records/{record_id}",
+    method: "GET",
+    authenticated: true,
+    rateLimit: { requests: 200, window: 6e4 }
+  },
+  update: {
+    path: "/tables/{table_id}/records",
+    method: "PATCH",
+    authenticated: true
+  },
+  updateById: {
+    path: "/tables/{table_id}/records/{record_id}",
+    method: "PATCH",
+    authenticated: true
+  },
+  delete: {
+    path: "/tables/{table_id}/records/list",
+    method: "DELETE",
+    authenticated: true
+  }
+};
+const buildRecordEndpointPath = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  });
+  const unreplacedParams = path.match(/\{([^}]+)\}/g);
+  if (unreplacedParams) {
+    throw new Error(`Missing path parameters: ${unreplacedParams.join(", ")}`);
+  }
+  return path;
+};
+function transformDeleteRequest(sdkRequest) {
+  const result = {};
+  if (sdkRequest.record_ids && sdkRequest.record_ids.length > 0) {
+    result.record_ids = sdkRequest.record_ids;
+  }
+  if (sdkRequest.filters) {
+    if (Array.isArray(sdkRequest.filters)) {
+      if (sdkRequest.filters.length > 0 && typeof sdkRequest.filters[0] === "object" && "field" in sdkRequest.filters[0] && "operator" in sdkRequest.filters[0] && "values" in sdkRequest.filters[0]) {
+        result.filters = sdkRequest.filters;
+      } else {
+        console.warn(
+          "Legacy Record<string, unknown>[] filter format detected. Please migrate to the new filter format."
+        );
+        result.filters = sdkRequest.filters;
+      }
+    } else {
+      result.filters = mapWhereToFilters(sdkRequest.filters);
+    }
+  }
+  return result;
+}
+class RecordsApiClient {
+  constructor(apiKey, config = {}) {
+    this.config = { apiKey, ...config };
+    this.httpAdapter = createHttpAdapter();
+    const environment = config.environment || "prod";
+    const region = config.region || "asia-south1";
+    this.baseURL = this.getBaseURL(environment, region);
+  }
+  getBaseURL(environment, region) {
+    const regionConfig = REGION_CONFIGS[region];
+    if (!regionConfig) {
+      throw new Error(`Unsupported region: ${region}`);
+    }
+    const envConfig = regionConfig[environment];
+    if (!envConfig) {
+      throw new Error(
+        `Unsupported environment: ${environment} for region: ${region}`
+      );
+    }
+    return `${envConfig.baseURL}/v1`;
+  }
+  /**
+   * Insert a single record
+   */
+  async insertRecord(request) {
+    try {
+      const { table_id, fields, ...recordData } = request;
+      if (!table_id) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for insert operation")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.insert;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: recordData,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Insert multiple records in bulk
+   */
+  async insertManyRecords(records, tableId, options = { validation: true }) {
+    try {
+      if (!tableId) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for bulk insert operation")
+        );
+      }
+      if (!records || !Array.isArray(records) || records.length === 0) {
+        return this.formatErrorResponse(
+          new Error("records array is required and cannot be empty")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.insertMany;
+      let url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id: tableId })}`;
+      const queryParams = new URLSearchParams();
+      if (options.validation !== void 0) {
+        queryParams.append("validation", options.validation.toString());
+      }
+      if (queryParams.toString()) {
+        url += `?${queryParams.toString()}`;
+      }
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: records,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Get a single record by ID
+   */
+  async getRecord(recordId, tableId, options = {}) {
+    try {
+      if (!tableId) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for get operation")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.get;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
+        table_id: tableId,
+        record_id: recordId
+      })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (options.fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          options.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * List records with filtering and pagination
+   */
+  async listRecords(options = {}) {
+    try {
+      const { table_id, ...queryOptions } = options;
+      if (!table_id) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for list operation")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.list;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: queryOptions,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (queryOptions.fields && responseData.data) {
+        responseData.data = filterArrayFields(
+          responseData.data,
+          queryOptions.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Update records by filters
+   */
+  async updateRecords(request) {
+    try {
+      const { table_id, ...updateOptions } = request;
+      if (!table_id) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for update operation")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.update;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: updateOptions,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (updateOptions.fields && responseData.data) {
+        responseData.data = filterArrayFields(
+          responseData.data,
+          updateOptions.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Update a single record by ID
+   */
+  async updateRecordById(recordId, request) {
+    try {
+      const { table_id, ...updateOptions } = request;
+      if (!table_id) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for updateById operation")
+        );
+      }
+      const endpoint = RECORD_ENDPOINTS.updateById;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, {
+        record_id: recordId,
+        table_id
+      })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: updateOptions.set,
+        timeout: this.config.timeout
+      });
+      const responseData = response.data;
+      if (updateOptions.fields && responseData.data) {
+        responseData.data = filterObjectFields(
+          responseData.data,
+          updateOptions.fields
+        );
+      }
+      return responseData;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Unified delete records method that supports both record_ids and filters
+   */
+  async deleteRecords(request) {
+    try {
+      const { table_id } = request;
+      if (!table_id) {
+        return this.formatErrorResponse(
+          new Error("table_id is required for delete operation")
+        );
+      }
+      const transformedRequest = transformDeleteRequest(request);
+      const endpoint = RECORD_ENDPOINTS.delete;
+      const url = `${this.baseURL}${buildRecordEndpointPath(endpoint, { table_id })}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: transformedRequest,
+        timeout: this.config.timeout
+      });
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error);
+    }
+  }
+  /**
+   * Delete a single record by ID
+   */
+  async deleteRecordById(recordId, request) {
+    return this.deleteRecords({
+      record_ids: [recordId],
+      table_id: request.table_id
+    });
+  }
+  buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-boltic-token": this.config.apiKey
+    };
+  }
+  formatErrorResponse(error) {
+    if (this.config.debug) {
+      console.error("Records API Error:", error);
+    }
+    if (error && typeof error === "object" && "response" in error) {
+      const apiError = error;
+      if (apiError.response?.data?.error) {
+        return apiError.response.data;
+      }
+      return {
+        error: {
+          code: "API_ERROR",
+          message: error.message || "Unknown API error",
+          meta: [`Status: ${apiError.response?.status || "unknown"}`]
+        }
+      };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      return {
+        error: {
+          code: "CLIENT_ERROR",
+          message: error.message,
+          meta: ["Client-side error occurred"]
+        }
+      };
+    }
+    return {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: "An unexpected error occurred",
+        meta: ["Unknown error type"]
+      }
+    };
+  }
+}
+class RecordResource {
+  constructor(client) {
+    this.client = client;
+    this.apiClient = new RecordsApiClient(client.getConfig().apiKey, {
+      environment: client.getConfig().environment,
+      timeout: client.getConfig().timeout,
+      debug: client.getConfig().debug
+    });
+    this.tablesApiClient = new TablesApiClient(client.getConfig().apiKey, {
+      environment: client.getConfig().environment,
+      timeout: client.getConfig().timeout,
+      debug: client.getConfig().debug
+    });
+  }
+  /**
+   * Insert a single record
+   */
+  async insert(tableName, data) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const completeDataResult = await this.ensureCompleteRecordData(
+        tableName,
+        data
+      );
+      if ("error" in completeDataResult && completeDataResult.error) {
+        return completeDataResult;
+      }
+      const requestData = {
+        ...completeDataResult,
+        table_id: tableInfo.id
+      };
+      const result = await this.apiClient.insertRecord(requestData);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "INSERT_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Insert multiple records in bulk
+   */
+  async insertMany(tableName, records, options = { validation: true }) {
+    try {
+      if (!records || !Array.isArray(records) || records.length === 0) {
+        return {
+          error: {
+            code: "INVALID_INPUT",
+            message: "Records array is required and cannot be empty"
+          }
+        };
+      }
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.apiClient.insertManyRecords(
+        records,
+        tableInfo.id,
+        options
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "INSERT_MANY_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Get a single record by ID
+   */
+  async get(tableName, recordId) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.apiClient.getRecord(recordId, tableInfo.id);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "GET_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * List records with filtering and pagination
+   */
+  async list(tableName, options = {}) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const requestOptions = { ...options, table_id: tableInfo.id };
+      const result = await this.apiClient.listRecords(requestOptions);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "LIST_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Update records by filters
+   */
+  async update(tableName, options) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const requestOptions = { ...options, table_id: tableInfo.id };
+      const result = await this.apiClient.updateRecords(requestOptions);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "UPDATE_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Update a single record by ID
+   */
+  async updateById(tableName, recordId, data) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const requestOptions = {
+        id: recordId,
+        set: data,
+        table_id: tableInfo.id
+      };
+      const result = await this.apiClient.updateRecordById(
+        recordId,
+        requestOptions
+      );
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "UPDATE_BY_ID_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Unified delete method that supports both record IDs and filters
+   */
+  async delete(tableName, options) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const requestOptions = { ...options, table_id: tableInfo.id };
+      const result = await this.apiClient.deleteRecords(requestOptions);
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "DELETE_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Delete a single record by ID
+   */
+  async deleteById(tableName, recordId) {
+    try {
+      const tableInfo = await this.getTableInfo(tableName);
+      if (!tableInfo) {
+        return {
+          error: {
+            code: "TABLE_NOT_FOUND",
+            message: `Table '${tableName}' not found`
+          }
+        };
+      }
+      const result = await this.apiClient.deleteRecordById(recordId, {
+        table_id: tableInfo.id
+      });
+      if (isErrorResponse(result)) {
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        error: {
+          code: "DELETE_BY_ID_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+  /**
+   * Helper method to get table information by name
+   */
+  async getTableInfo(tableName) {
+    try {
+      const tableResource = new TableResource(this.client);
+      const tableResult = await tableResource.findByName(tableName);
+      if (tableResult.data) {
+        return {
+          id: tableResult.data.id,
+          snapshot_url: tableResult.data.snapshot_url
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error("Error getting table info:", error);
+      return null;
+    }
+  }
+  /**
+   * Helper method to ensure all required fields for a record are present,
+   * filling missing ones with null.
+   */
+  async ensureCompleteRecordData(tableName, data) {
+    try {
+      const columnResource = new ColumnResource(this.client);
+      const columnsResult = await columnResource.findAll(tableName);
+      if (isErrorResponse(columnsResult)) {
+        return columnsResult;
+      }
+      const columns = Array.isArray(columnsResult.data) ? columnsResult.data : [];
+      const completeData = { ...data };
+      for (const column of columns) {
+        if (column.name === "id" || column.name === "created_at" || column.name === "updated_at") {
+          continue;
+        }
+        if (!(column.name in data)) {
+          completeData[column.name] = null;
+        }
+      }
+      return completeData;
+    } catch (error) {
+      return {
+        error: {
+          code: "COMPLETE_DATA_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error occurred"
+        }
+      };
+    }
+  }
+}
+class RecordBuilder {
+  constructor(options) {
+    this.queryOptions = {};
+    this.updateData = {};
+    this.tableName = options.tableName;
+    this.recordResource = options.recordResource;
+  }
+  /**
+   * Add filter conditions
+   */
+  where(conditions) {
+    if (!this.queryOptions.filters) {
+      this.queryOptions.filters = [];
+    }
+    Object.entries(conditions).forEach(([field, value]) => {
+      this.queryOptions.filters.push({
+        field,
+        operator: "equals",
+        values: [value]
+      });
+    });
+    return this;
+  }
+  /**
+   * Set sorting
+   */
+  orderBy(field, direction = "asc") {
+    if (!this.queryOptions.sort) {
+      this.queryOptions.sort = [];
+    }
+    this.queryOptions.sort.push({ field, order: direction });
+    return this;
+  }
+  /**
+   * Set limit (using page)
+   */
+  limit(count) {
+    if (!this.queryOptions.page) {
+      this.queryOptions.page = { page_no: 1, page_size: count };
+    } else {
+      this.queryOptions.page.page_size = count;
+    }
+    return this;
+  }
+  /**
+   * Set offset (using page)
+   */
+  offset(count) {
+    if (!this.queryOptions.page) {
+      this.queryOptions.page = {
+        page_no: Math.floor(count / 50) + 1,
+        page_size: 50
+      };
+    } else {
+      const pageSize = this.queryOptions.page.page_size || 50;
+      this.queryOptions.page.page_no = Math.floor(count / pageSize) + 1;
+    }
+    return this;
+  }
+  /**
+   * Set fields to select
+   */
+  select(fields) {
+    this.queryOptions.fields = fields;
+    return this;
+  }
+  /**
+   * Set data for update operations
+   */
+  set(data) {
+    this.updateData = { ...this.updateData, ...data };
+    return this;
+  }
+  /**
+   * Set pagination
+   */
+  page(pageNo, pageSize = 50) {
+    this.queryOptions.page = {
+      page_no: pageNo,
+      page_size: pageSize
+    };
+    return this;
+  }
+  /**
+   * Execute list operation (was findAll)
+   */
+  async list() {
+    return this.recordResource.list(this.tableName, this.queryOptions);
+  }
+  /**
+   * Execute findAll operation (alias for list)
+   */
+  async findAll() {
+    return this.recordResource.list(this.tableName, this.queryOptions);
+  }
+  /**
+   * Execute findOne operation by getting first result from list
+   */
+  async findOne() {
+    const queryOptions = { ...this.queryOptions, limit: 1 };
+    const result = await this.recordResource.list(this.tableName, queryOptions);
+    if ("error" in result) {
+      return result;
+    }
+    const record = result.data.length > 0 ? result.data[0] : null;
+    return {
+      data: record,
+      message: record ? "Record found" : "No record found"
+    };
+  }
+  /**
+   * Build where conditions from filters for API consumption
+   */
+  buildWhereConditions() {
+    const where = {};
+    if (this.queryOptions.filters) {
+      this.queryOptions.filters.forEach((filter) => {
+        if ("field" in filter && "values" in filter) {
+          const apiFilter = filter;
+          const fieldName = String(apiFilter.field);
+          if (apiFilter.operator === "equals") {
+            where[fieldName] = apiFilter.values[0];
+          } else if (apiFilter.operator === "contains") {
+            where[fieldName] = { $like: `%${String(apiFilter.values[0])}%` };
+          } else {
+            where[fieldName] = apiFilter.values[0];
+          }
+        } else {
+          Object.assign(where, filter);
+        }
+      });
+    }
+    return where;
+  }
+  /**
+   * Execute update operation - requires filters or record IDs
+   */
+  async update() {
+    if (!this.updateData) {
+      return {
+        error: {
+          code: "MISSING_UPDATE_DATA",
+          message: "Update data is required for update operation"
+        }
+      };
+    }
+    const updateOptions = {
+      set: this.updateData,
+      filters: this.queryOptions.filters || []
+    };
+    return this.recordResource.update(this.tableName, updateOptions);
+  }
+  /**
+   * Execute update by ID operation
+   */
+  async updateById(id) {
+    return this.recordResource.updateById(this.tableName, id, this.updateData);
+  }
+  /**
+   * Execute delete by single ID operation
+   */
+  async deleteById(id) {
+    return this.recordResource.deleteById(this.tableName, id);
+  }
+  /**
+   * Execute delete by IDs operation
+   */
+  async deleteByIds(ids) {
+    return this.recordResource.delete(this.tableName, { record_ids: ids });
+  }
+  /**
+   * Execute delete operation using filters
+   */
+  async delete() {
+    if (!this.queryOptions.filters || this.queryOptions.filters.length === 0) {
+      return {
+        error: {
+          code: "MISSING_DELETE_CONDITIONS",
+          message: "Filter conditions are required for delete operation. Use where() to specify conditions."
+        }
+      };
+    }
+    const deleteOptions = {
+      filters: this.buildWhereConditions()
+    };
+    return this.recordResource.delete(this.tableName, deleteOptions);
+  }
+  /**
+   * Get the built query options (for debugging)
+   */
+  getQueryOptions() {
+    return { ...this.queryOptions };
+  }
+  /**
+   * Get the update data (for debugging)
+   */
+  getUpdateData() {
+    return { ...this.updateData };
+  }
+  /**
+   * Execute insert operation
+   */
+  async insert(data) {
+    return this.recordResource.insert(this.tableName, data);
+  }
+}
+function createRecordBuilder(options) {
+  return new RecordBuilder(options);
+}
+const SQL_ENDPOINTS = {
+  textToSQL: {
+    path: "/tables/query/text-to-sql",
+    method: "POST",
+    authenticated: true,
+    rateLimit: { requests: 100, window: 6e4 }
+    // Limited due to AI processing
+  },
+  executeSQL: {
+    path: "/tables/query/execute",
+    method: "POST",
+    authenticated: true,
+    rateLimit: { requests: 200, window: 6e4 }
+  }
+};
+const buildSqlEndpointPath = (endpoint, params = {}) => {
+  let path = endpoint.path;
+  Object.entries(params).forEach(([key, value]) => {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  });
+  return path;
+};
+class BaseApiClient {
+  constructor(apiKey, config = {}) {
+    this.config = { apiKey, ...config };
+    this.httpAdapter = createHttpAdapter();
+    const environment = config.environment || "prod";
+    const region = config.region || "asia-south1";
+    this.baseURL = this.getBaseURL(environment, region);
+  }
+  getBaseURL(environment, region) {
+    const regionConfig = REGION_CONFIGS[region];
+    if (!regionConfig) {
+      throw new Error(`Unsupported region: ${region}`);
+    }
+    const envConfig = regionConfig[environment];
+    if (!envConfig) {
+      throw new Error(
+        `Unsupported environment: ${environment} for region: ${region}`
+      );
+    }
+    return `${envConfig.baseURL}/v1`;
+  }
+  buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-boltic-token": this.config.apiKey,
+      ...this.config.headers
+    };
+  }
+  formatErrorResponse(error, prefix = "API") {
+    if (this.config.debug) {
+      console.error(`${prefix} Error:`, error);
+    }
+    if (error && typeof error === "object" && "response" in error) {
+      const apiError = error;
+      if (apiError.response?.data?.error) {
+        return apiError.response.data;
+      }
+      return {
+        error: {
+          code: `${prefix}_ERROR`,
+          message: error.message || `Unknown ${prefix} error`,
+          meta: [`Status: ${apiError.response?.status || "unknown"}`]
+        }
+      };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+      return {
+        error: {
+          code: `${prefix}_CLIENT_ERROR`,
+          message: error.message,
+          meta: [`${prefix} client-side error occurred`]
+        }
+      };
+    }
+    return {
+      error: {
+        code: `${prefix}_UNKNOWN_ERROR`,
+        message: `An unexpected ${prefix} error occurred`,
+        meta: [`Unknown ${prefix} error type`]
+      }
+    };
+  }
+  // Security methods to prevent API key exposure
+  toString() {
+    return `${this.constructor.name} { environment: "${this.config.environment || "prod"}", debug: ${this.config.debug || false} }`;
+  }
+  toJSON() {
+    const safeConfig = { ...this.config };
+    delete safeConfig.apiKey;
+    return {
+      client: this.constructor.name,
+      config: safeConfig
+    };
+  }
+  // Custom inspect method for Node.js console logging
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+class SqlApiClient extends BaseApiClient {
+  constructor(apiKey, config = {}) {
+    super(apiKey, config);
+  }
+  /**
+   * Convert natural language to SQL query (streaming)
+   */
+  async textToSQL(request) {
+    try {
+      const endpoint = SQL_ENDPOINTS.textToSQL;
+      const url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: request,
+        timeout: this.config.timeout
+      });
+      if (response.status >= 400) {
+        return this.formatErrorResponse(
+          {
+            response: { data: response.data, status: response.status }
+          },
+          "SQL"
+        );
+      }
+      const sqlResponse = response.data;
+      return this.createAsyncIterable(sqlResponse.data);
+    } catch (error) {
+      return this.formatErrorResponse(error, "SQL");
+    }
+  }
+  /**
+   * Execute SQL query
+   */
+  async executeSQL(request) {
+    try {
+      const endpoint = SQL_ENDPOINTS.executeSQL;
+      const url = `${this.baseURL}${buildSqlEndpointPath(endpoint)}`;
+      const response = await this.httpAdapter.request({
+        url,
+        method: endpoint.method,
+        headers: this.buildHeaders(),
+        data: request,
+        timeout: this.config.timeout
+      });
+      if (response.status >= 400) {
+        return this.formatErrorResponse(
+          {
+            response: { data: response.data, status: response.status }
+          },
+          "SQL"
+        );
+      }
+      return response.data;
+    } catch (error) {
+      return this.formatErrorResponse(error, "SQL");
+    }
+  }
+  /**
+   * Helper method to create AsyncIterable from string data
+   * TODO: Replace with proper streaming implementation when backend supports it
+   */
+  async *createAsyncIterable(data) {
+    yield data;
+  }
+}
+function transformTextToSQLRequest(prompt, options = {}) {
+  return {
+    prompt,
+    current_query: options.currentQuery
+  };
+}
+class SqlResource {
+  constructor(client) {
+    const config = client.getConfig();
+    this.sqlApiClient = new SqlApiClient(config.apiKey, {
+      environment: config.environment,
+      region: config.region,
+      timeout: config.timeout,
+      debug: config.debug,
+      retryAttempts: config.retryAttempts,
+      retryDelay: config.retryDelay,
+      headers: config.headers
+    });
+  }
+  /**
+   * Convert natural language to SQL query
+   * Returns streaming results for real-time query generation
+   *
+   * @param prompt - Natural language description of the desired query
+   * @param options - Optional parameters including currentQuery for refinement
+   * @returns AsyncIterable<string> for streaming SQL generation
+   *
+   */
+  async textToSQL(prompt, options = {}) {
+    const request = transformTextToSQLRequest(prompt, options);
+    const response = await this.sqlApiClient.textToSQL(request);
+    if ("error" in response && response.error !== void 0) {
+      throw response;
+    }
+    return response;
+  }
+  /**
+   * Execute SQL query with built-in safety measures and performance optimization
+   *
+   * @param query - SQL query string to execute
+   * @returns Promise<ExecuteSQLApiResponse> with raw API response following Boltic API Response Structure
+   *
+   */
+  async executeSQL(query) {
+    const response = await this.sqlApiClient.executeSQL({ query });
+    if (isErrorResponse(response)) {
+      return response;
+    }
+    return response;
+  }
+}
+class TableBuilder {
+  constructor(options, tablesApiClient) {
+    this.isPublic = false;
+    this.fields = [];
+    this.tableName = options.name;
+    this.description = options.description;
+    this.tablesApiClient = tablesApiClient;
+  }
+  /**
+   * Set table name
+   */
+  name(name) {
+    this.tableName = name;
+    return this;
+  }
+  /**
+   * Set table description
+   */
+  describe(description) {
+    this.description = description;
+    return this;
+  }
+  /**
+   * Set if table is public
+   */
+  public(isPublic = true) {
+    this.isPublic = isPublic;
+    return this;
+  }
+  /**
+   * Add a text field
+   */
+  text(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "text",
+      is_nullable: options.nullable ?? true,
+      is_unique: options.unique ?? false,
+      is_indexed: options.indexed ?? false,
+      is_primary_key: false,
+      default_value: options.defaultValue,
+      description: options.description,
+      alignment: options.alignment || "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a long text field
+   */
+  longText(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "long-text",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      alignment: options.alignment || "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a number field
+   */
+  number(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "number",
+      is_nullable: options.nullable ?? true,
+      is_unique: options.unique ?? false,
+      is_indexed: options.indexed ?? false,
+      is_primary_key: false,
+      default_value: options.defaultValue,
+      description: options.description,
+      decimals: options.decimals,
+      alignment: options.alignment || "right",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a currency field
+   */
+  currency(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "currency",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      default_value: options.defaultValue,
+      description: options.description,
+      currency_format: options.currencyFormat,
+      decimals: options.decimals,
+      alignment: "right",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a checkbox field
+   */
+  checkbox(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "checkbox",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      default_value: options.defaultValue,
+      description: options.description,
+      alignment: "center",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a dropdown field
+   */
+  dropdown(name, items, options = {}) {
+    this.fields.push({
+      name,
+      type: "dropdown",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      default_value: options.defaultValue,
+      description: options.description,
+      selection_source: "provide-static-list",
+      selectable_items: items,
+      multiple_selections: options.multiple ?? false,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add an email field
+   */
+  email(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "email",
+      is_nullable: options.nullable ?? true,
+      is_unique: options.unique ?? false,
+      is_indexed: options.indexed ?? false,
+      is_primary_key: false,
+      description: options.description,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a phone number field
+   */
+  phone(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "phone-number",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      phone_format: options.format,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a link field
+   */
+  link(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "link",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a JSON field
+   */
+  json(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "json",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a date-time field
+   */
+  dateTime(name, options = {}) {
+    this.fields.push({
+      name,
+      type: "date-time",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      date_format: options.dateFormat,
+      time_format: options.timeFormat,
+      timezone: options.timezone,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a vector field
+   */
+  vector(name, dimension, options = {}) {
+    this.fields.push({
+      name,
+      type: "vector",
+      is_nullable: options.nullable ?? true,
+      is_unique: false,
+      is_indexed: false,
+      is_primary_key: false,
+      description: options.description,
+      vector_dimension: dimension,
+      alignment: "left",
+      field_order: this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Add a custom field
+   */
+  addField(field) {
+    this.fields.push({
+      ...field,
+      field_order: field.field_order || this.fields.length + 1
+    });
+    return this;
+  }
+  /**
+   * Remove a field by name
+   */
+  removeField(name) {
+    this.fields = this.fields.filter((field) => field.name !== name);
+    this.fields.forEach((field, index) => {
+      field.field_order = index + 1;
+    });
+    return this;
+  }
+  /**
+   * Get current fields
+   */
+  getFields() {
+    return [...this.fields];
+  }
+  /**
+   * Get current table name
+   */
+  getName() {
+    return this.tableName;
+  }
+  /**
+   * Get current description
+   */
+  getDescription() {
+    return this.description;
+  }
+  /**
+   * Build the table request object
+   */
+  build() {
+    if (!this.tableName) {
+      throw new ValidationError("Table name is required", [
+        { field: "name", message: "Table name cannot be empty" }
+      ]);
+    }
+    if (this.fields.length === 0) {
+      throw new ValidationError("At least one field is required", [
+        { field: "fields", message: "Table must have at least one field" }
+      ]);
+    }
+    return {
+      name: this.tableName,
+      description: this.description,
+      fields: this.fields
+    };
+  }
+  /**
+   * Build and create the table (requires API client)
+   */
+  async create(options = {}) {
+    if (!this.tablesApiClient) {
+      throw new Error("TablesApiClient is required for table creation");
+    }
+    const request = this.build();
+    return this.tablesApiClient.createTable(request, options);
+  }
+}
+function createTableBuilder(options, tablesApiClient) {
+  return new TableBuilder(options, tablesApiClient);
+}
+class BolticClient {
+  constructor(apiKey, options = {}) {
+    this.currentDatabase = null;
+    this.clientOptions = options;
+    this.configManager = new ConfigManager(
+      apiKey,
+      options.environment || "prod",
+      options.region || "asia-south1",
+      options
+    );
+    const config = this.configManager.getConfig();
+    this.authManager = new AuthManager2({
+      apiKey: config.apiKey,
+      maxRetries: config.maxRetries
+    });
+    this.baseClient = new BaseClient(config, this.authManager);
+    this.tableResource = new TableResource(this.baseClient);
+    this.columnResource = new ColumnResource(this.baseClient);
+    this.recordResource = new RecordResource(this.baseClient);
+    this.sqlResource = new SqlResource(this.baseClient);
+    this.currentDatabase = {
+      databaseName: "Default"
+    };
+  }
+  getCurrentDatabase() {
+    return this.currentDatabase;
+  }
+  // Direct table operations
+  get tables() {
+    return {
+      create: (data) => this.tableResource.create(data),
+      findAll: (options) => this.tableResource.findAll(options),
+      findById: (id) => this.tableResource.findById(id),
+      findByName: (name) => this.tableResource.findByName(name),
+      findOne: (options) => this.tableResource.findOne(options),
+      update: (name, data) => this.tableResource.update(name, data),
+      delete: (name) => this.tableResource.delete(name),
+      rename: (oldName, newName) => this.tableResource.rename(oldName, newName),
+      setAccess: (request) => this.tableResource.setAccess(request)
+    };
+  }
+  // Direct column operations
+  get columns() {
+    return {
+      create: (tableName, column) => this.columnResource.create(tableName, column),
+      createMany: (tableName, columns) => this.columnResource.createMany(tableName, columns),
+      findAll: (tableName, options) => this.columnResource.findAll(tableName, options),
+      findOne: (tableName, columnName) => this.columnResource.get(tableName, columnName),
+      findById: (tableName, columnId) => this.columnResource.findById(tableName, columnId),
+      update: (tableName, columnName, updates) => this.columnResource.update(tableName, columnName, updates),
+      delete: (tableName, columnName) => this.columnResource.delete(tableName, columnName)
+    };
+  }
+  // Fluent table operations
+  table(name) {
+    const tableBuilder = createTableBuilder({ name });
+    return tableBuilder;
+  }
+  // Method 3: Table-scoped operations
+  from(tableName) {
+    return {
+      // Column operations for this table
+      columns: () => ({
+        create: (column) => this.columnResource.create(tableName, column),
+        findAll: (options) => this.columnResource.findAll(tableName, options),
+        get: (columnName) => this.columnResource.get(tableName, columnName),
+        update: (columnName, updates) => this.columnResource.update(tableName, columnName, updates),
+        delete: (columnName) => this.columnResource.delete(tableName, columnName)
+      }),
+      // Record operations for this table
+      records: () => ({
+        insert: (data) => this.recordResource.insert(tableName, data),
+        insertMany: (records, options) => this.recordResource.insertMany(tableName, records, options),
+        findOne: (recordId) => this.recordResource.get(tableName, recordId),
+        update: (options) => this.recordResource.update(tableName, options),
+        updateById: (recordId, data) => this.recordResource.updateById(tableName, recordId, data),
+        // Unified delete method
+        delete: (options) => this.recordResource.delete(tableName, options),
+        // Single record delete method
+        deleteById: (recordId) => this.recordResource.deleteById(tableName, recordId)
+      }),
+      // Fluent record builder for this table
+      record: () => createRecordBuilder({
+        tableName,
+        recordResource: this.recordResource
+      })
+    };
+  }
+  // Direct record operations
+  get records() {
+    return {
+      insert: (tableName, data) => this.recordResource.insert(tableName, data),
+      insertMany: (tableName, records, options) => this.recordResource.insertMany(tableName, records, options),
+      findAll: (tableName, options) => this.recordResource.list(tableName, options),
+      findOne: (tableName, recordId) => this.recordResource.get(tableName, recordId),
+      update: (tableName, options) => this.recordResource.update(tableName, options),
+      updateById: (tableName, recordId, data) => this.recordResource.updateById(tableName, recordId, data),
+      delete: (tableName, options) => this.recordResource.delete(tableName, options),
+      deleteById: (tableName, recordId) => this.recordResource.deleteById(tableName, recordId)
+    };
+  }
+  // Method 4: Create fluent record builder
+  record(tableName) {
+    return createRecordBuilder({
+      tableName,
+      recordResource: this.recordResource
+    });
+  }
+  // Direct SQL operations
+  get sql() {
+    return {
+      textToSQL: (prompt, options) => this.sqlResource.textToSQL(prompt, options),
+      executeSQL: (query) => this.sqlResource.executeSQL(query)
+    };
+  }
+  // SQL resource access for testing
+  getSqlResource() {
+    return this.sqlResource;
+  }
+  // Configuration management
+  updateApiKey(newApiKey) {
+    this.configManager.updateConfig({ apiKey: newApiKey });
+    this.authManager.updateApiKey(newApiKey);
+  }
+  updateConfig(updates) {
+    this.configManager.updateConfig(updates);
+    this.baseClient.updateConfig(this.configManager.getConfig());
+    this.updateAllResourcesConfig();
+  }
+  getConfig() {
+    return this.configManager.getConfig();
+  }
+  // Authentication management
+  async validateApiKey() {
+    return this.authManager.validateApiKeyAsync();
+  }
+  isAuthenticated() {
+    return this.authManager.isAuthenticated();
+  }
+  // HTTP client access
+  getHttpClient() {
+    return this.baseClient;
+  }
+  // Interceptor management
+  addRequestInterceptor(interceptor) {
+    return this.baseClient.getInterceptors().request.use(interceptor);
+  }
+  addResponseInterceptor(onFulfilled, onRejected) {
+    return this.baseClient.getInterceptors().response.use(onFulfilled, onRejected);
+  }
+  ejectRequestInterceptor(id) {
+    this.baseClient.getInterceptors().request.eject(id);
+  }
+  ejectResponseInterceptor(id) {
+    this.baseClient.getInterceptors().response.eject(id);
+  }
+  // Connection testing
+  async testConnection() {
+    try {
+      return await this.authManager.validateApiKeyAsync();
+    } catch (error) {
+      return false;
+    }
+  }
+  // Get client version
+  getVersion() {
+    return "1.0.0";
+  }
+  // Environment helpers
+  getEnvironment() {
+    return this.configManager.getConfig().environment;
+  }
+  getRegion() {
+    return this.configManager.getConfig().region;
+  }
+  // Debug helpers
+  enableDebug() {
+    this.configManager.updateConfig({ debug: true });
+    this.baseClient.updateConfig(this.configManager.getConfig());
+    this.updateAllResourcesConfig();
+  }
+  disableDebug() {
+    this.configManager.updateConfig({ debug: false });
+    this.baseClient.updateConfig(this.configManager.getConfig());
+    this.updateAllResourcesConfig();
+  }
+  isDebugEnabled() {
+    return this.configManager.getConfig().debug || false;
+  }
+  // Private method to update all resource configurations
+  updateAllResourcesConfig() {
+    this.tableResource = new TableResource(this.baseClient);
+    this.columnResource = new ColumnResource(this.baseClient);
+    this.recordResource = new RecordResource(this.baseClient);
+    this.sqlResource = new SqlResource(this.baseClient);
+  }
+  // Security methods to prevent API key exposure
+  toString() {
+    const config = this.getConfig();
+    return `BolticClient { environment: "${config.environment}", region: "${config.region}", debug: ${config.debug} }`;
+  }
+  toJSON() {
+    const config = this.getConfig();
+    return {
+      environment: config.environment,
+      region: config.region,
+      debug: config.debug,
+      timeout: config.timeout,
+      version: this.getVersion()
+    };
+  }
+  // Custom inspect method for Node.js console logging
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+function createClient(apiKey, options = {}) {
+  return new BolticClient(apiKey, options);
+}
+const VERSION = "1.0.0";
+exports.AuthManager = AuthManager$1;
+exports.BolticClient = BolticClient;
+exports.VERSION = VERSION;
+exports.createClient = createClient;
+exports.createErrorWithContext = createErrorWithContext$1;
+exports.formatError = formatError$1;
+exports.getHttpStatusCode = getHttpStatusCode$1;
+exports.isErrorResponse = isErrorResponse;
+exports.isListResponse = isListResponse;
+exports.isNetworkError = isNetworkError;
+//# sourceMappingURL=sdk.js.map