@xylex-group/athena 1.9.0 → 2.1.2

package/dist/index.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var pg = require('pg');
 var fs = require('fs');
 var path = require('path');
 var url = require('url');
@@ -503,1264 +502,2411 @@ function identifier(...segments) {
   return new SqlIdentifierPath(expandedSegments);
 }
 
-// src/client.ts
-var DEFAULT_COLUMNS = "*";
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
-function formatResult(response) {
-  const result = {
-    data: response.data ?? null,
-    error: response.error ?? null,
-    errorDetails: response.errorDetails ?? null,
-    status: response.status,
-    raw: response.raw
-  };
-  if (response.count !== void 0) {
-    result.count = response.count;
-  }
-  return result;
+// src/auth/client.ts
+var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
+var FALLBACK_SDK_VERSION2 = "1.0.0";
+var SDK_NAME2 = "xylex-group/athena-auth";
+var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
+var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
-function toSingleResult(response) {
-  const payload = response.data;
-  const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
-  return {
-    ...response,
-    data: singleData
-  };
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function mergeOptions(...options) {
-  return options.reduce((acc, next) => {
-    if (!next) return acc;
-    return { ...acc, ...next };
-  }, void 0);
+function normalizeHeaderValue2(value) {
+  return value ? value : void 0;
 }
-function asAthenaJsonObject(value) {
-  return value;
+function parseResponseBody2(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
 }
-function asAthenaJsonObjectArray(values) {
-  return values;
+function resolveRequestId2(headers) {
+  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
 }
-function createMutationQuery(executor, defaultColumns = DEFAULT_COLUMNS) {
-  let selectedColumns = defaultColumns === null ? void 0 : defaultColumns;
-  let selectedOptions;
-  let promise = null;
-  const run = (columns, options) => {
-    const payloadColumns = columns ?? selectedColumns;
-    const payloadOptions = options ?? selectedOptions;
-    if (!promise) {
-      promise = executor(payloadColumns, payloadOptions);
+function resolveErrorMessage2(payload, fallback) {
+  if (isRecord2(payload)) {
+    const messageCandidates = [payload.error, payload.message, payload.details];
+    for (const candidate of messageCandidates) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
     }
-    return promise;
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function toErrorDetails(input) {
+  return {
+    code: input.code,
+    message: input.message,
+    status: input.status,
+    endpoint: input.endpoint,
+    method: input.method,
+    requestId: input.requestId,
+    hint: input.hint,
+    cause: input.cause
   };
-  const mutationQuery = {
-    select(columns = selectedColumns, options) {
-      selectedColumns = columns;
-      selectedOptions = options ?? selectedOptions;
-      return run(columns, options);
-    },
-    returning(columns = selectedColumns, options) {
-      return mutationQuery.select(columns, options);
-    },
-    single(columns = selectedColumns, options) {
-      selectedColumns = columns;
-      selectedOptions = options ?? selectedOptions;
-      return run(columns, options).then(toSingleResult);
-    },
-    maybeSingle(columns = selectedColumns, options) {
-      return mutationQuery.single(columns, options);
-    },
-    then(onfulfilled, onrejected) {
-      return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
-    },
-    catch(onrejected) {
-      return run(selectedColumns, selectedOptions).catch(onrejected);
-    },
-    finally(onfinally) {
-      return run(selectedColumns, selectedOptions).finally(onfinally);
+}
+function mergeCallOptions(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base,
+    ...override,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
     }
   };
-  return mutationQuery;
-}
-function getResourceId(state) {
-  const candidate = state.conditions.find(
-    (condition) => condition.operator === "eq" && (condition.column === "resource_id" || condition.column === "id")
-  );
-  return candidate?.value?.toString();
 }
-function stringifyFilterValue(value) {
-  if (Array.isArray(value)) {
-    return value.join(",");
+function extractFetchOptions(input) {
+  if (!input) {
+    return {
+      payload: void 0,
+      fetchOptions: void 0
+    };
   }
-  return String(value);
-}
-function isUuidString(value) {
-  return UUID_PATTERN.test(value.trim());
-}
-function isUuidIdentifierColumn(column) {
-  return column === "id" || /(?:^|_)uuid(?:_|$)/i.test(column) || /_id$/i.test(column);
-}
-function shouldUseUuidTextComparison(column, value) {
-  return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
+  const { fetchOptions, ...rest } = input;
+  const hasPayloadKeys = Object.keys(rest).length > 0;
+  return {
+    payload: hasPayloadKeys ? rest : void 0,
+    fetchOptions
+  };
 }
-function normalizeCast(cast) {
-  const normalized = cast.trim().toLowerCase();
-  if (!SAFE_CAST_PATTERN.test(normalized)) {
-    throw new Error(`Invalid cast type "${cast}"`);
+function buildHeaders2(config, options) {
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Athena-Sdk": SDK_HEADER_VALUE2
+  };
+  const apiKey = options?.apiKey ?? config.apiKey;
+  if (apiKey) {
+    headers.apikey = apiKey;
+    headers["x-api-key"] = apiKey;
   }
-  return normalized;
-}
-function escapeSqlStringLiteral(value) {
-  return value.replace(/'/g, "''");
-}
-function toSqlLiteral(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  return `'${escapeSqlStringLiteral(value)}'`;
-}
-function withCast(expression, cast) {
-  if (!cast) return expression;
-  return `${expression}::${normalizeCast(cast)}`;
+  const bearerToken = options?.bearerToken ?? config.bearerToken;
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+  const mergedExtraHeaders = {
+    ...config.headers ?? {},
+    ...options?.headers ?? {}
+  };
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    const normalized = normalizeHeaderValue2(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  return headers;
 }
-function buildSelectColumnsClause(columns) {
-  if (Array.isArray(columns)) {
-    return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
+function appendQueryParam(searchParams, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    value.forEach((item) => {
+      searchParams.append(key, String(item));
+    });
+    return;
   }
-  return quoteSelectColumnsExpression(columns);
+  searchParams.append(key, String(value));
 }
-function resolveTableNameForCall(tableName, schema) {
-  if (!schema) return tableName;
-  const normalizedSchema = schema.trim();
-  if (!normalizedSchema) {
-    throw new Error("schema option must be a non-empty string");
+function buildRequestUrl(baseUrl, endpoint, query) {
+  const url = `${baseUrl}${endpoint}`;
+  if (!query || Object.keys(query).length === 0) return url;
+  const searchParams = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => appendQueryParam(searchParams, key, value));
+  const queryText = searchParams.toString();
+  return queryText ? `${url}?${queryText}` : url;
+}
+function inferDefaultMethod(endpoint) {
+  if (endpoint.startsWith("/reset-password/")) {
+    return "GET";
   }
-  if (tableName.includes(".")) {
-    if (tableName.startsWith(`${normalizedSchema}.`)) {
-      return tableName;
-    }
-    throw new Error(
-      `schema option "${normalizedSchema}" conflicts with schema-qualified table "${tableName}"`
-    );
+  switch (endpoint) {
+    case "/get-session":
+    case "/list-sessions":
+    case "/verify-email":
+    case "/change-email/verify":
+    case "/delete-user/verify":
+    case "/email-list":
+    case "/email/list":
+    case "/delete-user/callback":
+    case "/list-accounts":
+    case "/passkey/generate-register-options":
+    case "/passkey/list-user-passkeys":
+    case "/.well-known/webauthn":
+    case "/admin/list-users":
+    case "/admin/athena-client/list":
+    case "/admin/audit-log/list":
+    case "/admin/email/get":
+    case "/admin/email-failure/list":
+    case "/admin/email-failure/get":
+    case "/admin/email-template/get":
+    case "/admin/email-template/list":
+    case "/admin/email/list":
+    case "/api-key/get":
+    case "/api-key/list":
+    case "/organization/get-full-organization":
+    case "/organization/list":
+    case "/organization/get-invitation":
+    case "/organization/list-invitations":
+    case "/organization/list-user-invitations":
+    case "/organization/list-members":
+    case "/organization/get-active-member":
+    case "/health":
+    case "/ok":
+    case "/error":
+      return "GET";
+    default:
+      return "POST";
   }
-  return `${normalizedSchema}.${tableName}`;
 }
-function conditionToSqlClause(condition) {
-  if (!condition.column) return null;
-  const column = withCast(quoteQualifiedIdentifier(condition.column), condition.column_cast);
-  const value = condition.value;
-  const sqlOperator = {
-    eq: "=",
-    neq: "!=",
-    gt: ">",
-    gte: ">=",
-    lt: "<",
-    lte: "<=",
-    like: "LIKE",
-    ilike: "ILIKE"
+async function callAuthEndpoint(config, context, body, query, options) {
+  const baseUrl = normalizeBaseUrl(options?.baseUrl ?? config.baseUrl);
+  const url = buildRequestUrl(baseUrl, context.endpoint, query);
+  const headers = buildHeaders2(config, options);
+  const credentials = options?.credentials ?? config.credentials ?? "include";
+  const requestInit = {
+    method: context.method,
+    headers,
+    credentials,
+    signal: options?.signal
   };
-  switch (condition.operator) {
-    case "eq":
-    case "neq":
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte":
-    case "like":
-    case "ilike": {
-      if (Array.isArray(value) || value === void 0) return null;
-      const rhs = withCast(toSqlLiteral(value), condition.value_cast);
-      return `${column} ${sqlOperator[condition.operator]} ${rhs}`;
-    }
-    case "is": {
-      if (value === null) return `${column} IS NULL`;
-      if (value === true) return `${column} IS TRUE`;
-      if (value === false) return `${column} IS FALSE`;
-      return null;
+  if (context.method !== "GET") {
+    requestInit.body = JSON.stringify(body ?? {});
+  }
+  const fetcher = config.fetch ?? globalThis.fetch;
+  if (!fetcher) {
+    const details = toErrorDetails({
+      code: "UNKNOWN_ERROR",
+      message: "No fetch implementation available for auth client",
+      status: 0,
+      endpoint: context.endpoint,
+      method: context.method,
+      hint: "Use Node 18+ or provide `fetch` via createClient(..., { auth: { fetch } }) or createAuthClient({ fetch })"
+    });
+    return {
+      ok: false,
+      status: 0,
+      data: null,
+      error: details.message,
+      errorDetails: details,
+      raw: null
+    };
+  }
+  try {
+    const response = await fetcher(url, requestInit);
+    const rawText = await response.text();
+    const requestId = resolveRequestId2(response.headers);
+    const parsedBody = parseResponseBody2(rawText ?? "", response.headers.get("content-type"));
+    if (parsedBody.parseFailed) {
+      const details = toErrorDetails({
+        code: "INVALID_JSON",
+        message: "Auth server returned malformed JSON",
+        status: response.status,
+        endpoint: context.endpoint,
+        method: context.method,
+        requestId,
+        hint: "Verify the auth endpoint response body is valid JSON.",
+        cause: rawText.slice(0, 300)
+      });
+      return {
+        ok: false,
+        status: response.status,
+        data: null,
+        error: details.message,
+        errorDetails: details,
+        raw: parsedBody.parsed
+      };
     }
-    case "in": {
-      if (!Array.isArray(value)) return null;
-      if (value.length === 0) return "FALSE";
-      const values = value.map((item) => withCast(toSqlLiteral(item), condition.value_cast));
-      return `${column} IN (${values.join(", ")})`;
+    const parsed = parsedBody.parsed;
+    if (!response.ok) {
+      const details = toErrorDetails({
+        code: "HTTP_ERROR",
+        message: resolveErrorMessage2(
+          parsed,
+          `Auth endpoint ${context.method} ${context.endpoint} failed with status ${response.status}`
+        ),
+        status: response.status,
+        endpoint: context.endpoint,
+        method: context.method,
+        requestId
+      });
+      return {
+        ok: false,
+        status: response.status,
+        data: null,
+        error: details.message,
+        errorDetails: details,
+        raw: parsed
+      };
     }
-    default:
-      return null;
+    return {
+      ok: true,
+      status: response.status,
+      data: parsed ?? null,
+      error: null,
+      errorDetails: null,
+      raw: parsed
+    };
+  } catch (callError) {
+    const message = callError instanceof Error ? callError.message : String(callError);
+    const details = toErrorDetails({
+      code: "NETWORK_ERROR",
+      message: `Network error while calling ${context.method} ${context.endpoint}: ${message}`,
+      status: 0,
+      endpoint: context.endpoint,
+      method: context.method,
+      cause: message,
+      hint: "Check auth server URL, DNS, and network reachability."
+    });
+    return {
+      ok: false,
+      status: 0,
+      data: null,
+      error: details.message,
+      errorDetails: details,
+      raw: null
+    };
   }
 }
-function buildTypedSelectQuery(input) {
-  const whereClauses = [];
-  for (const condition of input.conditions) {
-    const clause = conditionToSqlClause(condition);
-    if (!clause) return null;
-    whereClauses.push(clause);
-  }
-  let limit = input.limit;
-  let offset = input.offset;
-  if (limit === void 0 && input.pageSize !== void 0) {
-    limit = input.pageSize;
-  }
-  if (offset === void 0 && input.pageSize !== void 0 && input.currentPage !== void 0 && input.currentPage > 0) {
-    offset = (input.currentPage - 1) * input.pageSize;
-  }
-  const sqlParts = [
-    `SELECT ${buildSelectColumnsClause(input.columns)} FROM ${quoteQualifiedIdentifier(input.tableName)}`
-  ];
-  if (whereClauses.length > 0) {
-    sqlParts.push(`WHERE ${whereClauses.join(" AND ")}`);
-  }
-  if (input.order?.field) {
-    const direction = input.order.direction === "descending" ? "DESC" : "ASC";
-    sqlParts.push(`ORDER BY ${quoteQualifiedIdentifier(input.order.field)} ${direction}`);
-  }
-  if (limit !== void 0) {
-    sqlParts.push(`LIMIT ${Math.max(0, Math.trunc(limit))}`);
-  }
-  if (offset !== void 0) {
-    sqlParts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
-  }
-  return `${sqlParts.join(" ")};`;
+function executePostWithCompatibleInput(config, context, input, options) {
+  const { payload, fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, payload ?? {}, void 0, mergedOptions);
 }
-function createFilterMethods(state, addCondition, self) {
-  return {
-    eq(column, value) {
-      const columnName = String(column);
-      if (shouldUseUuidTextComparison(columnName, value)) {
-        addCondition("eq", columnName, value, { columnCast: "text" });
-      } else {
-        addCondition("eq", columnName, value);
+function executePostWithOptionalInput(config, context, input, options) {
+  const { fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, {}, void 0, mergedOptions);
+}
+function executeGetWithCompatibleInput(config, context, input, options) {
+  const { fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, void 0, void 0, mergedOptions);
+}
+function executeGetWithQueryCompatibleInput(config, context, input, options) {
+  const { payload, fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  const query = payload?.query;
+  return callAuthEndpoint(
+    config,
+    context,
+    void 0,
+    query,
+    mergedOptions
+  );
+}
+function createAuthClient(config = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const resolvedConfig = {
+    ...config,
+    baseUrl: normalizedBaseUrl
+  };
+  const request = (input, options) => {
+    const method = input.method ?? (input.body !== void 0 ? "POST" : inferDefaultMethod(input.endpoint));
+    const mergedOptions = mergeCallOptions(input.fetchOptions, options);
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: input.endpoint, method },
+      input.body,
+      input.query,
+      mergedOptions
+    );
+  };
+  const postGeneric = (endpoint, input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "POST",
+        body: payload ?? {},
+        fetchOptions
+      },
+      options
+    );
+  };
+  const getGeneric = (endpoint, input, options) => {
+    const { fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "GET",
+        fetchOptions
+      },
+      options
+    );
+  };
+  const getWithQuery = (endpoint, input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const query = payload?.query;
+    return request(
+      {
+        endpoint,
+        method: "GET",
+        query,
+        fetchOptions
+      },
+      options
+    );
+  };
+  const listUserEmailsWithFallback = async (input, options) => {
+    const primary = await getWithQuery(
+      "/email/list",
+      input,
+      options
+    );
+    if (primary.ok || primary.status !== 404 || primary.errorDetails?.code !== "HTTP_ERROR") {
+      return primary;
+    }
+    return getWithQuery(
+      "/email-list",
+      input,
+      options
+    );
+  };
+  const healthWithFallback = async (input, options) => {
+    const primary = await getGeneric("/health", input, options);
+    if (primary.ok || primary.status !== 404 || primary.errorDetails?.code !== "HTTP_ERROR") {
+      return primary;
+    }
+    const fallback = await getGeneric("/ok", input, options);
+    if (!fallback.ok) {
+      return {
+        ...fallback,
+        data: null
+      };
+    }
+    const fallbackStatus = isRecord2(fallback.data) && typeof fallback.data.ok === "boolean" ? fallback.data.ok ? "ok" : "error" : "ok";
+    return {
+      ...fallback,
+      data: {
+        status: fallbackStatus
       }
-      return self;
-    },
-    eqCast(column, value, cast) {
-      addCondition("eq", String(column), value, { valueCast: cast });
-      return self;
-    },
-    eqUuid(column, value) {
-      addCondition("eq", String(column), value, { valueCast: "uuid" });
-      return self;
-    },
-    match(filters) {
-      Object.entries(filters).forEach(([column, value]) => {
-        if (value === void 0) {
-          return;
-        }
-        if (shouldUseUuidTextComparison(column, value)) {
-          addCondition("eq", column, value, { columnCast: "text" });
-        } else {
-          addCondition("eq", column, value);
-        }
-      });
-      return self;
+    };
+  };
+  const signOut = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/sign-out", method: "POST" },
+    input,
+    options
+  );
+  const revokeSessions = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/revoke-sessions", method: "POST" },
+    input,
+    options
+  );
+  const revokeOtherSessions = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/revoke-other-sessions", method: "POST" },
+    input,
+    options
+  );
+  const revokeSession = (input, options) => executePostWithCompatibleInput(
+    resolvedConfig,
+    { endpoint: "/revoke-session", method: "POST" },
+    input,
+    options
+  );
+  const deleteUser = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: "/delete-user", method: "POST" },
+      payload ?? {},
+      void 0,
+      mergedOptions
+    );
+  };
+  const deleteUserCallback = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    const query = payload ?? {};
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: "/delete-user/callback", method: "GET" },
+      void 0,
+      {
+        token: query.token,
+        callbackURL: query.callbackURL
+      },
+      mergedOptions
+    );
+  };
+  const resolveResetPasswordToken = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    const query = payload;
+    const token = query?.token?.trim();
+    if (!token) {
+      throw new Error("resolveResetPasswordToken requires a non-empty token");
+    }
+    const endpoint = `/reset-password/${encodeURIComponent(token)}`;
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint, method: "GET" },
+      void 0,
+      query?.callbackURL ? { callbackURL: query.callbackURL } : void 0,
+      mergedOptions
+    );
+  };
+  const organization = {
+    create: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/create", method: "POST" },
+      input,
+      options
+    ),
+    update: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/update", method: "POST" },
+      input,
+      options
+    ),
+    delete: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/delete", method: "POST" },
+      input,
+      options
+    ),
+    setActive: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/set-active", method: "POST" },
+      input,
+      options
+    ),
+    list: (input, options) => getGeneric(
+      "/organization/list",
+      input,
+      options
+    ),
+    getFull: (input, options) => executeGetWithQueryCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/get-full-organization", method: "GET" },
+      input,
+      options
+    ),
+    checkSlug: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/check-slug", method: "POST" },
+      input,
+      options
+    ),
+    leave: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/leave", method: "POST" },
+      input,
+      options
+    ),
+    listUserInvitations: (input, options) => executeGetWithQueryCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/list-user-invitations", method: "GET" },
+      input,
+      options
+    ),
+    hasPermission: (input, options) => postGeneric(
+      "/organization/has-permission",
+      input,
+      options
+    ),
+    invitation: {
+      cancel: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/cancel-invitation", method: "POST" },
+        input,
+        options
+      ),
+      accept: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/accept-invitation", method: "POST" },
+        input,
+        options
+      ),
+      get: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/get-invitation", method: "GET" },
+        input,
+        options
+      ),
+      reject: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/reject-invitation", method: "POST" },
+        input,
+        options
+      ),
+      list: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/list-invitations", method: "GET" },
+        input,
+        options
+      )
     },
-    range(from, to) {
-      state.offset = from;
-      state.limit = to - from + 1;
-      return self;
+    member: {
+      remove: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/remove-member", method: "POST" },
+        input,
+        options
+      ),
+      updateRole: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/update-member-role", method: "POST" },
+        input,
+        options
+      ),
+      invite: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/invite-member", method: "POST" },
+        input,
+        options
+      ),
+      getActive: (input, options) => executeGetWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/get-active-member", method: "GET" },
+        input,
+        options
+      ),
+      list: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/list-members", method: "GET" },
+        input,
+        options
+      )
+    }
+  };
+  const authResetPassword = Object.assign(
+    (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/reset-password", method: "POST" },
+      input,
+      options
+    ),
+    {
+      token: resolveResetPasswordToken
+    }
+  );
+  const sessionRevokeBinding = (input, options) => {
+    if (Array.isArray(input)) {
+      if (input.length === 0) {
+        throw new Error("session.revoke requires at least one session token");
+      }
+      if (input.length === 1) {
+        return revokeSession(input[0], options);
+      }
+      return revokeSessions(void 0, options);
+    }
+    const parsed = input;
+    const tokens = Array.isArray(parsed.tokens) ? parsed.tokens.filter((token2) => token2.trim().length > 0) : void 0;
+    if (tokens && tokens.length > 1) {
+      return revokeSessions(
+        parsed.fetchOptions ? { fetchOptions: parsed.fetchOptions } : void 0,
+        options
+      );
+    }
+    if (tokens && tokens.length === 1) {
+      return revokeSession(
+        { token: tokens[0], fetchOptions: parsed.fetchOptions },
+        options
+      );
+    }
+    const token = parsed.token?.trim();
+    if (!token) {
+      throw new Error("session.revoke requires a non-empty token or a non-empty token list");
+    }
+    return revokeSession(
+      {
+        token,
+        fetchOptions: parsed.fetchOptions
+      },
+      options
+    );
+  };
+  const adminUserSessionRevokeBinding = (input, options) => {
+    const requireUserId = (userId) => {
+      const trimmed = String(userId ?? "").trim();
+      if (!trimmed) {
+        throw new Error("admin.user.session.revoke requires a non-empty userId");
+      }
+      return trimmed;
+    };
+    const requireSinglePluralUserId = (sessions2) => {
+      const uniqueUserIds = [...new Set(sessions2.map((session) => requireUserId(session.userId)))];
+      if (uniqueUserIds.length !== 1) {
+        throw new Error("admin.user.session.revoke requires the same userId across plural payloads");
+      }
+      return { userId: uniqueUserIds[0] };
+    };
+    if (Array.isArray(input)) {
+      if (input.length === 0) {
+        throw new Error("admin.user.session.revoke requires at least one payload item");
+      }
+      if (input.length === 1) {
+        return postGeneric(
+          "/admin/revoke-user-session",
+          {
+            ...input[0],
+            userId: requireUserId(input[0].userId)
+          },
+          options
+        );
+      }
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        requireSinglePluralUserId(input),
+        options
+      );
+    }
+    const parsed = input;
+    const sessions = parsed.sessions;
+    if (sessions && sessions.length === 0) {
+      throw new Error("admin.user.session.revoke requires at least one payload item");
+    }
+    if (sessions && sessions.length === 1) {
+      return postGeneric(
+        "/admin/revoke-user-session",
+        {
+          ...sessions[0],
+          userId: requireUserId(sessions[0].userId),
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    if (sessions && sessions.length > 1) {
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        {
+          ...requireSinglePluralUserId(sessions),
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    const normalizedUserId = requireUserId(parsed.userId);
+    if (!parsed.sessionToken) {
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        {
+          userId: normalizedUserId,
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    return postGeneric(
+      "/admin/revoke-user-session",
+      {
+        ...parsed,
+        userId: normalizedUserId
+      },
+      options
+    );
+  };
+  const auth = {
+    getSession: (input, options) => getGeneric("/get-session", input, options),
+    signOut,
+    forgetPassword: (input, options) => postGeneric("/forget-password", input, options),
+    resetPassword: authResetPassword,
+    setPassword: (input, options) => postGeneric("/set-password", input, options),
+    verifyEmail: (input, options) => {
+      const queryInput = {
+        query: {
+          token: input.token,
+          callbackURL: input.callbackURL
+        },
+        fetchOptions: input.fetchOptions
+      };
+      return getWithQuery(
+        "/verify-email",
+        queryInput,
+        options
+      );
     },
-    limit(count) {
-      state.limit = count;
-      return self;
+    sendVerificationEmail: (input, options) => postGeneric("/send-verification-email", input, options),
+    changeEmail: (input, options) => postGeneric("/change-email", input, options),
+    changeEmailVerify: (input, options) => getWithQuery("/change-email/verify", input, options),
+    deleteUserVerify: (input, options) => getWithQuery("/delete-user/verify", input, options),
+    changePassword: (input, options) => postGeneric("/change-password", input, options),
+    user: {
+      update: (input, options) => postGeneric("/update-user", input, options),
+      delete: (input, options) => postGeneric("/delete-user", input, options),
+      email: {
+        list: listUserEmailsWithFallback
+      }
     },
-    offset(count) {
-      state.offset = count;
-      return self;
+    session: {
+      list: (input, options) => getGeneric("/list-sessions", input, options),
+      revoke: sessionRevokeBinding,
+      revokeOther: revokeOtherSessions
     },
-    currentPage(value) {
-      state.currentPage = value;
-      return self;
+    social: {
+      link: (input, options) => postGeneric("/link-social", input, options)
     },
-    pageSize(value) {
-      state.pageSize = value;
-      return self;
+    account: {
+      list: (input, options) => getGeneric("/list-accounts", input, options),
+      unlink: (input, options) => postGeneric("/unlink-account", input, options)
     },
-    totalPages(value) {
-      state.totalPages = value;
-      return self;
+    deleteUser: {
+      callback: deleteUserCallback
     },
-    order(column, options) {
-      state.order = {
-        field: String(column),
-        direction: options?.ascending === false ? "descending" : "ascending"
-      };
-      return self;
+    refreshToken: (input, options) => postGeneric("/refresh-token", input, options),
+    getAccessToken: (input, options) => postGeneric("/get-access-token", input, options),
+    health: healthWithFallback,
+    ok: (input, options) => getGeneric("/ok", input, options),
+    error: (input, options) => getGeneric("/error", input, options),
+    twoFactor: {
+      getTotpUri: (input, options) => postGeneric("/two-factor/get-totp-uri", input, options),
+      verifyTotp: (input, options) => postGeneric("/two-factor/verify-totp", input, options),
+      sendOtp: (input, options) => postGeneric("/two-factor/send-otp", input, options),
+      verifyOtp: (input, options) => postGeneric("/two-factor/verify-otp", input, options),
+      verifyBackupCode: (input, options) => postGeneric("/two-factor/verify-backup-code", input, options),
+      generateBackupCodes: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/two-factor/generate-backup-codes", method: "POST" },
+        input,
+        options
+      ),
+      enable: (input, options) => postGeneric("/two-factor/enable", input, options),
+      disable: (input, options) => postGeneric("/two-factor/disable", input, options)
     },
-    gt(column, value) {
-      addCondition("gt", String(column), value);
-      return self;
+    passkey: {
+      generateRegisterOptions: (input, options) => getGeneric("/passkey/generate-register-options", input, options),
+      generateAuthenticateOptions: (input, options) => postGeneric("/passkey/generate-authenticate-options", input, options),
+      verifyRegistration: (input, options) => postGeneric("/passkey/verify-registration", input, options),
+      verifyAuthentication: (input, options) => postGeneric("/passkey/verify-authentication", input, options),
+      listUserPasskeys: (input, options) => getGeneric("/passkey/list-user-passkeys", input, options),
+      deletePasskey: (input, options) => postGeneric("/passkey/delete-passkey", input, options),
+      updatePasskey: (input, options) => postGeneric("/passkey/update-passkey", input, options),
+      getRelatedOrigins: (input, options) => getGeneric("/.well-known/webauthn", input, options)
     },
-    gte(column, value) {
-      addCondition("gte", String(column), value);
-      return self;
+    admin: {
+      role: {
+        set: (input, options) => postGeneric("/admin/set-role", input, options)
+      },
+      user: {
+        list: (input, options) => getWithQuery("/admin/list-users", input, options),
+        create: (input, options) => postGeneric("/admin/create-user", input, options),
+        unban: (input, options) => postGeneric("/admin/unban-user", input, options),
+        ban: (input, options) => postGeneric("/admin/ban-user", input, options),
+        impersonate: (input, options) => postGeneric("/admin/impersonate-user", input, options),
+        stopImpersonating: (input, options) => postGeneric("/admin/stop-impersonating", input, options),
+        remove: (input, options) => postGeneric("/admin/remove-user", input, options),
+        setPassword: (input, options) => postGeneric("/admin/set-user-password", input, options),
+        session: {
+          list: (input, options) => postGeneric("/admin/list-user-sessions", input, options),
+          revoke: adminUserSessionRevokeBinding
+        }
+      },
+      hasPermission: (input, options) => postGeneric("/admin/has-permission", input, options),
+      apiKey: {
+        create: (input, options) => postGeneric("/admin/api-key/create", input, options)
+      },
+      athenaClient: {
+        create: (input, options) => postGeneric("/admin/athena-client/create", input, options),
+        list: (input, options) => getWithQuery("/admin/athena-client/list", input, options)
+      },
+      auditLog: {
+        list: (input, options) => getWithQuery("/admin/audit-log/list", input, options)
+      },
+      email: {
+        list: (input, options) => getWithQuery("/admin/email/list", input, options),
+        get: (input, options) => getWithQuery("/admin/email/get", input, options),
+        create: (input, options) => postGeneric("/admin/email/create", input, options),
+        update: (input, options) => postGeneric("/admin/email/update", input, options),
+        delete: (input, options) => postGeneric("/admin/email/delete", input, options),
+        failure: {
+          list: (input, options) => getWithQuery("/admin/email-failure/list", input, options),
+          get: (input, options) => getWithQuery("/admin/email-failure/get", input, options),
+          create: (input, options) => postGeneric("/admin/email-failure/create", input, options),
+          update: (input, options) => postGeneric("/admin/email-failure/update", input, options),
+          delete: (input, options) => postGeneric("/admin/email-failure/delete", input, options)
+        },
+        template: {
+          list: (input, options) => getWithQuery("/admin/email-template/list", input, options),
+          get: (input, options) => getWithQuery("/admin/email-template/get", input, options),
+          create: (input, options) => postGeneric("/admin/email-template/create", input, options),
+          update: (input, options) => postGeneric("/admin/email-template/update", input, options),
+          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options)
+        }
+      },
+      emailTemplate: {
+        get: (input, options) => getWithQuery("/admin/email-template/get", input, options),
+        create: (input, options) => postGeneric("/admin/email-template/create", input, options),
+        delete: (input, options) => postGeneric("/admin/email-template/delete", input, options),
+        list: (input, options) => getWithQuery("/admin/email-template/list", input, options),
+        update: (input, options) => postGeneric("/admin/email-template/update", input, options)
+      }
     },
-    lt(column, value) {
-      addCondition("lt", String(column), value);
-      return self;
-    },
-    lte(column, value) {
-      addCondition("lte", String(column), value);
-      return self;
-    },
-    neq(column, value) {
-      addCondition("neq", String(column), value);
-      return self;
-    },
-    like(column, value) {
-      addCondition("like", String(column), value);
-      return self;
-    },
-    ilike(column, value) {
-      addCondition("ilike", String(column), value);
-      return self;
-    },
-    is(column, value) {
-      addCondition("is", String(column), value);
-      return self;
-    },
-    in(column, values) {
-      addCondition("in", String(column), values);
-      return self;
+    apiKey: {
+      create: (input, options) => postGeneric("/api-key/create", input, options),
+      get: (input, options) => getWithQuery("/api-key/get", input, options),
+      update: (input, options) => postGeneric("/api-key/update", input, options),
+      delete: (input, options) => postGeneric("/api-key/delete", input, options),
+      list: (input, options) => getWithQuery("/api-key/list", input, options),
+      verify: (input, options) => postGeneric("/api-key/verify", input, options),
+      deleteAllExpired: (input, options) => executePostWithOptionalInput(
+        resolvedConfig,
+        { endpoint: "/api-key/delete-all-expired-api-keys", method: "POST" },
+        input,
+        options
+      )
     },
-    contains(column, values) {
-      addCondition("contains", String(column), values);
-      return self;
+    signIn: {
+      email: (input, options) => postGeneric("/sign-in/email", input, options),
+      username: (input, options) => postGeneric("/sign-in/username", input, options),
+      social: (input, options) => postGeneric("/sign-in/social", input, options)
     },
-    containedBy(column, values) {
-      addCondition("containedBy", String(column), values);
-      return self;
+    signUp: {
+      email: (input, options) => postGeneric("/sign-up/email", input, options)
     },
-    not(columnOrExpression, operator, value) {
-      const expression = String(columnOrExpression);
-      if (operator != null && value !== void 0) {
-        addCondition("not", void 0, `${expression}.${operator}.${stringifyFilterValue(value)}`);
-      } else {
-        addCondition("not", void 0, expression);
+    organization,
+    callback: {
+      provider: (input, options) => {
+        const { payload, fetchOptions } = extractFetchOptions(input);
+        const parsed = payload;
+        const provider = String(parsed?.provider ?? "").trim();
+        if (!provider) {
+          throw new Error("callback.provider requires a non-empty provider value");
+        }
+        const code = String(parsed?.code ?? "").trim();
+        const state = String(parsed?.state ?? "").trim();
+        if (!code || !state) {
+          throw new Error("callback.provider requires non-empty code and state values");
+        }
+        const endpoint = `/callback/${encodeURIComponent(provider)}`;
+        return request({
+          endpoint,
+          method: "GET",
+          query: {
+            code,
+            state
+          },
+          fetchOptions
+        }, options);
       }
-      return self;
-    },
-    or(expression) {
-      addCondition("or", void 0, expression);
-      return self;
     }
   };
-}
-function toRpcSelect(columns) {
-  if (!columns) return void 0;
-  return Array.isArray(columns) ? columns.join(",") : columns;
-}
-function createRpcFilterMethods(filters, self) {
-  const addFilter = (operator, column, value) => {
-    filters.push({ column, operator, value });
-  };
   return {
-    eq(column, value) {
-      addFilter("eq", column, value);
-      return self;
-    },
-    neq(column, value) {
-      addFilter("neq", column, value);
-      return self;
-    },
-    gt(column, value) {
-      addFilter("gt", column, value);
-      return self;
-    },
-    gte(column, value) {
-      addFilter("gte", column, value);
-      return self;
-    },
-    lt(column, value) {
-      addFilter("lt", column, value);
-      return self;
-    },
-    lte(column, value) {
-      addFilter("lte", column, value);
-      return self;
-    },
-    like(column, value) {
-      addFilter("like", column, value);
-      return self;
+    baseUrl: normalizedBaseUrl,
+    request,
+    signIn: {
+      email: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/email", method: "POST" },
+        input,
+        options
+      ),
+      username: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/username", method: "POST" },
+        input,
+        options
+      ),
+      social: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/social", method: "POST" },
+        input,
+        options
+      )
     },
-    ilike(column, value) {
-      addFilter("ilike", column, value);
-      return self;
+    signUp: {
+      email: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-up/email", method: "POST" },
+        input,
+        options
+      )
     },
-    is(column, value) {
-      addFilter("is", column, value);
-      return self;
+    signOut,
+    logout: signOut,
+    getSession: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/get-session", method: "GET" },
+      input,
+      options
+    ),
+    listSessions: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/list-sessions", method: "GET" },
+      input,
+      options
+    ),
+    revokeSession,
+    clearSession: revokeSession,
+    revokeSessions,
+    clearSessions: revokeSessions,
+    revokeOtherSessions,
+    clearOtherSessions: revokeOtherSessions,
+    forgetPassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/forget-password", method: "POST" },
+      input,
+      options
+    ),
+    resetPassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/reset-password", method: "POST" },
+      input,
+      options
+    ),
+    resolveResetPasswordToken,
+    verifyEmail: (input, options) => {
+      const { payload, fetchOptions } = extractFetchOptions(input);
+      const mergedOptions = mergeCallOptions(fetchOptions, options);
+      const query = payload;
+      return callAuthEndpoint(
+        resolvedConfig,
+        { endpoint: "/verify-email", method: "GET" },
+        void 0,
+        query ? {
+          token: query.token,
+          callbackURL: query.callbackURL
+        } : void 0,
+        mergedOptions
+      );
     },
-    in(column, values) {
-      addFilter("in", column, values);
-      return self;
-    }
+    sendVerificationEmail: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/send-verification-email", method: "POST" },
+      input,
+      options
+    ),
+    changeEmail: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/change-email", method: "POST" },
+      input,
+      options
+    ),
+    changePassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/change-password", method: "POST" },
+      input,
+      options
+    ),
+    updateUser: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/update-user", method: "POST" },
+      input,
+      options
+    ),
+    deleteUser,
+    deleteUserCallback,
+    linkSocial: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/link-social", method: "POST" },
+      input,
+      options
+    ),
+    listAccounts: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/list-accounts", method: "GET" },
+      input,
+      options
+    ),
+    unlinkAccount: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/unlink-account", method: "POST" },
+      input,
+      options
+    ),
+    refreshToken: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/refresh-token", method: "POST" },
+      input,
+      options
+    ),
+    getAccessToken: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/get-access-token", method: "POST" },
+      input,
+      options
+    ),
+    organization,
+    auth
   };
 }
-function createRpcBuilder(functionName, args, baseOptions, client) {
-  const state = {
-    filters: []
-  };
-  let selectedColumns;
-  let selectedOptions;
-  let promise = null;
-  const executeRpc = async (columns, options) => {
-    const mergedOptions = mergeOptions(baseOptions, options);
-    const payload = {
-      function: functionName,
-      args,
-      schema: mergedOptions?.schema,
-      select: toRpcSelect(columns),
-      filters: state.filters.length ? [...state.filters] : void 0,
-      count: mergedOptions?.count,
-      head: mergedOptions?.head,
-      limit: state.limit,
-      offset: state.offset,
-      order: state.order
-    };
-    const response = await client.rpcGateway(payload, mergedOptions);
-    return formatResult(response);
-  };
-  const run = (columns, options) => {
-    const payloadColumns = columns ?? selectedColumns;
-    const payloadOptions = options ?? selectedOptions;
-    if (!promise) {
-      promise = executeRpc(payloadColumns, payloadOptions);
-    }
-    return promise;
-  };
-  const builder = {};
-  const filterMethods = createRpcFilterMethods(state.filters, builder);
-  Object.assign(builder, filterMethods, {
-    select(columns = selectedColumns, options) {
-      selectedColumns = columns;
-      selectedOptions = options ?? selectedOptions;
-      return run(columns, options);
-    },
-    async single(columns, options) {
-      const result = await run(columns, options);
-      return toSingleResult(result);
-    },
-    maybeSingle(columns, options) {
-      return builder.single(columns, options);
-    },
-    order(column, options) {
-      state.order = { column, ascending: options?.ascending ?? true };
-      return builder;
-    },
-    limit(count) {
-      state.limit = count;
-      return builder;
-    },
-    offset(count) {
-      state.offset = count;
-      return builder;
-    },
-    range(from, to) {
-      state.offset = from;
-      state.limit = to - from + 1;
-      return builder;
-    },
-    then(onfulfilled, onrejected) {
-      return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
-    },
-    catch(onrejected) {
-      return run(selectedColumns, selectedOptions).catch(onrejected);
-    },
-    finally(onfinally) {
-      return run(selectedColumns, selectedOptions).finally(onfinally);
-    }
-  });
-  return builder;
+
+// src/auxiliaries.ts
+var AthenaErrorKind = {
+  UniqueViolation: "unique_violation",
+  NotFound: "not_found",
+  Validation: "validation",
+  Auth: "auth",
+  RateLimit: "rate_limit",
+  Transient: "transient",
+  Unknown: "unknown"
+};
+var AthenaErrorCode = {
+  UniqueViolation: "UNIQUE_VIOLATION",
+  NotFound: "NOT_FOUND",
+  ValidationFailed: "VALIDATION_FAILED",
+  AuthUnauthorized: "AUTH_UNAUTHORIZED",
+  AuthForbidden: "AUTH_FORBIDDEN",
+  RateLimited: "RATE_LIMITED",
+  NetworkUnavailable: "NETWORK_UNAVAILABLE",
+  TransientFailure: "TRANSIENT_FAILURE",
+  HttpFailure: "HTTP_FAILURE",
+  Unknown: "UNKNOWN"
+};
+var AthenaErrorCategory = {
+  Transport: "transport",
+  Client: "client",
+  Server: "server",
+  Database: "database",
+  Unknown: "unknown"
+};
+function parseBooleanFlag(rawValue, fallback) {
+  if (!rawValue) return fallback;
+  const normalized = rawValue.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return fallback;
 }
-function createTableBuilder(tableName, client) {
-  const state = {
-    conditions: []
+var AthenaError = class extends Error {
+  code;
+  kind;
+  category;
+  status;
+  retryable;
+  requestId;
+  context;
+  raw;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaError";
+    this.code = input.code;
+    this.kind = input.kind;
+    this.category = input.category;
+    this.status = input.status;
+    this.retryable = input.retryable ?? false;
+    this.requestId = input.requestId;
+    this.context = input.context;
+    this.raw = input.raw;
+  }
+};
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isAthenaErrorKind(value) {
+  return value === "unique_violation" || value === "not_found" || value === "validation" || value === "auth" || value === "rate_limit" || value === "transient" || value === "unknown";
+}
+function isAthenaErrorCode(value) {
+  return value === "UNIQUE_VIOLATION" || value === "NOT_FOUND" || value === "VALIDATION_FAILED" || value === "AUTH_UNAUTHORIZED" || value === "AUTH_FORBIDDEN" || value === "RATE_LIMITED" || value === "NETWORK_UNAVAILABLE" || value === "TRANSIENT_FAILURE" || value === "HTTP_FAILURE" || value === "UNKNOWN";
+}
+function isAthenaErrorCategory(value) {
+  return value === "transport" || value === "client" || value === "server" || value === "database" || value === "unknown";
+}
+function isNormalizedAthenaError(value) {
+  return isRecord3(value) && isAthenaErrorKind(value.kind) && isAthenaErrorCode(value.code) && isAthenaErrorCategory(value.category) && typeof value.retryable === "boolean" && typeof value.message === "string" && "raw" in value;
+}
+function withContextOverrides(normalized, context) {
+  if (!context?.table && !context?.operation) {
+    return normalized;
+  }
+  return {
+    ...normalized,
+    table: context.table ?? normalized.table,
+    operation: context.operation ?? normalized.operation
   };
-  const addCondition = (operator, column, value, hints) => {
-    const condition = { operator };
-    if (column) {
-      condition.column = column;
-      if (operator === "eq") {
-        condition.eq_column = column;
-      }
-    }
-    if (value !== void 0) {
-      condition.value = value;
-      if (operator === "eq") {
-        condition.eq_value = value;
-      }
-    }
-    if (hints?.valueCast) {
-      condition.value_cast = hints.valueCast;
-      if (operator === "eq") {
-        condition.eq_value_cast = hints.valueCast;
-      }
-    }
-    if (hints?.columnCast) {
-      condition.column_cast = hints.columnCast;
-      if (operator === "eq") {
-        condition.eq_column_cast = hints.columnCast;
+}
+function resolveAttachedNormalizedError(resultOrError) {
+  if (!isRecord3(resultOrError)) return void 0;
+  if (!("__athenaNormalizedError" in resultOrError)) return void 0;
+  const candidate = resultOrError.__athenaNormalizedError;
+  return isNormalizedAthenaError(candidate) ? candidate : void 0;
+}
+function safeStringify(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized ?? String(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function contextHint(context) {
+  if (!context?.identity) return void 0;
+  const identity = typeof context.identity === "string" ? context.identity : safeStringify(context.identity);
+  return `Identity: ${identity}`;
+}
+function isAthenaResultLike(value) {
+  return isRecord3(value) && "status" in value && "error" in value && "data" in value && typeof value.status === "number";
+}
+function operationFromDetails(details) {
+  if (!details?.endpoint) return void 0;
+  if (details.endpoint === "/gateway/fetch" || details.endpoint === "/gateway/query") return "select";
+  if (details.endpoint === "/gateway/insert") return "insert";
+  if (details.endpoint === "/gateway/update") return "update";
+  if (details.endpoint === "/gateway/delete") return "delete";
+  if (details.endpoint === "/gateway/rpc" || details.endpoint.startsWith("/rpc/")) return "rpc";
+  return void 0;
+}
+function matchRegex(input, patterns) {
+  for (const pattern of patterns) {
+    const match = pattern.exec(input);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+function extractConstraint(message) {
+  return matchRegex(message, [
+    /unique constraint\s+["'`]([^"'`]+)["'`]/i,
+    /constraint\s+["'`]([^"'`]+)["'`]/i
+  ]);
+}
+function extractTable(message) {
+  return matchRegex(message, [
+    /(?:table|relation)\s+["'`]([^"'`]+)["'`]/i,
+    /on\s+table\s+([a-zA-Z0-9_.]+)/i
+  ]);
+}
+function classifyKind(status, code, message) {
+  const lower = message.toLowerCase();
+  const hasUniquePattern = lower.includes("unique constraint") || lower.includes("duplicate key") || lower.includes("already exists") || lower.includes("duplicate");
+  const hasNotFoundPattern = lower.includes("not found") || lower.includes("no rows");
+  const hasValidationPattern = lower.includes("validation") || lower.includes("invalid") || lower.includes("malformed");
+  const hasAuthPattern = lower.includes("unauthorized") || lower.includes("forbidden") || lower.includes("auth");
+  const hasRateLimitPattern = lower.includes("rate limit") || lower.includes("too many requests");
+  const hasTransientPattern = lower.includes("timeout") || lower.includes("temporar") || lower.includes("connection reset") || lower.includes("socket") || lower.includes("deadlock");
+  if (status === 409 || hasUniquePattern) return "unique_violation";
+  if (status === 404 || hasNotFoundPattern) return "not_found";
+  if (status === 401 || status === 403 || hasAuthPattern) return "auth";
+  if (status === 429 || hasRateLimitPattern) return "rate_limit";
+  if (status === 400 || status === 422 || hasValidationPattern) return "validation";
+  if (code === "NETWORK_ERROR" || status === 0 || status !== void 0 && status >= 500 || hasTransientPattern) {
+    return "transient";
+  }
+  return "unknown";
+}
+function toAthenaErrorCode(kind, status, gatewayCode) {
+  if (gatewayCode === "NETWORK_ERROR" || kind === "transient" && status === 0) {
+    return AthenaErrorCode.NetworkUnavailable;
+  }
+  switch (kind) {
+    case "unique_violation":
+      return AthenaErrorCode.UniqueViolation;
+    case "not_found":
+      return AthenaErrorCode.NotFound;
+    case "validation":
+      return AthenaErrorCode.ValidationFailed;
+    case "rate_limit":
+      return AthenaErrorCode.RateLimited;
+    case "auth":
+      if (status === 403) {
+        return AthenaErrorCode.AuthForbidden;
       }
-    }
-    state.conditions.push(condition);
+      return AthenaErrorCode.AuthUnauthorized;
+    case "transient":
+      return status !== void 0 && status >= 500 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.TransientFailure;
+    case "unknown":
+    default:
+      return status !== void 0 && status >= 400 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.Unknown;
+  }
+}
+function toAthenaErrorCategory(kind, status) {
+  if (kind === "transient" && (status === 0 || status === void 0)) {
+    return AthenaErrorCategory.Transport;
+  }
+  if (kind === "unique_violation") return AthenaErrorCategory.Database;
+  if (kind === "validation" || kind === "auth" || kind === "not_found") return AthenaErrorCategory.Client;
+  if (kind === "rate_limit" || kind === "transient") return AthenaErrorCategory.Server;
+  return AthenaErrorCategory.Unknown;
+}
+function isRetryable(kind, status) {
+  if (kind === "rate_limit" || kind === "transient") return true;
+  return status !== void 0 && status >= 500;
+}
+function toGatewayCode(kind, status) {
+  if (kind === "transient" && (status === 0 || status === void 0)) return "NETWORK_ERROR";
+  if (kind === "validation") return "INVALID_JSON";
+  if (status !== void 0 && status >= 400) return "HTTP_ERROR";
+  return "UNKNOWN_ERROR";
+}
+function toAthenaGatewayError(source, fallbackMessage, context) {
+  if (isAthenaGatewayError(source)) {
+    return source;
+  }
+  if (isAthenaResultLike(source) && source.errorDetails) {
+    return new AthenaGatewayError({
+      code: source.errorDetails.code,
+      message: source.error ?? source.errorDetails.message,
+      status: source.status,
+      endpoint: source.errorDetails.endpoint,
+      method: source.errorDetails.method,
+      requestId: source.errorDetails.requestId,
+      hint: source.errorDetails.hint,
+      cause: source.errorDetails.cause
+    });
+  }
+  const normalized = normalizeAthenaError(source, context);
+  const message = isAthenaResultLike(source) && source.error == null && source.errorDetails == null ? fallbackMessage : normalized.message || fallbackMessage;
+  return new AthenaGatewayError({
+    code: toGatewayCode(normalized.kind, normalized.status),
+    message,
+    status: normalized.status ?? 0,
+    hint: normalized.constraint != null ? `Constraint: ${normalized.constraint}` : contextHint(context),
+    cause: typeof normalized.raw === "string" ? normalized.raw : safeStringify(normalized.raw)
+  });
+}
+function isOk(result) {
+  return result.error == null && result.status >= 200 && result.status < 300;
+}
+function normalizeAthenaError(resultOrError, context) {
+  const attached = resolveAttachedNormalizedError(resultOrError);
+  if (attached) {
+    return withContextOverrides(attached, context);
+  }
+  if (isAthenaResultLike(resultOrError)) {
+    const details = resultOrError.errorDetails;
+    const message2 = resultOrError.error ?? details?.message ?? `Athena ${context?.operation ?? operationFromDetails(details) ?? "request"} failed`;
+    const operation = context?.operation ?? operationFromDetails(details);
+    const table = context?.table ?? extractTable(message2);
+    const constraint = extractConstraint(message2);
+    const kind2 = classifyKind(resultOrError.status, details?.code, message2);
+    const code = toAthenaErrorCode(kind2, resultOrError.status, details?.code);
+    const category = toAthenaErrorCategory(kind2, resultOrError.status);
+    return {
+      kind: kind2,
+      code,
+      category,
+      retryable: isRetryable(kind2, resultOrError.status),
+      status: resultOrError.status,
+      constraint,
+      table,
+      operation,
+      message: message2,
+      raw: resultOrError.raw
+    };
+  }
+  if (isAthenaGatewayError(resultOrError)) {
+    const details = resultOrError.toDetails();
+    const operation = context?.operation ?? operationFromDetails(details);
+    const table = context?.table ?? extractTable(resultOrError.message);
+    const constraint = extractConstraint(resultOrError.message);
+    const kind2 = classifyKind(resultOrError.status, resultOrError.code, resultOrError.message);
+    const code = toAthenaErrorCode(kind2, resultOrError.status, resultOrError.code);
+    const category = toAthenaErrorCategory(kind2, resultOrError.status);
+    return {
+      kind: kind2,
+      code,
+      category,
+      retryable: isRetryable(kind2, resultOrError.status),
+      status: resultOrError.status,
+      constraint,
+      table,
+      operation,
+      message: resultOrError.message,
+      raw: resultOrError
+    };
+  }
+  if (resultOrError instanceof Error) {
+    const maybeStatus = isRecord3(resultOrError) && typeof resultOrError.status === "number" ? resultOrError.status : void 0;
+    const kind2 = classifyKind(maybeStatus, void 0, resultOrError.message);
+    return {
+      kind: kind2,
+      code: toAthenaErrorCode(kind2, maybeStatus),
+      category: toAthenaErrorCategory(kind2, maybeStatus),
+      retryable: isRetryable(kind2, maybeStatus),
+      status: maybeStatus,
+      constraint: extractConstraint(resultOrError.message),
+      table: context?.table ?? extractTable(resultOrError.message),
+      operation: context?.operation,
+      message: resultOrError.message,
+      raw: resultOrError
+    };
+  }
+  const message = typeof resultOrError === "string" ? resultOrError : "Unknown Athena error";
+  const kind = classifyKind(void 0, void 0, message);
+  return {
+    kind,
+    code: toAthenaErrorCode(kind, void 0),
+    category: toAthenaErrorCategory(kind, void 0),
+    retryable: isRetryable(kind, void 0),
+    status: void 0,
+    constraint: extractConstraint(message),
+    table: context?.table ?? extractTable(message),
+    operation: context?.operation,
+    message,
+    raw: resultOrError
   };
-  const builder = {};
-  const filterMethods = createFilterMethods(
-    state,
-    addCondition,
-    builder
-  );
-  const runSelect = async (columns = DEFAULT_COLUMNS, options) => {
-    const resolvedTableName = resolveTableNameForCall(tableName, options?.schema);
-    const conditions = state.conditions.length ? state.conditions.map((condition) => ({ ...condition })) : void 0;
-    const hasTypedEqualityComparison = conditions?.some(
-      (condition) => condition.operator === "eq" && (condition.value_cast !== void 0 || condition.column_cast !== void 0)
-    ) ?? false;
-    if (hasTypedEqualityComparison && !options?.head && !options?.count && conditions) {
-      const query = buildTypedSelectQuery({
-        tableName: resolvedTableName,
-        columns,
-        conditions,
-        limit: state.limit,
-        offset: state.offset,
-        currentPage: state.currentPage,
-        pageSize: state.pageSize,
-        order: state.order
-      });
-      if (query) {
-        const queryResponse = await client.queryGateway({ query }, options);
-        return formatResult(queryResponse);
+}
+function unwrapRows(result, options) {
+  if (!isOk(result)) {
+    throw toAthenaGatewayError(result, "Athena request failed", options?.context);
+  }
+  if (result.data == null) return [];
+  return Array.isArray(result.data) ? result.data : [result.data];
+}
+function unwrap(result, options) {
+  if (!isOk(result)) {
+    throw toAthenaGatewayError(result, "Athena request failed", options?.context);
+  }
+  if (result.data == null && !options?.allowNull) {
+    throw toAthenaGatewayError(result, "Expected data but received null", options?.context);
+  }
+  return result.data;
+}
+function unwrapOne(result, options) {
+  const rows = unwrapRows(result, options);
+  if (!rows.length) {
+    if (options?.allowNull) return null;
+    throw toAthenaGatewayError(result, "Expected one row but received none", options?.context);
+  }
+  if (options?.requireExactlyOne && rows.length !== 1) {
+    throw toAthenaGatewayError(
+      result,
+      `Expected exactly one row but received ${rows.length}`,
+      options.context
+    );
+  }
+  return rows[0];
+}
+function requireSuccess(result, context) {
+  if (!isOk(result)) {
+    throw toAthenaGatewayError(
+      result,
+      `Athena ${context?.operation ?? "request"} failed`,
+      context
+    );
+  }
+  return result;
+}
+function requireAffected(result, options, context) {
+  requireSuccess(result, context);
+  const minimum = options?.min ?? 1;
+  const count = result.count;
+  if (count == null) {
+    throw new AthenaGatewayError({
+      code: "UNKNOWN_ERROR",
+      status: result.status,
+      message: "Expected affected row count but response.count is missing",
+      hint: 'Set call option { count: "exact" } for mutation postcondition checks.',
+      cause: safeStringify(result.raw)
+    });
+  }
+  if (count < minimum) {
+    throw new AthenaGatewayError({
+      code: "UNKNOWN_ERROR",
+      status: result.status,
+      message: `Expected at least ${minimum} affected rows but received ${count}`,
+      hint: contextHint(context),
+      cause: safeStringify(result.raw)
+    });
+  }
+  return count;
+}
+function applyBounds(value, options) {
+  if (options?.min !== void 0 && value < options.min) return null;
+  if (options?.max !== void 0 && value > options.max) return null;
+  return value;
+}
+function parseIntegerString(value) {
+  const normalized = value.trim();
+  if (!/^[-+]?\d+$/.test(normalized)) return null;
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) return null;
+  return parsed;
+}
+function coerceInt(value, options) {
+  if (value == null) return null;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) return null;
+    return applyBounds(value, options);
+  }
+  if (typeof value === "string") {
+    const parsed = parseIntegerString(value);
+    if (parsed == null) return null;
+    return applyBounds(parsed, options);
+  }
+  if (typeof value === "bigint") {
+    if (options?.strictBigInt) {
+      if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
+        return null;
       }
     }
-    const payload = {
-      table_name: resolvedTableName,
-      columns,
-      conditions,
-      limit: state.limit,
-      offset: state.offset,
-      current_page: state.currentPage,
-      page_size: state.pageSize,
-      total_pages: state.totalPages,
-      sort_by: state.order,
-      strip_nulls: options?.stripNulls ?? true,
-      count: options?.count,
-      head: options?.head
-    };
-    const response = await client.fetchGateway(payload, options);
-    return formatResult(response);
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) return null;
+    return applyBounds(parsed, options);
+  }
+  return null;
+}
+function assertInt(value, label = "value", options) {
+  const parsed = coerceInt(value, options);
+  if (parsed == null) {
+    throw new TypeError(`${label} must be a finite integer`);
+  }
+  return parsed;
+}
+function defaultShouldRetry(error) {
+  const normalized = normalizeAthenaError(error);
+  return normalized.kind === "transient" || normalized.kind === "rate_limit";
+}
+function computeDelayMs(attempt, error, config) {
+  const baseDelay = config.baseDelayMs;
+  const rawDelay = typeof config.backoff === "function" ? config.backoff(attempt, error) : config.backoff === "linear" ? baseDelay * attempt : baseDelay * Math.pow(2, attempt - 1);
+  const safeDelay = Number.isFinite(rawDelay) ? Math.max(0, rawDelay) : 0;
+  const clamped = Math.min(config.maxDelayMs, safeDelay);
+  const jitterFactor = typeof config.jitter === "number" ? Math.max(0, Math.min(1, config.jitter)) : config.jitter ? 0.2 : 0;
+  if (!jitterFactor) return clamped;
+  const deviation = clamped * jitterFactor;
+  const offset = (Math.random() * 2 - 1) * deviation;
+  return Math.max(0, clamped + offset);
+}
+function sleep(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+async function withRetry(config, fn) {
+  const retries = Math.max(0, Math.trunc(config.retries));
+  const shouldRetry = config.shouldRetry ?? defaultShouldRetry;
+  const resolvedConfig = {
+    baseDelayMs: config.baseDelayMs ?? 100,
+    maxDelayMs: config.maxDelayMs ?? 1e4,
+    backoff: config.backoff ?? "exponential",
+    jitter: config.jitter ?? false
   };
-  const createSelectChain = (columns, options) => {
-    const chain = {};
-    const filterMethods2 = createFilterMethods(state, addCondition, chain);
-    Object.assign(chain, filterMethods2, {
-      async single(cols, opts) {
-        const r = await runSelect(cols ?? columns, opts ?? options);
-        return toSingleResult(r);
-      },
-      maybeSingle(cols, opts) {
-        return chain.single(cols, opts);
-      },
-      then(onfulfilled, onrejected) {
-        return runSelect(columns, options).then(onfulfilled, onrejected);
-      },
-      catch(onrejected) {
-        return runSelect(columns, options).catch(onrejected);
-      },
-      finally(onfinally) {
-        return runSelect(columns, options).finally(onfinally);
+  for (let attempts = 0; attempts <= retries; attempts += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempts >= retries) {
+        throw error;
       }
-    });
-    return chain;
-  };
-  Object.assign(builder, filterMethods, {
-    reset() {
-      state.conditions = [];
-      state.limit = void 0;
-      state.offset = void 0;
-      state.order = void 0;
-      state.currentPage = void 0;
-      state.pageSize = void 0;
-      state.totalPages = void 0;
-      return builder;
+      const currentAttempt = attempts + 1;
+      const retry = await shouldRetry(error, currentAttempt);
+      if (!retry) {
+        throw error;
+      }
+      const delay = computeDelayMs(currentAttempt, error, resolvedConfig);
+      await sleep(delay);
+    }
+  }
+  throw new Error("withRetry reached an unexpected state");
+}
+
+// src/db/module.ts
+function createDbModule(input) {
+  const db = {
+    from(table) {
+      return input.from(table);
     },
-    select(columns = DEFAULT_COLUMNS, options) {
-      return createSelectChain(columns, options);
+    select(table, columns, options) {
+      return input.from(table).select(columns, options);
     },
-    insert(values, options) {
-      if (Array.isArray(values)) {
-        const executeInsertMany = async (columns, selectOptions) => {
-          const mergedOptions = mergeOptions(options, selectOptions);
-          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-          const payload = {
-            table_name: resolvedTableName,
-            insert_body: asAthenaJsonObjectArray(values)
-          };
-          if (columns) payload.columns = columns;
-          if (mergedOptions?.count) payload.count = mergedOptions.count;
-          if (mergedOptions?.head) payload.head = mergedOptions.head;
-          if (mergedOptions?.defaultToNull !== void 0) {
-            payload.default_to_null = mergedOptions.defaultToNull;
-          }
-          const response = await client.insertGateway(payload, mergedOptions);
-          return formatResult(response);
-        };
-        return createMutationQuery(executeInsertMany);
-      }
-      const executeInsertOne = async (columns, selectOptions) => {
-        const mergedOptions = mergeOptions(options, selectOptions);
-        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-        const payload = {
-          table_name: resolvedTableName,
-          insert_body: asAthenaJsonObject(values)
-        };
-        if (columns) payload.columns = columns;
-        if (mergedOptions?.count) payload.count = mergedOptions.count;
-        if (mergedOptions?.head) payload.head = mergedOptions.head;
-        if (mergedOptions?.defaultToNull !== void 0) {
-          payload.default_to_null = mergedOptions.defaultToNull;
-        }
-        const response = await client.insertGateway(payload, mergedOptions);
-        return formatResult(response);
-      };
-      return createMutationQuery(executeInsertOne);
+    insert(table, values, options) {
+      return Array.isArray(values) ? input.from(table).insert(values, options) : input.from(table).insert(values, options);
     },
-    upsert(values, options) {
-      if (Array.isArray(values)) {
-        const executeUpsertMany = async (columns, selectOptions) => {
-          const mergedOptions = mergeOptions(options, selectOptions);
-          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-          const payload = {
-            table_name: resolvedTableName,
-            insert_body: asAthenaJsonObjectArray(values),
-            update_body: options?.updateBody ? asAthenaJsonObject(options.updateBody) : void 0
-          };
-          if (columns) payload.columns = columns;
-          if (options?.onConflict) payload.on_conflict = options.onConflict;
-          if (mergedOptions?.count) payload.count = mergedOptions.count;
-          if (mergedOptions?.head) payload.head = mergedOptions.head;
-          if (mergedOptions?.defaultToNull !== void 0) {
-            payload.default_to_null = mergedOptions.defaultToNull;
-          }
-          const response = await client.insertGateway(payload, mergedOptions);
-          return formatResult(response);
-        };
-        return createMutationQuery(executeUpsertMany);
-      }
-      const executeUpsertOne = async (columns, selectOptions) => {
-        const mergedOptions = mergeOptions(options, selectOptions);
-        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-        const payload = {
-          table_name: resolvedTableName,
-          insert_body: asAthenaJsonObject(values),
-          update_body: options?.updateBody ? asAthenaJsonObject(options.updateBody) : void 0
-        };
-        if (columns) payload.columns = columns;
-        if (options?.onConflict) payload.on_conflict = options.onConflict;
-        if (mergedOptions?.count) payload.count = mergedOptions.count;
-        if (mergedOptions?.head) payload.head = mergedOptions.head;
-        if (mergedOptions?.defaultToNull !== void 0) {
-          payload.default_to_null = mergedOptions.defaultToNull;
-        }
-        const response = await client.insertGateway(payload, mergedOptions);
-        return formatResult(response);
-      };
-      return createMutationQuery(executeUpsertOne);
+    upsert(table, values, options) {
+      return Array.isArray(values) ? input.from(table).upsert(values, options) : input.from(table).upsert(values, options);
     },
-    update(values, options) {
-      const executeUpdate = async (columns, selectOptions) => {
-        const filters = state.conditions.length ? [...state.conditions] : void 0;
-        const mergedOptions = mergeOptions(options, selectOptions);
-        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-        const payload = {
-          table_name: resolvedTableName,
-          set: asAthenaJsonObject(values),
-          conditions: filters,
-          strip_nulls: mergedOptions?.stripNulls ?? true
-        };
-        if (state.order) payload.sort_by = state.order;
-        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
-        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
-        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
-        if (columns) payload.columns = columns;
-        const response = await client.updateGateway(payload, mergedOptions);
-        return formatResult(response);
-      };
-      const mutation = createMutationQuery(executeUpdate, null);
-      const updateChain = {};
-      const filterMethods2 = createFilterMethods(state, addCondition, updateChain);
-      Object.assign(updateChain, filterMethods2, mutation);
-      return updateChain;
+    update(table, values, options) {
+      return input.from(table).update(values, options);
     },
-    delete(options) {
-      const filters = state.conditions.length ? [...state.conditions] : void 0;
-      const resourceId = options?.resourceId ?? getResourceId(state);
-      if (!resourceId && !filters?.length) {
-        throw new Error('delete requires a resource_id either via eq("resource_id", ...) or options.resourceId');
-      }
-      const executeDelete = async (columns, selectOptions) => {
-        const mergedOptions = mergeOptions(options, selectOptions);
-        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-        const payload = {
-          table_name: resolvedTableName,
-          resource_id: resourceId,
-          conditions: filters
-        };
-        if (state.order) payload.sort_by = state.order;
-        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
-        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
-        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
-        if (columns) payload.columns = columns;
-        const response = await client.deleteGateway(payload, mergedOptions);
-        return formatResult(response);
-      };
-      return createMutationQuery(executeDelete, null);
+    delete(table, options) {
+      return input.from(table).delete(options);
     },
-    async single(columns, options) {
-      const response = await builder.select(columns, options);
-      return toSingleResult(response);
+    rpc(fn, args, options) {
+      return input.rpc(fn, args, options);
     },
-    async maybeSingle(columns, options) {
-      return builder.single(columns, options);
+    query(query, options) {
+      return input.query(query, options);
     }
+  };
+  return db;
+}
+
+// src/client.ts
+var DEFAULT_COLUMNS = "*";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
+var ATHENA_NORMALIZED_ERROR_KEY = "__athenaNormalizedError";
+function formatResult(response) {
+  const result = {
+    data: response.data ?? null,
+    error: response.error ?? null,
+    errorDetails: response.errorDetails ?? null,
+    status: response.status,
+    raw: response.raw
+  };
+  if (response.count !== void 0) {
+    result.count = response.count;
+  }
+  return result;
+}
+function attachNormalizedError(result, normalizedError) {
+  Object.defineProperty(result, ATHENA_NORMALIZED_ERROR_KEY, {
+    value: normalizedError,
+    enumerable: false,
+    configurable: true,
+    writable: false
   });
-  return builder;
 }
-function createQueryBuilder(client) {
-  return async function query(query, options) {
-    const normalizedQuery = query.trim();
-    if (!normalizedQuery) {
-      throw new Error("query requires a non-empty string");
+function createResultFormatter(experimental) {
+  if (!experimental?.enableErrorNormalization) {
+    return formatResult;
+  }
+  return (response, context) => {
+    const result = formatResult(response);
+    if (result.error == null) {
+      return result;
     }
-    const response = await client.queryGateway({ query: normalizedQuery }, options);
-    return formatResult(response);
+    const normalizedError = normalizeAthenaError(result, context);
+    attachNormalizedError(result, normalizedError);
+    return result;
   };
 }
-function createClientFromConfig(config) {
-  const gateway = createAthenaGatewayClient({
-    baseUrl: config.baseUrl,
-    apiKey: config.apiKey,
-    client: config.client,
-    backend: config.backend,
-    headers: config.headers
-  });
+function toSingleResult(response) {
+  const payload = response.data;
+  const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
   return {
-    from(table) {
-      return createTableBuilder(table, gateway);
-    },
-    rpc(fn, args, options) {
-      const normalizedFn = fn.trim();
-      if (!normalizedFn) {
-        throw new Error("rpc requires a function name");
-      }
-      return createRpcBuilder(
-        normalizedFn,
-        args,
-        options,
-        gateway
-      );
-    },
-    query: createQueryBuilder(gateway)
+    ...response,
+    data: singleData
   };
 }
-var DEFAULT_BACKEND = { type: "athena" };
-function toBackendConfig(b) {
-  if (!b) return DEFAULT_BACKEND;
-  return typeof b === "string" ? { type: b } : b;
+function mergeOptions(...options) {
+  return options.reduce((acc, next) => {
+    if (!next) return acc;
+    return { ...acc, ...next };
+  }, void 0);
 }
-var AthenaClientBuilderImpl = class {
-  baseUrl;
-  apiKey;
-  backendConfig = DEFAULT_BACKEND;
-  clientName;
-  defaultHeaders;
-  isHealthTrackingEnabled = false;
-  url(url) {
-    this.baseUrl = url;
-    return this;
-  }
-  key(apiKey) {
-    this.apiKey = apiKey;
-    return this;
-  }
-  backend(backend) {
-    this.backendConfig = toBackendConfig(backend);
-    return this;
-  }
-  client(clientName) {
-    this.clientName = clientName;
-    return this;
-  }
-  headers(headers) {
-    this.defaultHeaders = headers;
-    return this;
-  }
-  healthTracking(enabled) {
-    this.isHealthTrackingEnabled = enabled;
-    return this;
-  }
-  build() {
-    if (!this.baseUrl || !this.apiKey) {
-      throw new Error("AthenaClient requires url and key; call .url() and .key() before .build()");
+function asAthenaJsonObject(value) {
+  return value;
+}
+function asAthenaJsonObjectArray(values) {
+  return values;
+}
+function createMutationQuery(executor, defaultColumns = DEFAULT_COLUMNS) {
+  let selectedColumns = defaultColumns === null ? void 0 : defaultColumns;
+  let selectedOptions;
+  let promise = null;
+  const run = (columns, options) => {
+    const payloadColumns = columns ?? selectedColumns;
+    const payloadOptions = options ?? selectedOptions;
+    if (!promise) {
+      promise = executor(payloadColumns, payloadOptions);
     }
-    return createClientFromConfig({
-      baseUrl: this.baseUrl,
-      apiKey: this.apiKey,
-      client: this.clientName,
-      backend: this.backendConfig,
-      headers: this.defaultHeaders,
-      healthTracking: this.isHealthTrackingEnabled
-    });
-  }
-};
-var AthenaClient = class _AthenaClient {
-  /** Create a fluent builder for a strongly-typed Athena SDK client. */
-  static builder() {
-    return new AthenaClientBuilderImpl();
-  }
-  /** Build a client from process environment variables. */
-  static fromEnvironment() {
-    const url = process.env.ATHENA_URL ?? process.env.ATHENA_GATEWAY_URL;
-    const key = process.env.ATHENA_API_KEY ?? process.env.ATHENA_GATEWAY_API_KEY;
-    if (!url || !key) {
-      throw new Error(
-        "ATHENA_URL and ATHENA_API_KEY (or ATHENA_GATEWAY_URL and ATHENA_GATEWAY_API_KEY) are required"
-      );
+    return promise;
+  };
+  const mutationQuery = {
+    select(columns = selectedColumns, options) {
+      selectedColumns = columns;
+      selectedOptions = options ?? selectedOptions;
+      return run(columns, options);
+    },
+    returning(columns = selectedColumns, options) {
+      return mutationQuery.select(columns, options);
+    },
+    single(columns = selectedColumns, options) {
+      selectedColumns = columns;
+      selectedOptions = options ?? selectedOptions;
+      return run(columns, options).then(toSingleResult);
+    },
+    maybeSingle(columns = selectedColumns, options) {
+      return mutationQuery.single(columns, options);
+    },
+    then(onfulfilled, onrejected) {
+      return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
+    },
+    catch(onrejected) {
+      return run(selectedColumns, selectedOptions).catch(onrejected);
+    },
+    finally(onfinally) {
+      return run(selectedColumns, selectedOptions).finally(onfinally);
     }
-    return _AthenaClient.builder().url(url).key(key).build();
-  }
-};
-function createClient(url, apiKey, options) {
-  const b = AthenaClient.builder().url(url).key(apiKey).backend(toBackendConfig(options?.backend));
-  if (options?.client) b.client(options.client);
-  if (options?.headers && Object.keys(options.headers).length > 0) b.headers(options.headers);
-  return b.build();
+  };
+  return mutationQuery;
 }
-
-// src/gateway/types.ts
-var Backend = {
-  Athena: { type: "athena" },
-  Postgrest: { type: "postgrest" },
-  PostgreSQL: { type: "postgresql" },
-  ScyllaDB: { type: "scylladb" }
-};
-
-// src/auxiliaries.ts
-var AthenaErrorKind = {
-  UniqueViolation: "unique_violation",
-  NotFound: "not_found",
-  Validation: "validation",
-  Auth: "auth",
-  RateLimit: "rate_limit",
-  Transient: "transient",
-  Unknown: "unknown"
-};
-var AthenaErrorCode = {
-  UniqueViolation: "UNIQUE_VIOLATION",
-  NotFound: "NOT_FOUND",
-  ValidationFailed: "VALIDATION_FAILED",
-  AuthUnauthorized: "AUTH_UNAUTHORIZED",
-  AuthForbidden: "AUTH_FORBIDDEN",
-  RateLimited: "RATE_LIMITED",
-  NetworkUnavailable: "NETWORK_UNAVAILABLE",
-  TransientFailure: "TRANSIENT_FAILURE",
-  HttpFailure: "HTTP_FAILURE",
-  Unknown: "UNKNOWN"
-};
-var AthenaErrorCategory = {
-  Transport: "transport",
-  Client: "client",
-  Server: "server",
-  Database: "database",
-  Unknown: "unknown"
-};
-var AthenaError = class extends Error {
-  code;
-  kind;
-  category;
-  status;
-  retryable;
-  requestId;
-  context;
-  raw;
-  constructor(input) {
-    super(input.message);
-    this.name = "AthenaError";
-    this.code = input.code;
-    this.kind = input.kind;
-    this.category = input.category;
-    this.status = input.status;
-    this.retryable = input.retryable ?? false;
-    this.requestId = input.requestId;
-    this.context = input.context;
-    this.raw = input.raw;
+function getResourceId(state) {
+  const candidate = state.conditions.find(
+    (condition) => condition.operator === "eq" && (condition.column === "resource_id" || condition.column === "id")
+  );
+  return candidate?.value?.toString();
+}
+function stringifyFilterValue(value) {
+  if (Array.isArray(value)) {
+    return value.join(",");
   }
-};
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  return String(value);
 }
-function safeStringify(value) {
-  try {
-    const serialized = JSON.stringify(value);
-    return serialized ?? String(value);
-  } catch {
-    return "[unserializable]";
+function isUuidString(value) {
+  return UUID_PATTERN.test(value.trim());
+}
+function isUuidIdentifierColumn(column) {
+  return column === "id" || /(?:^|_)uuid(?:_|$)/i.test(column) || /_id$/i.test(column);
+}
+function shouldUseUuidTextComparison(column, value) {
+  return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
+}
+function normalizeCast(cast) {
+  const normalized = cast.trim().toLowerCase();
+  if (!SAFE_CAST_PATTERN.test(normalized)) {
+    throw new Error(`Invalid cast type "${cast}"`);
   }
+  return normalized;
 }
-function contextHint(context) {
-  if (!context?.identity) return void 0;
-  const identity = typeof context.identity === "string" ? context.identity : safeStringify(context.identity);
-  return `Identity: ${identity}`;
+function escapeSqlStringLiteral(value) {
+  return value.replace(/'/g, "''");
 }
-function isAthenaResultLike(value) {
-  return isRecord2(value) && "status" in value && "error" in value && "data" in value && typeof value.status === "number";
+function toSqlLiteral(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  return `'${escapeSqlStringLiteral(value)}'`;
 }
-function operationFromDetails(details) {
-  if (!details?.endpoint) return void 0;
-  if (details.endpoint === "/gateway/fetch" || details.endpoint === "/gateway/query") return "select";
-  if (details.endpoint === "/gateway/insert") return "insert";
-  if (details.endpoint === "/gateway/update") return "update";
-  if (details.endpoint === "/gateway/delete") return "delete";
-  if (details.endpoint === "/gateway/rpc" || details.endpoint.startsWith("/rpc/")) return "rpc";
-  return void 0;
+function withCast(expression, cast) {
+  if (!cast) return expression;
+  return `${expression}::${normalizeCast(cast)}`;
 }
-function matchRegex(input, patterns) {
-  for (const pattern of patterns) {
-    const match = pattern.exec(input);
-    if (match?.[1]) return match[1];
+function buildSelectColumnsClause(columns) {
+  if (Array.isArray(columns)) {
+    return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
   }
-  return void 0;
-}
-function extractConstraint(message) {
-  return matchRegex(message, [
-    /unique constraint\s+["'`]([^"'`]+)["'`]/i,
-    /constraint\s+["'`]([^"'`]+)["'`]/i
-  ]);
+  return quoteSelectColumnsExpression(columns);
 }
-function extractTable(message) {
-  return matchRegex(message, [
-    /(?:table|relation)\s+["'`]([^"'`]+)["'`]/i,
-    /on\s+table\s+([a-zA-Z0-9_.]+)/i
-  ]);
+function resolveTableNameForCall(tableName, schema) {
+  if (!schema) return tableName;
+  const normalizedSchema = schema.trim();
+  if (!normalizedSchema) {
+    throw new Error("schema option must be a non-empty string");
+  }
+  if (tableName.includes(".")) {
+    if (tableName.startsWith(`${normalizedSchema}.`)) {
+      return tableName;
+    }
+    throw new Error(
+      `schema option "${normalizedSchema}" conflicts with schema-qualified table "${tableName}"`
+    );
+  }
+  return `${normalizedSchema}.${tableName}`;
 }
-function classifyKind(status, code, message) {
-  const lower = message.toLowerCase();
-  const hasUniquePattern = lower.includes("unique constraint") || lower.includes("duplicate key") || lower.includes("already exists") || lower.includes("duplicate");
-  const hasNotFoundPattern = lower.includes("not found") || lower.includes("no rows");
-  const hasValidationPattern = lower.includes("validation") || lower.includes("invalid") || lower.includes("malformed");
-  const hasAuthPattern = lower.includes("unauthorized") || lower.includes("forbidden") || lower.includes("auth");
-  const hasRateLimitPattern = lower.includes("rate limit") || lower.includes("too many requests");
-  const hasTransientPattern = lower.includes("timeout") || lower.includes("temporar") || lower.includes("connection reset") || lower.includes("socket") || lower.includes("deadlock");
-  if (status === 409 || hasUniquePattern) return "unique_violation";
-  if (status === 404 || hasNotFoundPattern) return "not_found";
-  if (status === 401 || status === 403 || hasAuthPattern) return "auth";
-  if (status === 429 || hasRateLimitPattern) return "rate_limit";
-  if (status === 400 || status === 422 || hasValidationPattern) return "validation";
-  if (code === "NETWORK_ERROR" || status === 0 || status !== void 0 && status >= 500 || hasTransientPattern) {
-    return "transient";
+function conditionToSqlClause(condition) {
+  if (!condition.column) return null;
+  const column = withCast(quoteQualifiedIdentifier(condition.column), condition.column_cast);
+  const value = condition.value;
+  const sqlOperator = {
+    eq: "=",
+    neq: "!=",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<=",
+    like: "LIKE",
+    ilike: "ILIKE"
+  };
+  switch (condition.operator) {
+    case "eq":
+    case "neq":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "like":
+    case "ilike": {
+      if (Array.isArray(value) || value === void 0) return null;
+      const rhs = withCast(toSqlLiteral(value), condition.value_cast);
+      return `${column} ${sqlOperator[condition.operator]} ${rhs}`;
+    }
+    case "is": {
+      if (value === null) return `${column} IS NULL`;
+      if (value === true) return `${column} IS TRUE`;
+      if (value === false) return `${column} IS FALSE`;
+      return null;
+    }
+    case "in": {
+      if (!Array.isArray(value)) return null;
+      if (value.length === 0) return "FALSE";
+      const values = value.map((item) => withCast(toSqlLiteral(item), condition.value_cast));
+      return `${column} IN (${values.join(", ")})`;
+    }
+    default:
+      return null;
   }
-  return "unknown";
 }
-function toAthenaErrorCode(kind, status, gatewayCode) {
-  if (gatewayCode === "NETWORK_ERROR" || kind === "transient" && status === 0) {
-    return AthenaErrorCode.NetworkUnavailable;
+function buildTypedSelectQuery(input) {
+  const whereClauses = [];
+  for (const condition of input.conditions) {
+    const clause = conditionToSqlClause(condition);
+    if (!clause) return null;
+    whereClauses.push(clause);
   }
-  switch (kind) {
-    case "unique_violation":
-      return AthenaErrorCode.UniqueViolation;
-    case "not_found":
-      return AthenaErrorCode.NotFound;
-    case "validation":
-      return AthenaErrorCode.ValidationFailed;
-    case "rate_limit":
-      return AthenaErrorCode.RateLimited;
-    case "auth":
-      if (status === 403) {
-        return AthenaErrorCode.AuthForbidden;
-      }
-      return AthenaErrorCode.AuthUnauthorized;
-    case "transient":
-      return status !== void 0 && status >= 500 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.TransientFailure;
-    case "unknown":
-    default:
-      return status !== void 0 && status >= 400 ? AthenaErrorCode.HttpFailure : AthenaErrorCode.Unknown;
+  let limit = input.limit;
+  let offset = input.offset;
+  if (limit === void 0 && input.pageSize !== void 0) {
+    limit = input.pageSize;
+  }
+  if (offset === void 0 && input.pageSize !== void 0 && input.currentPage !== void 0 && input.currentPage > 0) {
+    offset = (input.currentPage - 1) * input.pageSize;
+  }
+  const sqlParts = [
+    `SELECT ${buildSelectColumnsClause(input.columns)} FROM ${quoteQualifiedIdentifier(input.tableName)}`
+  ];
+  if (whereClauses.length > 0) {
+    sqlParts.push(`WHERE ${whereClauses.join(" AND ")}`);
+  }
+  if (input.order?.field) {
+    const direction = input.order.direction === "descending" ? "DESC" : "ASC";
+    sqlParts.push(`ORDER BY ${quoteQualifiedIdentifier(input.order.field)} ${direction}`);
+  }
+  if (limit !== void 0) {
+    sqlParts.push(`LIMIT ${Math.max(0, Math.trunc(limit))}`);
   }
+  if (offset !== void 0) {
+    sqlParts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
+  }
+  return `${sqlParts.join(" ")};`;
+}
+function createFilterMethods(state, addCondition, self) {
+  return {
+    eq(column, value) {
+      const columnName = String(column);
+      if (shouldUseUuidTextComparison(columnName, value)) {
+        addCondition("eq", columnName, value, { columnCast: "text" });
+      } else {
+        addCondition("eq", columnName, value);
+      }
+      return self;
+    },
+    eqCast(column, value, cast) {
+      addCondition("eq", String(column), value, { valueCast: cast });
+      return self;
+    },
+    eqUuid(column, value) {
+      addCondition("eq", String(column), value, { valueCast: "uuid" });
+      return self;
+    },
+    match(filters) {
+      Object.entries(filters).forEach(([column, value]) => {
+        if (value === void 0) {
+          return;
+        }
+        if (shouldUseUuidTextComparison(column, value)) {
+          addCondition("eq", column, value, { columnCast: "text" });
+        } else {
+          addCondition("eq", column, value);
+        }
+      });
+      return self;
+    },
+    range(from, to) {
+      state.offset = from;
+      state.limit = to - from + 1;
+      return self;
+    },
+    limit(count) {
+      state.limit = count;
+      return self;
+    },
+    offset(count) {
+      state.offset = count;
+      return self;
+    },
+    currentPage(value) {
+      state.currentPage = value;
+      return self;
+    },
+    pageSize(value) {
+      state.pageSize = value;
+      return self;
+    },
+    totalPages(value) {
+      state.totalPages = value;
+      return self;
+    },
+    order(column, options) {
+      state.order = {
+        field: String(column),
+        direction: options?.ascending === false ? "descending" : "ascending"
+      };
+      return self;
+    },
+    gt(column, value) {
+      addCondition("gt", String(column), value);
+      return self;
+    },
+    gte(column, value) {
+      addCondition("gte", String(column), value);
+      return self;
+    },
+    lt(column, value) {
+      addCondition("lt", String(column), value);
+      return self;
+    },
+    lte(column, value) {
+      addCondition("lte", String(column), value);
+      return self;
+    },
+    neq(column, value) {
+      addCondition("neq", String(column), value);
+      return self;
+    },
+    like(column, value) {
+      addCondition("like", String(column), value);
+      return self;
+    },
+    ilike(column, value) {
+      addCondition("ilike", String(column), value);
+      return self;
+    },
+    is(column, value) {
+      addCondition("is", String(column), value);
+      return self;
+    },
+    in(column, values) {
+      addCondition("in", String(column), values);
+      return self;
+    },
+    contains(column, values) {
+      addCondition("contains", String(column), values);
+      return self;
+    },
+    containedBy(column, values) {
+      addCondition("containedBy", String(column), values);
+      return self;
+    },
+    not(columnOrExpression, operator, value) {
+      const expression = String(columnOrExpression);
+      if (operator != null && value !== void 0) {
+        addCondition("not", void 0, `${expression}.${operator}.${stringifyFilterValue(value)}`);
+      } else {
+        addCondition("not", void 0, expression);
+      }
+      return self;
+    },
+    or(expression) {
+      addCondition("or", void 0, expression);
+      return self;
+    }
+  };
 }
-function toAthenaErrorCategory(kind, status) {
-  if (kind === "transient" && (status === 0 || status === void 0)) {
-    return AthenaErrorCategory.Transport;
-  }
-  if (kind === "unique_violation") return AthenaErrorCategory.Database;
-  if (kind === "validation" || kind === "auth" || kind === "not_found") return AthenaErrorCategory.Client;
-  if (kind === "rate_limit" || kind === "transient") return AthenaErrorCategory.Server;
-  return AthenaErrorCategory.Unknown;
+function toRpcSelect(columns) {
+  if (!columns) return void 0;
+  return Array.isArray(columns) ? columns.join(",") : columns;
 }
-function isRetryable(kind, status) {
-  if (kind === "rate_limit" || kind === "transient") return true;
-  return status !== void 0 && status >= 500;
+function createRpcFilterMethods(filters, self) {
+  const addFilter = (operator, column, value) => {
+    filters.push({ column, operator, value });
+  };
+  return {
+    eq(column, value) {
+      addFilter("eq", column, value);
+      return self;
+    },
+    neq(column, value) {
+      addFilter("neq", column, value);
+      return self;
+    },
+    gt(column, value) {
+      addFilter("gt", column, value);
+      return self;
+    },
+    gte(column, value) {
+      addFilter("gte", column, value);
+      return self;
+    },
+    lt(column, value) {
+      addFilter("lt", column, value);
+      return self;
+    },
+    lte(column, value) {
+      addFilter("lte", column, value);
+      return self;
+    },
+    like(column, value) {
+      addFilter("like", column, value);
+      return self;
+    },
+    ilike(column, value) {
+      addFilter("ilike", column, value);
+      return self;
+    },
+    is(column, value) {
+      addFilter("is", column, value);
+      return self;
+    },
+    in(column, values) {
+      addFilter("in", column, values);
+      return self;
+    }
+  };
 }
-function toGatewayCode(kind, status) {
-  if (kind === "transient" && (status === 0 || status === void 0)) return "NETWORK_ERROR";
-  if (kind === "validation") return "INVALID_JSON";
-  if (status !== void 0 && status >= 400) return "HTTP_ERROR";
-  return "UNKNOWN_ERROR";
+function createRpcBuilder(functionName, args, baseOptions, client, formatGatewayResult) {
+  const state = {
+    filters: []
+  };
+  let selectedColumns;
+  let selectedOptions;
+  let promise = null;
+  const executeRpc = async (columns, options) => {
+    const mergedOptions = mergeOptions(baseOptions, options);
+    const payload = {
+      function: functionName,
+      args,
+      schema: mergedOptions?.schema,
+      select: toRpcSelect(columns),
+      filters: state.filters.length ? [...state.filters] : void 0,
+      count: mergedOptions?.count,
+      head: mergedOptions?.head,
+      limit: state.limit,
+      offset: state.offset,
+      order: state.order
+    };
+    const response = await client.rpcGateway(payload, mergedOptions);
+    return formatGatewayResult(response, { operation: "rpc" });
+  };
+  const run = (columns, options) => {
+    const payloadColumns = columns ?? selectedColumns;
+    const payloadOptions = options ?? selectedOptions;
+    if (!promise) {
+      promise = executeRpc(payloadColumns, payloadOptions);
+    }
+    return promise;
+  };
+  const builder = {};
+  const filterMethods = createRpcFilterMethods(state.filters, builder);
+  Object.assign(builder, filterMethods, {
+    select(columns = selectedColumns, options) {
+      selectedColumns = columns;
+      selectedOptions = options ?? selectedOptions;
+      return run(columns, options);
+    },
+    async single(columns, options) {
+      const result = await run(columns, options);
+      return toSingleResult(result);
+    },
+    maybeSingle(columns, options) {
+      return builder.single(columns, options);
+    },
+    order(column, options) {
+      state.order = { column, ascending: options?.ascending ?? true };
+      return builder;
+    },
+    limit(count) {
+      state.limit = count;
+      return builder;
+    },
+    offset(count) {
+      state.offset = count;
+      return builder;
+    },
+    range(from, to) {
+      state.offset = from;
+      state.limit = to - from + 1;
+      return builder;
+    },
+    then(onfulfilled, onrejected) {
+      return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
+    },
+    catch(onrejected) {
+      return run(selectedColumns, selectedOptions).catch(onrejected);
+    },
+    finally(onfinally) {
+      return run(selectedColumns, selectedOptions).finally(onfinally);
+    }
+  });
+  return builder;
 }
-function toAthenaGatewayError(source, fallbackMessage, context) {
-  if (isAthenaGatewayError(source)) {
-    return source;
-  }
-  if (isAthenaResultLike(source) && source.errorDetails) {
-    return new AthenaGatewayError({
-      code: source.errorDetails.code,
-      message: source.error ?? source.errorDetails.message,
-      status: source.status,
-      endpoint: source.errorDetails.endpoint,
-      method: source.errorDetails.method,
-      requestId: source.errorDetails.requestId,
-      hint: source.errorDetails.hint,
-      cause: source.errorDetails.cause
+function createTableBuilder(tableName, client, formatGatewayResult) {
+  const state = {
+    conditions: []
+  };
+  const addCondition = (operator, column, value, hints) => {
+    const condition = { operator };
+    if (column) {
+      condition.column = column;
+      if (operator === "eq") {
+        condition.eq_column = column;
+      }
+    }
+    if (value !== void 0) {
+      condition.value = value;
+      if (operator === "eq") {
+        condition.eq_value = value;
+      }
+    }
+    if (hints?.valueCast) {
+      condition.value_cast = hints.valueCast;
+      if (operator === "eq") {
+        condition.eq_value_cast = hints.valueCast;
+      }
+    }
+    if (hints?.columnCast) {
+      condition.column_cast = hints.columnCast;
+      if (operator === "eq") {
+        condition.eq_column_cast = hints.columnCast;
+      }
+    }
+    state.conditions.push(condition);
+  };
+  const builder = {};
+  const filterMethods = createFilterMethods(
+    state,
+    addCondition,
+    builder
+  );
+  const runSelect = async (columns = DEFAULT_COLUMNS, options) => {
+    const resolvedTableName = resolveTableNameForCall(tableName, options?.schema);
+    const conditions = state.conditions.length ? state.conditions.map((condition) => ({ ...condition })) : void 0;
+    const hasTypedEqualityComparison = conditions?.some(
+      (condition) => condition.operator === "eq" && (condition.value_cast !== void 0 || condition.column_cast !== void 0)
+    ) ?? false;
+    if (hasTypedEqualityComparison && !options?.head && !options?.count && conditions) {
+      const query = buildTypedSelectQuery({
+        tableName: resolvedTableName,
+        columns,
+        conditions,
+        limit: state.limit,
+        offset: state.offset,
+        currentPage: state.currentPage,
+        pageSize: state.pageSize,
+        order: state.order
+      });
+      if (query) {
+        const queryResponse = await client.queryGateway({ query }, options);
+        return formatGatewayResult(queryResponse, { table: resolvedTableName, operation: "select" });
+      }
+    }
+    const payload = {
+      table_name: resolvedTableName,
+      columns,
+      conditions,
+      limit: state.limit,
+      offset: state.offset,
+      current_page: state.currentPage,
+      page_size: state.pageSize,
+      total_pages: state.totalPages,
+      sort_by: state.order,
+      strip_nulls: options?.stripNulls ?? true,
+      count: options?.count,
+      head: options?.head
+    };
+    const response = await client.fetchGateway(payload, options);
+    return formatGatewayResult(response, { table: resolvedTableName, operation: "select" });
+  };
+  const createSelectChain = (columns, options) => {
+    const chain = {};
+    const filterMethods2 = createFilterMethods(state, addCondition, chain);
+    Object.assign(chain, filterMethods2, {
+      async single(cols, opts) {
+        const r = await runSelect(cols ?? columns, opts ?? options);
+        return toSingleResult(r);
+      },
+      maybeSingle(cols, opts) {
+        return chain.single(cols, opts);
+      },
+      then(onfulfilled, onrejected) {
+        return runSelect(columns, options).then(onfulfilled, onrejected);
+      },
+      catch(onrejected) {
+        return runSelect(columns, options).catch(onrejected);
+      },
+      finally(onfinally) {
+        return runSelect(columns, options).finally(onfinally);
+      }
     });
-  }
-  const normalized = normalizeAthenaError(source, context);
-  const message = isAthenaResultLike(source) && source.error == null && source.errorDetails == null ? fallbackMessage : normalized.message || fallbackMessage;
-  return new AthenaGatewayError({
-    code: toGatewayCode(normalized.kind, normalized.status),
-    message,
-    status: normalized.status ?? 0,
-    hint: normalized.constraint != null ? `Constraint: ${normalized.constraint}` : contextHint(context),
-    cause: typeof normalized.raw === "string" ? normalized.raw : safeStringify(normalized.raw)
+    return chain;
+  };
+  Object.assign(builder, filterMethods, {
+    reset() {
+      state.conditions = [];
+      state.limit = void 0;
+      state.offset = void 0;
+      state.order = void 0;
+      state.currentPage = void 0;
+      state.pageSize = void 0;
+      state.totalPages = void 0;
+      return builder;
+    },
+    select(columns = DEFAULT_COLUMNS, options) {
+      return createSelectChain(columns, options);
+    },
+    insert(values, options) {
+      if (Array.isArray(values)) {
+        const executeInsertMany = async (columns, selectOptions) => {
+          const mergedOptions = mergeOptions(options, selectOptions);
+          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+          const payload = {
+            table_name: resolvedTableName,
+            insert_body: asAthenaJsonObjectArray(values)
+          };
+          if (columns) payload.columns = columns;
+          if (mergedOptions?.count) payload.count = mergedOptions.count;
+          if (mergedOptions?.head) payload.head = mergedOptions.head;
+          if (mergedOptions?.defaultToNull !== void 0) {
+            payload.default_to_null = mergedOptions.defaultToNull;
+          }
+          const response = await client.insertGateway(payload, mergedOptions);
+          return formatGatewayResult(response, { table: resolvedTableName, operation: "insert" });
+        };
+        return createMutationQuery(executeInsertMany);
+      }
+      const executeInsertOne = async (columns, selectOptions) => {
+        const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+        const payload = {
+          table_name: resolvedTableName,
+          insert_body: asAthenaJsonObject(values)
+        };
+        if (columns) payload.columns = columns;
+        if (mergedOptions?.count) payload.count = mergedOptions.count;
+        if (mergedOptions?.head) payload.head = mergedOptions.head;
+        if (mergedOptions?.defaultToNull !== void 0) {
+          payload.default_to_null = mergedOptions.defaultToNull;
+        }
+        const response = await client.insertGateway(payload, mergedOptions);
+        return formatGatewayResult(response, { table: resolvedTableName, operation: "insert" });
+      };
+      return createMutationQuery(executeInsertOne);
+    },
+    upsert(values, options) {
+      if (Array.isArray(values)) {
+        const executeUpsertMany = async (columns, selectOptions) => {
+          const mergedOptions = mergeOptions(options, selectOptions);
+          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+          const payload = {
+            table_name: resolvedTableName,
+            insert_body: asAthenaJsonObjectArray(values),
+            update_body: options?.updateBody ? asAthenaJsonObject(options.updateBody) : void 0
+          };
+          if (columns) payload.columns = columns;
+          if (options?.onConflict) payload.on_conflict = options.onConflict;
+          if (mergedOptions?.count) payload.count = mergedOptions.count;
+          if (mergedOptions?.head) payload.head = mergedOptions.head;
+          if (mergedOptions?.defaultToNull !== void 0) {
+            payload.default_to_null = mergedOptions.defaultToNull;
+          }
+          const response = await client.insertGateway(payload, mergedOptions);
+          return formatGatewayResult(response, { table: resolvedTableName, operation: "insert" });
+        };
+        return createMutationQuery(executeUpsertMany);
+      }
+      const executeUpsertOne = async (columns, selectOptions) => {
+        const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+        const payload = {
+          table_name: resolvedTableName,
+          insert_body: asAthenaJsonObject(values),
+          update_body: options?.updateBody ? asAthenaJsonObject(options.updateBody) : void 0
+        };
+        if (columns) payload.columns = columns;
+        if (options?.onConflict) payload.on_conflict = options.onConflict;
+        if (mergedOptions?.count) payload.count = mergedOptions.count;
+        if (mergedOptions?.head) payload.head = mergedOptions.head;
+        if (mergedOptions?.defaultToNull !== void 0) {
+          payload.default_to_null = mergedOptions.defaultToNull;
+        }
+        const response = await client.insertGateway(payload, mergedOptions);
+        return formatGatewayResult(response, { table: resolvedTableName, operation: "insert" });
+      };
+      return createMutationQuery(executeUpsertOne);
+    },
+    update(values, options) {
+      const executeUpdate = async (columns, selectOptions) => {
+        const filters = state.conditions.length ? [...state.conditions] : void 0;
+        const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+        const payload = {
+          table_name: resolvedTableName,
+          set: asAthenaJsonObject(values),
+          conditions: filters,
+          strip_nulls: mergedOptions?.stripNulls ?? true
+        };
+        if (state.order) payload.sort_by = state.order;
+        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
+        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
+        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
+        if (columns) payload.columns = columns;
+        const response = await client.updateGateway(payload, mergedOptions);
+        return formatGatewayResult(response, { table: resolvedTableName, operation: "update" });
+      };
+      const mutation = createMutationQuery(executeUpdate, null);
+      const updateChain = {};
+      const filterMethods2 = createFilterMethods(state, addCondition, updateChain);
+      Object.assign(updateChain, filterMethods2, mutation);
+      return updateChain;
+    },
+    delete(options) {
+      const filters = state.conditions.length ? [...state.conditions] : void 0;
+      const resourceId = options?.resourceId ?? getResourceId(state);
+      if (!resourceId && !filters?.length) {
+        throw new Error('delete requires a resource_id either via eq("resource_id", ...) or options.resourceId');
+      }
+      const executeDelete = async (columns, selectOptions) => {
+        const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+        const payload = {
+          table_name: resolvedTableName,
+          resource_id: resourceId,
+          conditions: filters
+        };
+        if (state.order) payload.sort_by = state.order;
+        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
+        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
+        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
+        if (columns) payload.columns = columns;
+        const response = await client.deleteGateway(payload, mergedOptions);
+        return formatGatewayResult(response, { table: resolvedTableName, operation: "delete" });
+      };
+      return createMutationQuery(executeDelete, null);
+    },
+    async single(columns, options) {
+      const response = await builder.select(columns, options);
+      return toSingleResult(response);
+    },
+    async maybeSingle(columns, options) {
+      return builder.single(columns, options);
+    }
   });
+  return builder;
 }
-function isOk(result) {
-  return result.error == null && result.status >= 200 && result.status < 300;
+function createQueryBuilder(client, formatGatewayResult) {
+  return async function query(query, options) {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery) {
+      throw new Error("query requires a non-empty string");
+    }
+    const response = await client.queryGateway({ query: normalizedQuery }, options);
+    return formatGatewayResult(response, { operation: "query" });
+  };
 }
-function normalizeAthenaError(resultOrError, context) {
-  if (isAthenaResultLike(resultOrError)) {
-    const details = resultOrError.errorDetails;
-    const message2 = resultOrError.error ?? details?.message ?? `Athena ${context?.operation ?? operationFromDetails(details) ?? "request"} failed`;
-    const operation = context?.operation ?? operationFromDetails(details);
-    const table = context?.table ?? extractTable(message2);
-    const constraint = extractConstraint(message2);
-    const kind2 = classifyKind(resultOrError.status, details?.code, message2);
-    const code = toAthenaErrorCode(kind2, resultOrError.status, details?.code);
-    const category = toAthenaErrorCategory(kind2, resultOrError.status);
-    return {
-      kind: kind2,
-      code,
-      category,
-      retryable: isRetryable(kind2, resultOrError.status),
-      status: resultOrError.status,
-      constraint,
-      table,
-      operation,
-      message: message2,
-      raw: resultOrError.raw
-    };
-  }
-  if (isAthenaGatewayError(resultOrError)) {
-    const details = resultOrError.toDetails();
-    const operation = context?.operation ?? operationFromDetails(details);
-    const table = context?.table ?? extractTable(resultOrError.message);
-    const constraint = extractConstraint(resultOrError.message);
-    const kind2 = classifyKind(resultOrError.status, resultOrError.code, resultOrError.message);
-    const code = toAthenaErrorCode(kind2, resultOrError.status, resultOrError.code);
-    const category = toAthenaErrorCategory(kind2, resultOrError.status);
-    return {
-      kind: kind2,
-      code,
-      category,
-      retryable: isRetryable(kind2, resultOrError.status),
-      status: resultOrError.status,
-      constraint,
-      table,
-      operation,
-      message: resultOrError.message,
-      raw: resultOrError
-    };
-  }
-  if (resultOrError instanceof Error) {
-    const maybeStatus = isRecord2(resultOrError) && typeof resultOrError.status === "number" ? resultOrError.status : void 0;
-    const kind2 = classifyKind(maybeStatus, void 0, resultOrError.message);
-    return {
-      kind: kind2,
-      code: toAthenaErrorCode(kind2, maybeStatus),
-      category: toAthenaErrorCategory(kind2, maybeStatus),
-      retryable: isRetryable(kind2, maybeStatus),
-      status: maybeStatus,
-      constraint: extractConstraint(resultOrError.message),
-      table: context?.table ?? extractTable(resultOrError.message),
-      operation: context?.operation,
-      message: resultOrError.message,
-      raw: resultOrError
-    };
-  }
-  const message = typeof resultOrError === "string" ? resultOrError : "Unknown Athena error";
-  const kind = classifyKind(void 0, void 0, message);
+function createClientFromConfig(config) {
+  const gateway = createAthenaGatewayClient({
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    client: config.client,
+    backend: config.backend,
+    headers: config.headers
+  });
+  const formatGatewayResult = createResultFormatter(config.experimental);
+  const auth = createAuthClient(config.auth);
+  const from = (table) => createTableBuilder(table, gateway, formatGatewayResult);
+  const rpc = (fn, args, options) => {
+    const normalizedFn = fn.trim();
+    if (!normalizedFn) {
+      throw new Error("rpc requires a function name");
+    }
+    return createRpcBuilder(
+      normalizedFn,
+      args,
+      options,
+      gateway,
+      formatGatewayResult
+    );
+  };
+  const query = createQueryBuilder(gateway, formatGatewayResult);
+  const db = createDbModule({ from, rpc, query });
   return {
-    kind,
-    code: toAthenaErrorCode(kind, void 0),
-    category: toAthenaErrorCategory(kind, void 0),
-    retryable: isRetryable(kind, void 0),
-    status: void 0,
-    constraint: extractConstraint(message),
-    table: context?.table ?? extractTable(message),
-    operation: context?.operation,
-    message,
-    raw: resultOrError
+    from,
+    db,
+    rpc,
+    query,
+    auth: auth.auth
   };
 }
-function unwrapRows(result, options) {
-  if (!isOk(result)) {
-    throw toAthenaGatewayError(result, "Athena request failed", options?.context);
-  }
-  if (result.data == null) return [];
-  return Array.isArray(result.data) ? result.data : [result.data];
+var DEFAULT_BACKEND = { type: "athena" };
+function toBackendConfig(b) {
+  if (!b) return DEFAULT_BACKEND;
+  return typeof b === "string" ? { type: b } : b;
 }
-function unwrap(result, options) {
-  if (!isOk(result)) {
-    throw toAthenaGatewayError(result, "Athena request failed", options?.context);
+var AthenaClientBuilderImpl = class {
+  baseUrl;
+  apiKey;
+  backendConfig = DEFAULT_BACKEND;
+  clientName;
+  defaultHeaders;
+  isHealthTrackingEnabled = false;
+  url(url) {
+    this.baseUrl = url;
+    return this;
   }
-  if (result.data == null && !options?.allowNull) {
-    throw toAthenaGatewayError(result, "Expected data but received null", options?.context);
+  key(apiKey) {
+    this.apiKey = apiKey;
+    return this;
   }
-  return result.data;
-}
-function unwrapOne(result, options) {
-  const rows = unwrapRows(result, options);
-  if (!rows.length) {
-    if (options?.allowNull) return null;
-    throw toAthenaGatewayError(result, "Expected one row but received none", options?.context);
+  backend(backend) {
+    this.backendConfig = toBackendConfig(backend);
+    return this;
   }
-  if (options?.requireExactlyOne && rows.length !== 1) {
-    throw toAthenaGatewayError(
-      result,
-      `Expected exactly one row but received ${rows.length}`,
-      options.context
-    );
+  client(clientName) {
+    this.clientName = clientName;
+    return this;
   }
-  return rows[0];
-}
-function requireSuccess(result, context) {
-  if (!isOk(result)) {
-    throw toAthenaGatewayError(
-      result,
-      `Athena ${context?.operation ?? "request"} failed`,
-      context
-    );
+  headers(headers) {
+    this.defaultHeaders = headers;
+    return this;
   }
-  return result;
-}
-function requireAffected(result, options, context) {
-  requireSuccess(result, context);
-  const minimum = options?.min ?? 1;
-  const count = result.count;
-  if (count == null) {
-    throw new AthenaGatewayError({
-      code: "UNKNOWN_ERROR",
-      status: result.status,
-      message: "Expected affected row count but response.count is missing",
-      hint: 'Set call option { count: "exact" } for mutation postcondition checks.',
-      cause: safeStringify(result.raw)
-    });
+  healthTracking(enabled) {
+    this.isHealthTrackingEnabled = enabled;
+    return this;
   }
-  if (count < minimum) {
-    throw new AthenaGatewayError({
-      code: "UNKNOWN_ERROR",
-      status: result.status,
-      message: `Expected at least ${minimum} affected rows but received ${count}`,
-      hint: contextHint(context),
-      cause: safeStringify(result.raw)
+  build() {
+    if (!this.baseUrl || !this.apiKey) {
+      throw new Error("AthenaClient requires url and key; call .url() and .key() before .build()");
+    }
+    return createClientFromConfig({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      client: this.clientName,
+      backend: this.backendConfig,
+      headers: this.defaultHeaders,
+      healthTracking: this.isHealthTrackingEnabled
     });
   }
-  return count;
-}
-function applyBounds(value, options) {
-  if (options?.min !== void 0 && value < options.min) return null;
-  if (options?.max !== void 0 && value > options.max) return null;
-  return value;
-}
-function parseIntegerString(value) {
-  const normalized = value.trim();
-  if (!/^[-+]?\d+$/.test(normalized)) return null;
-  const parsed = Number(normalized);
-  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) return null;
-  return parsed;
-}
-function coerceInt(value, options) {
-  if (value == null) return null;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || !Number.isInteger(value)) return null;
-    return applyBounds(value, options);
-  }
-  if (typeof value === "string") {
-    const parsed = parseIntegerString(value);
-    if (parsed == null) return null;
-    return applyBounds(parsed, options);
+};
+var AthenaClient = class _AthenaClient {
+  /** Create a fluent builder for a strongly-typed Athena SDK client. */
+  static builder() {
+    return new AthenaClientBuilderImpl();
   }
-  if (typeof value === "bigint") {
-    if (options?.strictBigInt) {
-      if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
-        return null;
-      }
+  /** Build a client from process environment variables. */
+  static fromEnvironment() {
+    const url = process.env.ATHENA_URL ?? process.env.ATHENA_GATEWAY_URL;
+    const key = process.env.ATHENA_API_KEY ?? process.env.ATHENA_GATEWAY_API_KEY;
+    if (!url || !key) {
+      throw new Error(
+        "ATHENA_URL and ATHENA_API_KEY (or ATHENA_GATEWAY_URL and ATHENA_GATEWAY_API_KEY) are required"
+      );
     }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) return null;
-    return applyBounds(parsed, options);
-  }
-  return null;
-}
-function assertInt(value, label = "value", options) {
-  const parsed = coerceInt(value, options);
-  if (parsed == null) {
-    throw new TypeError(`${label} must be a finite integer`);
+    return _AthenaClient.builder().url(url).key(key).build();
   }
-  return parsed;
-}
-function defaultShouldRetry(error) {
-  const normalized = normalizeAthenaError(error);
-  return normalized.kind === "transient" || normalized.kind === "rate_limit";
-}
-function computeDelayMs(attempt, error, config) {
-  const baseDelay = config.baseDelayMs;
-  const rawDelay = typeof config.backoff === "function" ? config.backoff(attempt, error) : config.backoff === "linear" ? baseDelay * attempt : baseDelay * Math.pow(2, attempt - 1);
-  const safeDelay = Number.isFinite(rawDelay) ? Math.max(0, rawDelay) : 0;
-  const clamped = Math.min(config.maxDelayMs, safeDelay);
-  const jitterFactor = typeof config.jitter === "number" ? Math.max(0, Math.min(1, config.jitter)) : config.jitter ? 0.2 : 0;
-  if (!jitterFactor) return clamped;
-  const deviation = clamped * jitterFactor;
-  const offset = (Math.random() * 2 - 1) * deviation;
-  return Math.max(0, clamped + offset);
-}
-function sleep(ms) {
-  if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3) => {
-    setTimeout(resolve3, ms);
+};
+function createClient(url, apiKey, options) {
+  return createClientFromConfig({
+    baseUrl: url,
+    apiKey,
+    client: options?.client,
+    backend: toBackendConfig(options?.backend),
+    headers: options?.headers,
+    auth: options?.auth,
+    experimental: options?.experimental
   });
 }
-async function withRetry(config, fn) {
-  const retries = Math.max(0, Math.trunc(config.retries));
-  const shouldRetry = config.shouldRetry ?? defaultShouldRetry;
-  const resolvedConfig = {
-    baseDelayMs: config.baseDelayMs ?? 100,
-    maxDelayMs: config.maxDelayMs ?? 1e4,
-    backoff: config.backoff ?? "exponential",
-    jitter: config.jitter ?? false
-  };
-  for (let attempts = 0; attempts <= retries; attempts += 1) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (attempts >= retries) {
-        throw error;
-      }
-      const currentAttempt = attempts + 1;
-      const retry = await shouldRetry(error, currentAttempt);
-      if (!retry) {
-        throw error;
-      }
-      const delay = computeDelayMs(currentAttempt, error, resolvedConfig);
-      await sleep(delay);
-    }
-  }
-  throw new Error("withRetry reached an unexpected state");
-}
+
+// src/gateway/types.ts
+var Backend = {
+  Athena: { type: "athena" },
+  Postgrest: { type: "postgrest" },
+  PostgreSQL: { type: "postgresql" },
+  ScyllaDB: { type: "scylladb" }
+};
 
 // src/schema/definitions.ts
 function defineModel(input) {
@@ -1827,6 +2973,7 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
   registry;
   tenantKeyMap;
   tenantContext;
+  db;
   baseClient;
   registryNavigator;
   tenantHeaderMapper;
@@ -1853,6 +3000,7 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
       client: this.clientOptions.client,
       headers: this.tenantHeaderMapper.apply(this.clientOptions.headers, tenantContext)
     });
+    this.db = this.baseClient.db;
   }
   from(table) {
     return this.baseClient.from(table);
@@ -2242,6 +3390,21 @@ var PostgresCatalogSnapshotAssembler = class {
 };
 
 // src/schema/postgres-provider.ts
+var pgPoolConstructorPromise;
+async function loadPgPoolConstructor() {
+  if (!pgPoolConstructorPromise) {
+    pgPoolConstructorPromise = import('pg').then((module) => {
+      const poolConstructor = module.Pool ?? module.default?.Pool;
+      if (!poolConstructor) {
+        throw new Error(
+          '@xylex-group/athena: Unable to load the PostgreSQL driver. Ensure "pg" is installed and this API runs in a Node.js server runtime.'
+        );
+      }
+      return poolConstructor;
+    });
+  }
+  return pgPoolConstructorPromise;
+}
 var PgCatalogClient = class {
   constructor(pool) {
     this.pool = pool;
@@ -2281,7 +3444,8 @@ var PostgresIntrospectionProvider = class {
   }
   async inspect(options) {
     const schemas = options?.schemas && options.schemas.length > 0 ? normalizePostgresCatalogSchemas(options.schemas) : this.schemas;
-    const pool = new pg.Pool({
+    const PoolConstructor = await loadPgPoolConstructor();
+    const pool = new PoolConstructor({
       connectionString: this.connectionString
     });
     const catalogClient = new PgCatalogClient(pool);
@@ -2318,7 +3482,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -2327,7 +3491,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord3(source)) {
+  if (!isRecord4(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -2403,6 +3567,7 @@ function resolveProviderSchemas(providerConfig) {
 }
 
 // src/generator/config.ts
+var POSTGRES_PROTOCOLS = /* @__PURE__ */ new Set(["postgres:", "postgresql:"]);
 var DEFAULT_CONFIG_CANDIDATES = [
   "athena.config.ts",
   "athena.config.js",
@@ -2432,6 +3597,184 @@ var DEFAULT_EXPERIMENTAL_FLAGS = {
   postgresGatewayIntrospection: false,
   scyllaProviderContracts: true
 };
+var PROJECT_ENV_FILENAMES = [".env", ".env.local"];
+var DIRECT_CONNECTION_STRING_ENV_KEYS = [
+  "ATHENA_GENERATOR_PG_URL",
+  "DATABASE_URL",
+  "PG_URL",
+  "POSTGRES_URL",
+  "POSTGRESQL_URL"
+];
+var POSTGRES_DATABASE_ENV_KEYS = ["ATHENA_GENERATOR_DB", "ATHENA_DATABASE", "PGDATABASE"];
+var POSTGRES_PASSWORD_ENV_KEYS = ["ATHENA_GENERATOR_PG_PASSWORD", "PGPASSWORD"];
+var GATEWAY_URL_ENV_KEYS = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
+var GATEWAY_API_KEY_ENV_KEYS = [
+  "ATHENA_API_KEY",
+  "ATHENA_GATEWAY_API_KEY",
+  "ATHENA_GENERATOR_API_KEY"
+];
+function normalizeRawEnvValue(rawValue) {
+  if (rawValue.startsWith('"') && rawValue.endsWith('"') && rawValue.length >= 2) {
+    const inner = rawValue.slice(1, -1);
+    return inner.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (rawValue.startsWith("'") && rawValue.endsWith("'") && rawValue.length >= 2) {
+    return rawValue.slice(1, -1);
+  }
+  const commentIndex = rawValue.search(/\s+#/);
+  const withoutComment = commentIndex >= 0 ? rawValue.slice(0, commentIndex) : rawValue;
+  return withoutComment.trim();
+}
+function parseEnvLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) {
+    return void 0;
+  }
+  const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+  if (!match) {
+    return void 0;
+  }
+  const [, key, rawValue] = match;
+  return [key, normalizeRawEnvValue(rawValue.trim())];
+}
+function readProjectEnvEntries(cwd) {
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  const filenames = [
+    ...PROJECT_ENV_FILENAMES,
+    ...nodeEnv ? [`.env.${nodeEnv}`, `.env.${nodeEnv}.local`] : []
+  ];
+  const entries = /* @__PURE__ */ new Map();
+  for (const filename of filenames) {
+    const absolutePath = path.resolve(cwd, filename);
+    if (!fs.existsSync(absolutePath)) {
+      continue;
+    }
+    const content = fs.readFileSync(absolutePath, "utf8");
+    const lines = content.split(/\r?\n/g);
+    for (const line of lines) {
+      const parsed = parseEnvLine(line);
+      if (!parsed) {
+        continue;
+      }
+      const [key, value] = parsed;
+      entries.set(key, value);
+    }
+  }
+  return entries;
+}
+function applyProjectEnv(cwd) {
+  const envEntries = readProjectEnvEntries(cwd);
+  if (envEntries.size === 0) {
+    return () => {
+    };
+  }
+  const initialKeys = new Set(
+    Object.keys(process.env).filter((key) => process.env[key] !== void 0)
+  );
+  const staged = /* @__PURE__ */ new Map();
+  for (const [key, value] of envEntries.entries()) {
+    if (initialKeys.has(key)) {
+      continue;
+    }
+    staged.set(key, value);
+  }
+  for (const [key, value] of staged.entries()) {
+    process.env[key] = value;
+  }
+  return () => {
+    for (const key of staged.keys()) {
+      delete process.env[key];
+    }
+  };
+}
+function readEnvStringValue(key) {
+  const value = process.env[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveFallbackValue(fallbackKeys) {
+  for (const key of fallbackKeys) {
+    const value = readEnvStringValue(key);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeOptionalString(value, fallbackKeys) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return resolveFallbackValue(fallbackKeys);
+}
+function normalizeRequiredString(value, fieldLabel, fallbackKeys) {
+  const resolved = normalizeOptionalString(value, fallbackKeys);
+  if (resolved) {
+    return resolved;
+  }
+  throw new Error(
+    `Generator config is missing ${fieldLabel}. Set ${fieldLabel} directly or provide one of: ${fallbackKeys.join(", ")}.`
+  );
+}
+function applyPostgresPasswordFallback(connectionString) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(connectionString);
+  } catch {
+    return connectionString;
+  }
+  if (!POSTGRES_PROTOCOLS.has(parsedUrl.protocol)) {
+    return connectionString;
+  }
+  if (!parsedUrl.username || parsedUrl.password) {
+    return connectionString;
+  }
+  const fallbackPassword = resolveFallbackValue(POSTGRES_PASSWORD_ENV_KEYS);
+  if (!fallbackPassword) {
+    return connectionString;
+  }
+  parsedUrl.password = fallbackPassword;
+  return parsedUrl.toString();
+}
+function normalizeBooleanFlag(rawValue, fallback) {
+  if (typeof rawValue === "boolean") {
+    return rawValue;
+  }
+  if (typeof rawValue === "string") {
+    return parseBooleanFlag(rawValue, fallback);
+  }
+  return fallback;
+}
+function normalizeFeatureFlags(input) {
+  return {
+    emitRelations: normalizeBooleanFlag(
+      input?.emitRelations,
+      DEFAULT_FEATURES.emitRelations
+    ),
+    emitRegistry: normalizeBooleanFlag(
+      input?.emitRegistry,
+      DEFAULT_FEATURES.emitRegistry
+    )
+  };
+}
+function normalizeExperimentalFlags(input) {
+  return {
+    postgresGatewayIntrospection: normalizeBooleanFlag(
+      input?.postgresGatewayIntrospection,
+      DEFAULT_EXPERIMENTAL_FLAGS.postgresGatewayIntrospection
+    ),
+    scyllaProviderContracts: normalizeBooleanFlag(
+      input?.scyllaProviderContracts,
+      DEFAULT_EXPERIMENTAL_FLAGS.scyllaProviderContracts
+    )
+  };
+}
 function normalizeOutputConfig(output) {
   return {
     targets: {
@@ -2444,9 +3787,41 @@ function normalizeOutputConfig(output) {
   };
 }
 function normalizeProviderConfig(provider) {
-  if (provider.kind === "postgres") {
+  if (provider.kind === "postgres" && provider.mode === "direct") {
+    const connectionString = normalizeRequiredString(
+      provider.connectionString,
+      "provider.connectionString",
+      DIRECT_CONNECTION_STRING_ENV_KEYS
+    );
+    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS);
+    return {
+      ...provider,
+      connectionString: applyPostgresPasswordFallback(connectionString),
+      database,
+      schemas: normalizeSchemaSelection(provider.schemas)
+    };
+  }
+  if (provider.kind === "postgres" && provider.mode === "gateway") {
+    const gatewayUrl = normalizeRequiredString(
+      provider.gatewayUrl,
+      "provider.gatewayUrl",
+      GATEWAY_URL_ENV_KEYS
+    );
+    const apiKey = normalizeRequiredString(
+      provider.apiKey,
+      "provider.apiKey",
+      GATEWAY_API_KEY_ENV_KEYS
+    );
+    const database = normalizeRequiredString(
+      provider.database,
+      "provider.database",
+      POSTGRES_DATABASE_ENV_KEYS
+    );
     return {
       ...provider,
+      gatewayUrl,
+      apiKey,
+      database,
       schemas: normalizeSchemaSelection(provider.schemas)
     };
   }
@@ -2467,14 +3842,8 @@ function normalizeGeneratorConfig(input) {
       ...DEFAULT_NAMING,
       ...input.naming ?? {}
     },
-    features: {
-      ...DEFAULT_FEATURES,
-      ...input.features ?? {}
-    },
-    experimental: {
-      ...DEFAULT_EXPERIMENTAL_FLAGS,
-      ...input.experimental ?? {}
-    }
+    features: normalizeFeatureFlags(input.features),
+    experimental: normalizeExperimentalFlags(input.experimental)
   };
 }
 function defineGeneratorConfig(config) {
@@ -2514,6 +3883,11 @@ function extractConfigExport(module) {
     if (moduleExports && typeof moduleExports === "object") {
       queue.push(moduleExports);
     }
+    for (const value of Object.values(record)) {
+      if (value && typeof value === "object") {
+        queue.push(value);
+      }
+    }
   }
   throw new Error(
     "Generator config file must export a config object as default export or `config`."
@@ -2528,19 +3902,24 @@ function importConfigModule(moduleSpecifier) {
 }
 async function loadGeneratorConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const restoreProjectEnv = applyProjectEnv(cwd);
   const resolvedPath = options.configPath ? path.resolve(cwd, options.configPath) : findGeneratorConfigPath(cwd);
   if (!resolvedPath) {
     throw new Error(
       `No generator config found in ${cwd}. Expected one of: ${DEFAULT_CONFIG_CANDIDATES.join(", ")}`
     );
   }
-  const moduleUrl = url.pathToFileURL(resolvedPath);
-  const module = await importConfigModule(`${moduleUrl.href}?cacheBust=${Date.now()}`);
-  const rawConfig = extractConfigExport(module);
-  return {
-    configPath: resolvedPath,
-    config: normalizeGeneratorConfig(rawConfig)
-  };
+  try {
+    const moduleUrl = url.pathToFileURL(resolvedPath);
+    const module = await importConfigModule(`${moduleUrl.href}?cacheBust=${Date.now()}`);
+    const rawConfig = extractConfigExport(module);
+    return {
+      configPath: resolvedPath,
+      config: normalizeGeneratorConfig(rawConfig)
+    };
+  } finally {
+    restoreProjectEnv();
+  }
 }
 
 // src/generator/naming.ts
@@ -2684,9 +4063,13 @@ function resolvePlaceholderMap(baseTokens, outputConfig) {
   const resolved = {
     ...baseTokens
   };
+  const reservedTokenKeys = new Set(Object.keys(baseTokens));
   const entries = Object.entries(outputConfig.placeholderMap ?? {});
   for (let index = 0; index < entries.length; index += 1) {
     const [key, value] = entries[index];
+    if (reservedTokenKeys.has(key)) {
+      continue;
+    }
     let current = value;
     for (let depth = 0; depth < 8; depth += 1) {
       const next = renderTemplate(current, resolved);
@@ -2966,13 +4349,65 @@ function assertNoDuplicatePaths(files) {
         [
           `Generator output collision detected for path: ${file.path}`,
           `Collision: ${existing.kind} and ${file.kind}.`,
-          "When syncing multiple schemas, include a schema placeholder such as {schema} or {schema_kebab} in model/schema output targets."
+          "Use explicit placeholders such as {model}, {model_kebab}, {schema}, or {schema_kebab} in output targets so each artifact resolves to a unique path."
         ].join(" ")
       );
     }
     seen.set(file.path, file);
   }
 }
+function addSchemaSegmentToPath(pathValue, schemaName) {
+  const normalizedPath = normalizePath(pathValue);
+  const parsedPath = path.posix.parse(normalizedPath);
+  const schemaSegment = applyNamingStyle(schemaName, "kebab");
+  if (!schemaSegment) {
+    return normalizedPath;
+  }
+  const dir = parsedPath.dir.length > 0 ? `${parsedPath.dir}/${schemaSegment}` : schemaSegment;
+  return normalizePath(path.posix.join(dir, parsedPath.base));
+}
+function scopeDuplicateDescriptorPathsBySchema(descriptors) {
+  const nextDescriptors = descriptors.map((descriptor) => ({ ...descriptor }));
+  const duplicates = /* @__PURE__ */ new Map();
+  for (let index = 0; index < nextDescriptors.length; index += 1) {
+    const descriptor = nextDescriptors[index];
+    const indexes = duplicates.get(descriptor.filePath) ?? [];
+    indexes.push(index);
+    duplicates.set(descriptor.filePath, indexes);
+  }
+  let appliedSchemaScoping = false;
+  for (const indexes of duplicates.values()) {
+    if (indexes.length <= 1) {
+      continue;
+    }
+    const schemaNames = new Set(indexes.map((index) => nextDescriptors[index].schemaName));
+    if (schemaNames.size <= 1) {
+      continue;
+    }
+    for (const index of indexes) {
+      const descriptor = nextDescriptors[index];
+      descriptor.filePath = addSchemaSegmentToPath(descriptor.filePath, descriptor.schemaName);
+    }
+    appliedSchemaScoping = true;
+  }
+  if (!appliedSchemaScoping) {
+    return nextDescriptors;
+  }
+  const normalizedPaths = /* @__PURE__ */ new Set();
+  for (const descriptor of nextDescriptors) {
+    if (normalizedPaths.has(descriptor.filePath)) {
+      throw new Error(
+        [
+          `Generator output collision detected for path: ${descriptor.filePath}`,
+          "Automatic schema path scoping was applied but collisions remain.",
+          "Add explicit placeholders such as {model}, {model_kebab}, {schema}, or {schema_kebab} to your output targets."
+        ].join(" ")
+      );
+    }
+    normalizedPaths.add(descriptor.filePath);
+  }
+  return nextDescriptors;
+}
 var ArtifactComposer = class {
   constructor(snapshot, config) {
     this.snapshot = snapshot;
@@ -3011,7 +4446,8 @@ var ArtifactComposer = class {
         });
       }
     }
-    const schemaDescriptors = Object.keys(this.snapshot.schemas).sort().map((schemaName) => {
+    const scopedModelDescriptors = scopeDuplicateDescriptorPathsBySchema(modelDescriptors);
+    let schemaDescriptors = Object.keys(this.snapshot.schemas).sort().map((schemaName) => {
       const schemaPath = normalizePath(
         renderOutputPath(this.config.output.targets.schema, {
           provider: providerName,
@@ -3029,9 +4465,10 @@ var ArtifactComposer = class {
           this.config.naming.schemaConst,
           "schema"
         ),
-        models: modelDescriptors.filter((model) => model.schemaName === schemaName)
+        models: scopedModelDescriptors.filter((model) => model.schemaName === schemaName)
       };
     });
+    schemaDescriptors = scopeDuplicateDescriptorPathsBySchema(schemaDescriptors);
     const databasePath = normalizePath(
       renderOutputPath(this.config.output.targets.database, {
         provider: providerName,
@@ -3051,7 +4488,7 @@ var ArtifactComposer = class {
       schemas: schemaDescriptors
     };
     const files = [];
-    for (const modelDescriptor of modelDescriptors) {
+    for (const modelDescriptor of scopedModelDescriptors) {
       files.push(renderModelArtifact(this.snapshot, modelDescriptor, this.config));
     }
     for (const schemaDescriptor of schemaDescriptors) {
@@ -3084,633 +4521,142 @@ var ArtifactComposer = class {
       files
     };
   }
-};
-function generateArtifactsFromSnapshot(snapshot, config) {
-  const normalizedConfig = "naming" in config && "features" in config && "experimental" in config ? config : normalizeGeneratorConfig(config);
-  return new ArtifactComposer(snapshot, normalizedConfig).compose();
-}
-
-// src/generator/providers.ts
-var AthenaGatewayCatalogClient = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async queryRows(query) {
-    const result = await this.client.query(query);
-    if (result.error || result.status < 200 || result.status >= 300) {
-      throw new Error(result.error ?? `Gateway query failed with status ${result.status}`);
-    }
-    return result.data ?? [];
-  }
-  async queryColumns(query) {
-    return this.queryRows(query);
-  }
-  async queryEnums(query) {
-    const rows = await this.queryRows(query);
-    const enumMap = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const existing = enumMap.get(row.type_oid) ?? [];
-      existing.push(row.enum_label);
-      enumMap.set(row.type_oid, existing);
-    }
-    return enumMap;
-  }
-  async queryPrimaryKeys(query) {
-    return this.queryRows(query);
-  }
-  async queryForeignKeys(query) {
-    return this.queryRows(query);
-  }
-};
-var AthenaGatewayPostgresIntrospectionProvider = class {
-  constructor(config) {
-    this.config = config;
-    this.client = createClient(this.config.gatewayUrl, this.config.apiKey, {
-      backend: {
-        type: this.config.backend ?? "postgresql"
-      }
-    });
-    this.schemas = normalizeSchemaSelection(this.config.schemas);
-  }
-  backend = "postgresql";
-  client;
-  schemas;
-  async inspect(options) {
-    const schemas = options?.schemas && options.schemas.length > 0 ? normalizeSchemaSelection(options.schemas) : this.schemas;
-    const catalogClient = new AthenaGatewayCatalogClient(this.client);
-    const queries = buildGatewayCatalogQueries(schemas);
-    const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
-      catalogClient.queryColumns(queries.columns),
-      catalogClient.queryEnums(queries.enums),
-      catalogClient.queryPrimaryKeys(queries.primaryKeys),
-      catalogClient.queryForeignKeys(queries.foreignKeys)
-    ]);
-    const assembler = new PostgresCatalogSnapshotAssembler();
-    assembler.addColumnRows(columnRows, enumMap);
-    assembler.addPrimaryKeyRows(primaryKeyRows);
-    assembler.addForeignKeyRows(foreignKeyRows);
-    assembler.addManyToManyRows(foreignKeyRows);
-    return {
-      backend: "postgresql",
-      database: this.config.database,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      schemas: assembler.toSchemas()
-    };
-  }
-};
-var ScyllaIntrospectionProvider = class {
-  constructor(config) {
-    this.config = config;
-  }
-  backend = "scylladb";
-  async inspect() {
-    throw new Error(
-      `Scylla introspection provider is not implemented yet for keyspace ${this.config.keyspace}.`
-    );
-  }
-};
-function createPostgresProvider(config) {
-  return createPostgresIntrospectionProvider({
-    connectionString: config.connectionString,
-    database: config.database,
-    schemas: normalizeSchemaSelection(config.schemas)
-  });
-}
-function resolveGeneratorProvider(providerConfig, experimentalFlags) {
-  if (providerConfig.kind === "postgres" && providerConfig.mode === "direct") {
-    return createPostgresProvider(providerConfig);
-  }
-  if (providerConfig.kind === "postgres" && providerConfig.mode === "gateway") {
-    return new AthenaGatewayPostgresIntrospectionProvider(providerConfig);
-  }
-  if (providerConfig.kind === "scylla") {
-    if (!experimentalFlags.scyllaProviderContracts) {
-      throw new Error(
-        "Scylla provider contracts are disabled. Set experimental.scyllaProviderContracts=true to enable placeholders."
-      );
-    }
-    return new ScyllaIntrospectionProvider(providerConfig);
-  }
-  throw new Error(`Unsupported generator provider kind: ${providerConfig.kind ?? "unknown"}`);
-}
-async function writeArtifacts(files, cwd) {
-  const writtenFiles = [];
-  for (const file of files) {
-    const absolutePath = path.resolve(cwd, file.path);
-    await promises.mkdir(path.dirname(absolutePath), { recursive: true });
-    await promises.writeFile(absolutePath, file.content, "utf8");
-    writtenFiles.push(file.path);
-  }
-  return writtenFiles;
-}
-async function runSchemaGenerator(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const configOptions = {
-    cwd,
-    configPath: options.configPath
-  };
-  const { configPath, config } = await loadGeneratorConfig(configOptions);
-  const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
-  const snapshot = await provider.inspect({
-    schemas: resolveProviderSchemas(config.provider)
-  });
-  const generated = generateArtifactsFromSnapshot(snapshot, config);
-  const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
-  return {
-    ...generated,
-    configPath,
-    writtenFiles
-  };
-}
-
-// src/auth/client.ts
-var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
-var FALLBACK_SDK_VERSION2 = "1.0.0";
-var SDK_NAME2 = "xylex-group/athena-auth";
-var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
-var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
-function normalizeBaseUrl(baseUrl) {
-  return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
-}
-function isRecord4(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeHeaderValue2(value) {
-  return value ? value : void 0;
-}
-function parseResponseBody2(rawText, contentType) {
-  if (!rawText) {
-    return { parsed: null, parseFailed: false };
-  }
-  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
-  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
-  if (!looksJson) {
-    return { parsed: rawText, parseFailed: false };
-  }
-  try {
-    return { parsed: JSON.parse(rawText), parseFailed: false };
-  } catch {
-    return { parsed: rawText, parseFailed: true };
-  }
-}
-function resolveRequestId2(headers) {
-  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
-}
-function resolveErrorMessage2(payload, fallback) {
-  if (isRecord4(payload)) {
-    const messageCandidates = [payload.error, payload.message, payload.details];
-    for (const candidate of messageCandidates) {
-      if (typeof candidate === "string" && candidate.trim().length > 0) {
-        return candidate.trim();
-      }
-    }
-  }
-  if (typeof payload === "string" && payload.trim().length > 0) {
-    return payload.trim();
-  }
-  return fallback;
-}
-function toErrorDetails(input) {
-  return {
-    code: input.code,
-    message: input.message,
-    status: input.status,
-    endpoint: input.endpoint,
-    method: input.method,
-    requestId: input.requestId,
-    hint: input.hint,
-    cause: input.cause
-  };
-}
-function mergeCallOptions(base, override) {
-  if (!base && !override) return void 0;
-  return {
-    ...base,
-    ...override,
-    headers: {
-      ...base?.headers ?? {},
-      ...override?.headers ?? {}
-    }
-  };
-}
-function extractFetchOptions(input) {
-  if (!input) {
-    return {
-      payload: void 0,
-      fetchOptions: void 0
-    };
-  }
-  const { fetchOptions, ...rest } = input;
-  const hasPayloadKeys = Object.keys(rest).length > 0;
-  return {
-    payload: hasPayloadKeys ? rest : void 0,
-    fetchOptions
-  };
+};
+function generateArtifactsFromSnapshot(snapshot, config) {
+  const normalizedConfig = "naming" in config && "features" in config && "experimental" in config ? config : normalizeGeneratorConfig(config);
+  return new ArtifactComposer(snapshot, normalizedConfig).compose();
 }
-function buildHeaders2(config, options) {
-  const headers = {
-    "Content-Type": "application/json",
-    "X-Athena-Sdk": SDK_HEADER_VALUE2
-  };
-  const apiKey = options?.apiKey ?? config.apiKey;
-  if (apiKey) {
-    headers.apikey = apiKey;
-    headers["x-api-key"] = apiKey;
-  }
-  const bearerToken = options?.bearerToken ?? config.bearerToken;
-  if (bearerToken) {
-    headers.Authorization = `Bearer ${bearerToken}`;
+
+// src/generator/providers.ts
+var AthenaGatewayCatalogClient = class {
+  constructor(client) {
+    this.client = client;
   }
-  const mergedExtraHeaders = {
-    ...config.headers ?? {},
-    ...options?.headers ?? {}
-  };
-  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
-    const normalized = normalizeHeaderValue2(value);
-    if (normalized) {
-      headers[key] = normalized;
+  async queryRows(query) {
+    const result = await this.client.query(query);
+    if (result.error || result.status < 200 || result.status >= 300) {
+      throw new Error(result.error ?? `Gateway query failed with status ${result.status}`);
     }
-  });
-  return headers;
-}
-function appendQueryParam(searchParams, key, value) {
-  if (value === void 0 || value === null) return;
-  if (Array.isArray(value)) {
-    value.forEach((item) => {
-      searchParams.append(key, String(item));
-    });
-    return;
+    return result.data ?? [];
   }
-  searchParams.append(key, String(value));
-}
-function buildRequestUrl(baseUrl, endpoint, query) {
-  const url = `${baseUrl}${endpoint}`;
-  if (!query || Object.keys(query).length === 0) return url;
-  const searchParams = new URLSearchParams();
-  Object.entries(query).forEach(([key, value]) => appendQueryParam(searchParams, key, value));
-  const queryText = searchParams.toString();
-  return queryText ? `${url}?${queryText}` : url;
-}
-function inferDefaultMethod(endpoint) {
-  if (endpoint.startsWith("/reset-password/")) {
-    return "GET";
+  async queryColumns(query) {
+    return this.queryRows(query);
   }
-  switch (endpoint) {
-    case "/get-session":
-    case "/list-sessions":
-    case "/verify-email":
-    case "/delete-user/callback":
-    case "/list-accounts":
-    case "/ok":
-    case "/error":
-      return "GET";
-    default:
-      return "POST";
+  async queryEnums(query) {
+    const rows = await this.queryRows(query);
+    const enumMap = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const existing = enumMap.get(row.type_oid) ?? [];
+      existing.push(row.enum_label);
+      enumMap.set(row.type_oid, existing);
+    }
+    return enumMap;
   }
-}
-async function callAuthEndpoint(config, context, body, query, options) {
-  const baseUrl = normalizeBaseUrl(options?.baseUrl ?? config.baseUrl);
-  const url = buildRequestUrl(baseUrl, context.endpoint, query);
-  const headers = buildHeaders2(config, options);
-  const credentials = options?.credentials ?? config.credentials ?? "include";
-  const requestInit = {
-    method: context.method,
-    headers,
-    credentials,
-    signal: options?.signal
-  };
-  if (context.method !== "GET") {
-    requestInit.body = JSON.stringify(body ?? {});
+  async queryPrimaryKeys(query) {
+    return this.queryRows(query);
   }
-  const fetcher = config.fetch ?? globalThis.fetch;
-  if (!fetcher) {
-    const details = toErrorDetails({
-      code: "UNKNOWN_ERROR",
-      message: "No fetch implementation available for auth client",
-      status: 0,
-      endpoint: context.endpoint,
-      method: context.method,
-      hint: "Use Node 18+ or provide `fetch` in createAuthClient({ fetch })"
+  async queryForeignKeys(query) {
+    return this.queryRows(query);
+  }
+};
+var AthenaGatewayPostgresIntrospectionProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.client = createClient(this.config.gatewayUrl, this.config.apiKey, {
+      backend: {
+        type: this.config.backend ?? "postgresql"
+      }
     });
+    this.schemas = normalizeSchemaSelection(this.config.schemas);
+  }
+  backend = "postgresql";
+  client;
+  schemas;
+  async inspect(options) {
+    const schemas = options?.schemas && options.schemas.length > 0 ? normalizeSchemaSelection(options.schemas) : this.schemas;
+    const catalogClient = new AthenaGatewayCatalogClient(this.client);
+    const queries = buildGatewayCatalogQueries(schemas);
+    const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
+      catalogClient.queryColumns(queries.columns),
+      catalogClient.queryEnums(queries.enums),
+      catalogClient.queryPrimaryKeys(queries.primaryKeys),
+      catalogClient.queryForeignKeys(queries.foreignKeys)
+    ]);
+    const assembler = new PostgresCatalogSnapshotAssembler();
+    assembler.addColumnRows(columnRows, enumMap);
+    assembler.addPrimaryKeyRows(primaryKeyRows);
+    assembler.addForeignKeyRows(foreignKeyRows);
+    assembler.addManyToManyRows(foreignKeyRows);
     return {
-      ok: false,
-      status: 0,
-      data: null,
-      error: details.message,
-      errorDetails: details,
-      raw: null
+      backend: "postgresql",
+      database: this.config.database,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      schemas: assembler.toSchemas()
     };
   }
-  try {
-    const response = await fetcher(url, requestInit);
-    const rawText = await response.text();
-    const requestId = resolveRequestId2(response.headers);
-    const parsedBody = parseResponseBody2(rawText ?? "", response.headers.get("content-type"));
-    if (parsedBody.parseFailed) {
-      const details = toErrorDetails({
-        code: "INVALID_JSON",
-        message: "Auth server returned malformed JSON",
-        status: response.status,
-        endpoint: context.endpoint,
-        method: context.method,
-        requestId,
-        hint: "Verify the auth endpoint response body is valid JSON.",
-        cause: rawText.slice(0, 300)
-      });
-      return {
-        ok: false,
-        status: response.status,
-        data: null,
-        error: details.message,
-        errorDetails: details,
-        raw: parsedBody.parsed
-      };
-    }
-    const parsed = parsedBody.parsed;
-    if (!response.ok) {
-      const details = toErrorDetails({
-        code: "HTTP_ERROR",
-        message: resolveErrorMessage2(
-          parsed,
-          `Auth endpoint ${context.method} ${context.endpoint} failed with status ${response.status}`
-        ),
-        status: response.status,
-        endpoint: context.endpoint,
-        method: context.method,
-        requestId
-      });
-      return {
-        ok: false,
-        status: response.status,
-        data: null,
-        error: details.message,
-        errorDetails: details,
-        raw: parsed
-      };
+};
+var ScyllaIntrospectionProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  backend = "scylladb";
+  async inspect() {
+    throw new Error(
+      `Scylla introspection provider is not implemented yet for keyspace ${this.config.keyspace}.`
+    );
+  }
+};
+function createPostgresProvider(config) {
+  return createPostgresIntrospectionProvider({
+    connectionString: config.connectionString,
+    database: config.database,
+    schemas: normalizeSchemaSelection(config.schemas)
+  });
+}
+function resolveGeneratorProvider(providerConfig, experimentalFlags) {
+  if (providerConfig.kind === "postgres" && providerConfig.mode === "direct") {
+    return createPostgresProvider(providerConfig);
+  }
+  if (providerConfig.kind === "postgres" && providerConfig.mode === "gateway") {
+    return new AthenaGatewayPostgresIntrospectionProvider(providerConfig);
+  }
+  if (providerConfig.kind === "scylla") {
+    if (!experimentalFlags.scyllaProviderContracts) {
+      throw new Error(
+        "Scylla provider contracts are disabled. Set experimental.scyllaProviderContracts=true to enable placeholders."
+      );
     }
-    return {
-      ok: true,
-      status: response.status,
-      data: parsed ?? null,
-      error: null,
-      errorDetails: null,
-      raw: parsed
-    };
-  } catch (callError) {
-    const message = callError instanceof Error ? callError.message : String(callError);
-    const details = toErrorDetails({
-      code: "NETWORK_ERROR",
-      message: `Network error while calling ${context.method} ${context.endpoint}: ${message}`,
-      status: 0,
-      endpoint: context.endpoint,
-      method: context.method,
-      cause: message,
-      hint: "Check auth server URL, DNS, and network reachability."
-    });
-    return {
-      ok: false,
-      status: 0,
-      data: null,
-      error: details.message,
-      errorDetails: details,
-      raw: null
-    };
+    return new ScyllaIntrospectionProvider(providerConfig);
   }
+  throw new Error(`Unsupported generator provider kind: ${providerConfig.kind ?? "unknown"}`);
 }
-function executePostWithCompatibleInput(config, context, input, options) {
-  const { payload, fetchOptions } = extractFetchOptions(input);
-  const mergedOptions = mergeCallOptions(fetchOptions, options);
-  return callAuthEndpoint(config, context, payload ?? {}, void 0, mergedOptions);
-}
-function executePostWithOptionalInput(config, context, input, options) {
-  const { fetchOptions } = extractFetchOptions(input);
-  const mergedOptions = mergeCallOptions(fetchOptions, options);
-  return callAuthEndpoint(config, context, {}, void 0, mergedOptions);
-}
-function executeGetWithCompatibleInput(config, context, input, options) {
-  const { fetchOptions } = extractFetchOptions(input);
-  const mergedOptions = mergeCallOptions(fetchOptions, options);
-  return callAuthEndpoint(config, context, void 0, void 0, mergedOptions);
+async function writeArtifacts(files, cwd) {
+  const writtenFiles = [];
+  for (const file of files) {
+    const absolutePath = path.resolve(cwd, file.path);
+    await promises.mkdir(path.dirname(absolutePath), { recursive: true });
+    await promises.writeFile(absolutePath, file.content, "utf8");
+    writtenFiles.push(file.path);
+  }
+  return writtenFiles;
 }
-function createAuthClient(config = {}) {
-  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
-  const resolvedConfig = {
-    ...config,
-    baseUrl: normalizedBaseUrl
-  };
-  const request = (input, options) => {
-    const method = input.method ?? (input.body !== void 0 ? "POST" : inferDefaultMethod(input.endpoint));
-    const mergedOptions = mergeCallOptions(input.fetchOptions, options);
-    return callAuthEndpoint(
-      resolvedConfig,
-      { endpoint: input.endpoint, method },
-      input.body,
-      input.query,
-      mergedOptions
-    );
-  };
-  const signOut = (input, options) => executePostWithOptionalInput(
-    resolvedConfig,
-    { endpoint: "/sign-out", method: "POST" },
-    input,
-    options
-  );
-  const revokeSessions = (input, options) => executePostWithOptionalInput(
-    resolvedConfig,
-    { endpoint: "/revoke-sessions", method: "POST" },
-    input,
-    options
-  );
-  const revokeOtherSessions = (input, options) => executePostWithOptionalInput(
-    resolvedConfig,
-    { endpoint: "/revoke-other-sessions", method: "POST" },
-    input,
-    options
-  );
-  const revokeSession = (input, options) => executePostWithCompatibleInput(
-    resolvedConfig,
-    { endpoint: "/revoke-session", method: "POST" },
-    input,
-    options
-  );
-  const deleteUser = (input, options) => {
-    const { payload, fetchOptions } = extractFetchOptions(input);
-    const mergedOptions = mergeCallOptions(fetchOptions, options);
-    return callAuthEndpoint(
-      resolvedConfig,
-      { endpoint: "/delete-user", method: "POST" },
-      payload ?? {},
-      void 0,
-      mergedOptions
-    );
-  };
-  const deleteUserCallback = (input, options) => {
-    const { payload, fetchOptions } = extractFetchOptions(input);
-    const mergedOptions = mergeCallOptions(fetchOptions, options);
-    const query = payload ?? {};
-    return callAuthEndpoint(
-      resolvedConfig,
-      { endpoint: "/delete-user/callback", method: "GET" },
-      void 0,
-      {
-        token: query.token,
-        callbackURL: query.callbackURL
-      },
-      mergedOptions
-    );
-  };
-  const resolveResetPasswordToken = (input, options) => {
-    const { payload, fetchOptions } = extractFetchOptions(input);
-    const mergedOptions = mergeCallOptions(fetchOptions, options);
-    const query = payload;
-    const token = query?.token?.trim();
-    if (!token) {
-      throw new Error("resolveResetPasswordToken requires a non-empty token");
-    }
-    const endpoint = `/reset-password/${encodeURIComponent(token)}`;
-    return callAuthEndpoint(
-      resolvedConfig,
-      { endpoint, method: "GET" },
-      void 0,
-      query?.callbackURL ? { callbackURL: query.callbackURL } : void 0,
-      mergedOptions
-    );
+async function runSchemaGenerator(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configOptions = {
+    cwd,
+    configPath: options.configPath
   };
+  const { configPath, config } = await loadGeneratorConfig(configOptions);
+  const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
+  const snapshot = await provider.inspect({
+    schemas: resolveProviderSchemas(config.provider)
+  });
+  const generated = generateArtifactsFromSnapshot(snapshot, config);
+  const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
   return {
-    baseUrl: normalizedBaseUrl,
-    request,
-    signIn: {
-      email: (input, options) => executePostWithCompatibleInput(
-        resolvedConfig,
-        { endpoint: "/sign-in/email", method: "POST" },
-        input,
-        options
-      ),
-      username: (input, options) => executePostWithCompatibleInput(
-        resolvedConfig,
-        { endpoint: "/sign-in/username", method: "POST" },
-        input,
-        options
-      ),
-      social: (input, options) => executePostWithCompatibleInput(
-        resolvedConfig,
-        { endpoint: "/sign-in/social", method: "POST" },
-        input,
-        options
-      )
-    },
-    signUp: {
-      email: (input, options) => executePostWithCompatibleInput(
-        resolvedConfig,
-        { endpoint: "/sign-up/email", method: "POST" },
-        input,
-        options
-      )
-    },
-    signOut,
-    logout: signOut,
-    getSession: (input, options) => executeGetWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/get-session", method: "GET" },
-      input,
-      options
-    ),
-    listSessions: (input, options) => executeGetWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/list-sessions", method: "GET" },
-      input,
-      options
-    ),
-    revokeSession,
-    clearSession: revokeSession,
-    revokeSessions,
-    clearSessions: revokeSessions,
-    revokeOtherSessions,
-    clearOtherSessions: revokeOtherSessions,
-    forgetPassword: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/forget-password", method: "POST" },
-      input,
-      options
-    ),
-    resetPassword: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/reset-password", method: "POST" },
-      input,
-      options
-    ),
-    resolveResetPasswordToken,
-    verifyEmail: (input, options) => {
-      const { payload, fetchOptions } = extractFetchOptions(input);
-      const mergedOptions = mergeCallOptions(fetchOptions, options);
-      const query = payload;
-      return callAuthEndpoint(
-        resolvedConfig,
-        { endpoint: "/verify-email", method: "GET" },
-        void 0,
-        query ? {
-          token: query.token,
-          callbackURL: query.callbackURL
-        } : void 0,
-        mergedOptions
-      );
-    },
-    sendVerificationEmail: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/send-verification-email", method: "POST" },
-      input,
-      options
-    ),
-    changeEmail: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/change-email", method: "POST" },
-      input,
-      options
-    ),
-    changePassword: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/change-password", method: "POST" },
-      input,
-      options
-    ),
-    updateUser: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/update-user", method: "POST" },
-      input,
-      options
-    ),
-    deleteUser,
-    deleteUserCallback,
-    linkSocial: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/link-social", method: "POST" },
-      input,
-      options
-    ),
-    listAccounts: (input, options) => executeGetWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/list-accounts", method: "GET" },
-      input,
-      options
-    ),
-    unlinkAccount: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/unlink-account", method: "POST" },
-      input,
-      options
-    ),
-    refreshToken: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/refresh-token", method: "POST" },
-      input,
-      options
-    ),
-    getAccessToken: (input, options) => executePostWithCompatibleInput(
-      resolvedConfig,
-      { endpoint: "/get-access-token", method: "POST" },
-      input,
-      options
-    )
+    ...generated,
+    configPath,
+    writtenFiles
   };
 }
 
@@ -3743,6 +4689,7 @@ exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
+exports.parseBooleanFlag = parseBooleanFlag;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;