@xylex-group/athena 3.0.3 → 3.3.0

package/dist/index.cjs

@@ -573,8 +573,8 @@ function computeDelayMs(attempt, error, config) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3) => {
-    setTimeout(resolve3, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 async function withRetry(config, fn) {
@@ -2009,7 +2009,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.0.3"
+  version: "3.3.0"
 };
 
 // src/sdk-version.ts
@@ -4769,6 +4769,14 @@ function createAuthModule(config = {}, runtimeOptions = {}) {
     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),
+    // Better Auth UI flat method aliases (also nested under session/account/social/user).
+    listSessions: (input, options) => getGeneric("/list-sessions", input, options),
+    revokeSession: sessionRevokeBinding,
+    revokeOtherSessions,
+    listAccounts: (input, options) => getGeneric("/list-accounts", input, options),
+    unlinkAccount: (input, options) => postGeneric("/unlink-account", input, options),
+    linkSocial: (input, options) => postGeneric("/link-social", input, options),
+    updateUser: (input, options) => postGeneric("/update-user", input, options),
     user: {
       update: (input, options) => postGeneric("/update-user", input, options),
       delete: (input, options) => postGeneric("/delete-user", input, options),
@@ -5228,7 +5236,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload direct mode requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5241,7 +5249,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
         return;
       }
       onProgress({ loaded: bodySize(body) });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders(xhr.getAllResponseHeaders())
@@ -5694,7 +5702,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5711,7 +5719,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
         return;
       }
       onProgress({ loaded: source.sizeBytes });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders2(xhr.getAllResponseHeaders())
@@ -10578,6 +10586,82 @@ function mergeAthenaRequestContexts(base, override) {
   };
 }
 
+// src/diagnostics.ts
+function readProcessEnv2() {
+  try {
+    return globalThis.process?.env ?? {};
+  } catch {
+    return {};
+  }
+}
+function isTruthyEnv(value) {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function isQuietAthenaDiagnosticsEnvironment(env = readProcessEnv2()) {
+  const nodeEnv = env.NODE_ENV?.trim().toLowerCase();
+  if (nodeEnv === "production") {
+    return true;
+  }
+  if (isTruthyEnv(env.OPENNEXT_BUILD)) {
+    return true;
+  }
+  const nextPhase = env.NEXT_PHASE?.trim();
+  if (nextPhase === "phase-production-build") {
+    return true;
+  }
+  if (isTruthyEnv(env.CI) && nodeEnv !== "test") {
+    if (nodeEnv === "production" || isTruthyEnv(env.OPENNEXT_BUILD)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveBooleanFlag(explicit, mode, quiet) {
+  if (typeof explicit === "boolean") {
+    return explicit;
+  }
+  if (mode === true) {
+    return true;
+  }
+  if (mode === false) {
+    return false;
+  }
+  if (mode === "auto") {
+    return false;
+  }
+  return false;
+}
+function resolveAthenaClientDiagnostics(input) {
+  const env = input.env ?? readProcessEnv2();
+  const quiet = isQuietAthenaDiagnosticsEnvironment(env);
+  const mode = input.diagnostics;
+  const effectiveMode = mode === "auto" && quiet ? false : mode;
+  const debugAst = resolveBooleanFlag(input.debugAst, effectiveMode);
+  const findManyAst = resolveBooleanFlag(input.findManyAst, effectiveMode);
+  let traceQueries;
+  if (input.traceQueries !== void 0) {
+    if (typeof input.traceQueries === "boolean") {
+      traceQueries = input.traceQueries;
+    } else if (effectiveMode === false || mode === "auto" && quiet) {
+      const enabled = input.traceQueries.enabled;
+      traceQueries = typeof enabled === "boolean" ? enabled ? input.traceQueries : false : false;
+    } else {
+      traceQueries = input.traceQueries;
+    }
+  } else if (effectiveMode === true) {
+    traceQueries = true;
+  } else {
+    traceQueries = false;
+  }
+  return {
+    debugAst,
+    findManyAst,
+    traceQueries
+  };
+}
+
 // src/v3-client.ts
 var ENV_URL_KEYS = ["ATHENA_URL", "NEXT_PUBLIC_ATHENA_URL"];
 var ENV_DB_URL_KEYS = ["ATHENA_DB_URL", "ATHENA_GATEWAY_URL", "NEXT_PUBLIC_ATHENA_DB_API_URL"];
@@ -10586,7 +10670,13 @@ var ENV_CHAT_URL_KEYS = ["ATHENA_CHAT_URL", "NEXT_PUBLIC_ATHENA_CHAT_URL"];
 var ENV_CHAT_WS_URL_KEYS = ["ATHENA_CHAT_WS_URL", "NEXT_PUBLIC_ATHENA_CHAT_WS_URL"];
 var ENV_STORAGE_URL_KEYS = ["ATHENA_STORAGE_URL", "NEXT_PUBLIC_ATHENA_STORAGE_URL"];
 var ENV_KEY_KEYS = ["ATHENA_API_KEY", "NEXT_PUBLIC_ATHENA_API_KEY", "ATHENA_GATEWAY_API_KEY", "X_API_KEY"];
-var ENV_CLIENT_KEYS = ["ATHENA_CLIENT", "NEXT_PUBLIC_ATHENA_CLIENT"];
+var ENV_CLIENT_KEYS = [
+  "ATHENA_CLIENT",
+  "ATHENA_GATEWAY_CLIENT",
+  "ATHENA_GENERATOR_CLIENT",
+  "NEXT_PUBLIC_ATHENA_CLIENT",
+  "NEXT_PUBLIC_ATHENA_GATEWAY_CLIENT"
+];
 var MISSING_DB_SENTINEL = "https://athena.invalid/db";
 function readFirstEnv(env, keys) {
   for (const key of keys) {
@@ -10661,6 +10751,13 @@ function createInternalConfig(core) {
   const { config, urls } = core;
   const { url: _authUrl, ...authOptions } = config.auth ?? {};
   const { url: _storageUrl, directUpload, ...storageOptions } = config.storage ?? {};
+  const diagnostics = resolveAthenaClientDiagnostics({
+    diagnostics: config.diagnostics,
+    debugAst: config.debugAst,
+    findManyAst: config.findManyAst,
+    traceQueries: config.traceQueries,
+    env: config.env
+  });
   return {
     baseUrl: urls.db ?? MISSING_DB_SENTINEL,
     apiKey: core.key,
@@ -10677,9 +10774,9 @@ function createInternalConfig(core) {
     models: config.models,
     behavior: {
       retryReads: config.retryReads,
-      traceQueries: config.traceQueries,
-      debugAst: config.debugAst,
-      findManyAst: config.findManyAst
+      traceQueries: diagnostics.traceQueries,
+      debugAst: diagnostics.debugAst,
+      findManyAst: diagnostics.findManyAst
     },
     storage: {
       ...storageOptions,
@@ -10753,11 +10850,30 @@ function createClientView(core, viewContext) {
       return resolved.verifyConnection(options);
     },
     withContext(context) {
+      warnIfEmptyRequestContext(context);
       return createClientView(core, mergeAthenaRequestContexts(viewContext, context));
     }
   };
   return Object.freeze(client);
 }
+function isEmptyAthenaRequestContext(context) {
+  if (!context) return true;
+  const hasHeaders = context.headers != null && Object.keys(context.headers).length > 0;
+  return context.userId == null && context.organizationId == null && !normalizeOptionalContextString(context.cookie) && !normalizeOptionalContextString(context.bearerToken) && !normalizeOptionalContextString(context.sessionToken) && !context.forceNoCache && !hasHeaders;
+}
+function normalizeOptionalContextString(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function warnIfEmptyRequestContext(context) {
+  if (!isEmptyAthenaRequestContext(context)) return;
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+    return;
+  }
+  console.warn(
+    "[athena] withContext({}) has no userId, organizationId, cookie, bearerToken, sessionToken, headers, or forceNoCache. Gateway scope headers will not change. Pass identity fields, or use createAthenaServerClient({ session, scope })."
+  );
+}
 function createClient(config) {
   return createClientView(resolveCore(config));
 }
@@ -10770,6 +10886,339 @@ var Backend = {
   ScyllaDB: { type: "scylladb" }
 };
 
+// src/query/read-query.ts
+function normalizeAthenaReadQueryOrderBy(orderBy) {
+  if (!orderBy) {
+    return [];
+  }
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return list.filter(
+    (entry) => entry && typeof entry.column === "string" && entry.column.trim().length > 0
+  );
+}
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function flattenAthenaRowValue(row, column) {
+  if (!column.relation) {
+    return row[column.column];
+  }
+  const relationValue = row[column.relation.name];
+  if (Array.isArray(relationValue)) {
+    return relationValue.map((entry) => isRecord12(entry) ? entry[column.column] : void 0).filter((entry) => entry !== void 0);
+  }
+  if (isRecord12(relationValue)) {
+    return relationValue[column.column];
+  }
+  return void 0;
+}
+function resolveFlatRowKey(row, index, preferredKey) {
+  const preferredValue = preferredKey && preferredKey in row ? row[preferredKey] : void 0;
+  if (preferredValue !== void 0 && preferredValue !== null && `${preferredValue}`.trim().length > 0) {
+    return String(preferredValue);
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "__rowKey") {
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        return `${key}-${value.join("-")}`;
+      }
+      continue;
+    }
+    const nextValue = String(value).trim();
+    if (nextValue.length > 0) {
+      return nextValue;
+    }
+  }
+  return `row-${index + 1}`;
+}
+function flattenAthenaReadQueryRows(rows, columns, preferredKey) {
+  return rows.map((entry, index) => {
+    const sourceRow = isRecord12(entry) ? entry : {};
+    const flatRow = columns.reduce(
+      (currentRow, column) => {
+        currentRow[column.key] = flattenAthenaRowValue(sourceRow, column);
+        return currentRow;
+      },
+      { __rowKey: "" }
+    );
+    flatRow.__rowKey = resolveFlatRowKey(flatRow, index, preferredKey);
+    return flatRow;
+  });
+}
+var flattenAthenaRows = flattenAthenaReadQueryRows;
+function buildAthenaReadQuerySelectString(columns) {
+  const baseColumns = columns.filter((column) => !column.relation).map((column) => column.column);
+  const relationGroups = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!column.relation) {
+      continue;
+    }
+    const groupKey = [
+      column.relation.name,
+      column.relation.schema ?? "",
+      column.relation.table
+    ].join(":");
+    const existingGroup = relationGroups.get(groupKey);
+    if (existingGroup) {
+      if (!existingGroup.columns.includes(column.column)) {
+        existingGroup.columns.push(column.column);
+      }
+      continue;
+    }
+    relationGroups.set(groupKey, {
+      columns: [column.column],
+      relation: column.relation
+    });
+  }
+  const relationColumns = [...relationGroups.values()].map(
+    ({ columns: relationColumns2, relation }) => {
+      const relationTarget = relation.schema ? `${relation.schema}.${relation.table}` : relation.table;
+      return `${relation.name}:${relationTarget}(${relationColumns2.join(",")})`;
+    }
+  );
+  return [...baseColumns, ...relationColumns].join(",");
+}
+var buildAthenaTableSelectString = buildAthenaReadQuerySelectString;
+function buildAthenaReadQueryFindManySelect(columns) {
+  const select = {};
+  for (const column of columns) {
+    if (!column.relation) {
+      select[column.column] = true;
+      continue;
+    }
+    const existingRelation = select[column.relation.name];
+    if (existingRelation && existingRelation !== true && isRecord12(existingRelation.select)) {
+      existingRelation.select[column.column] = true;
+      continue;
+    }
+    select[column.relation.name] = {
+      ...column.relation.schema ? { schema: column.relation.schema } : {},
+      select: {
+        [column.column]: true
+      }
+    };
+  }
+  return select;
+}
+var buildAthenaTableFindManySelect = buildAthenaReadQueryFindManySelect;
+function buildAthenaReadQueryFindManyWhere(filters) {
+  if (!filters?.length) {
+    return;
+  }
+  return filters.reduce(
+    (where, filter) => {
+      const operator = filter.operator ?? "eq";
+      where[filter.column] = operator === "eq" ? filter.value : { [operator]: filter.value };
+      return where;
+    },
+    {}
+  );
+}
+var buildAthenaTableFindManyWhere = buildAthenaReadQueryFindManyWhere;
+function buildAthenaReadQueryFindManyOrderBy(orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return;
+  }
+  if (normalized.length === 1) {
+    const primary = normalized[0];
+    if (!primary) {
+      return;
+    }
+    return {
+      ascending: primary.direction !== "desc",
+      column: primary.column
+    };
+  }
+  return Object.fromEntries(
+    normalized.map((entry) => [
+      entry.column,
+      entry.direction === "desc" ? "desc" : "asc"
+    ])
+  );
+}
+var buildAthenaTableFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+var normalizeAthenaTableOrderBy = normalizeAthenaReadQueryOrderBy;
+function applyAthenaReadQueryFilters(queryBuilder, filters) {
+  if (!filters?.length) {
+    return queryBuilder;
+  }
+  return filters.reduce((currentBuilder, filter) => {
+    const operator = filter.operator ?? "eq";
+    const builderMethod = currentBuilder[operator];
+    if (typeof builderMethod !== "function") {
+      return currentBuilder;
+    }
+    return builderMethod.call(currentBuilder, filter.column, filter.value);
+  }, queryBuilder);
+}
+var applyAthenaTableFilters = applyAthenaReadQueryFilters;
+function applyAthenaReadQuerySelectOrder(queryBuilder, orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return queryBuilder;
+  }
+  return normalized.reduce(
+    (builder, entry) => builder.order(entry.column, {
+      ascending: entry.direction !== "desc"
+    }),
+    queryBuilder
+  );
+}
+var applyAthenaTableSelectOrder = applyAthenaReadQuerySelectOrder;
+function applyAthenaReadQuerySelectLimit(queryBuilder, limit) {
+  if (!limit || limit < 1) {
+    return queryBuilder;
+  }
+  return queryBuilder.limit(limit);
+}
+var applyAthenaTableSelectLimit = applyAthenaReadQuerySelectLimit;
+function clampAthenaReadQueryTotalItems(totalItems, limit) {
+  if (!limit || limit < 1) {
+    return totalItems;
+  }
+  return Math.min(totalItems, limit);
+}
+var clampAthenaTableTotalItems = clampAthenaReadQueryTotalItems;
+function resolveCountValue(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return Math.max(0, Math.trunc(candidate));
+    }
+  }
+  return 0;
+}
+function resolveTotalItemsFromPage({
+  countCandidates,
+  limit,
+  page,
+  pageSize,
+  rowCount
+}) {
+  const exactCount = resolveCountValue(...countCandidates);
+  if (exactCount > 0) {
+    return clampAthenaReadQueryTotalItems(exactCount, limit);
+  }
+  if (rowCount > 0) {
+    const base = (page - 1) * pageSize + rowCount;
+    const synthetic = rowCount >= pageSize ? base + 1 : base;
+    return clampAthenaReadQueryTotalItems(synthetic, limit);
+  }
+  return clampAthenaReadQueryTotalItems(exactCount, limit);
+}
+function resolveAthenaReadQueryPageFetch({
+  page,
+  pageSize,
+  limit
+}) {
+  const safePage = Math.max(1, Math.trunc(page) || 1);
+  const safePageSize = Math.max(1, Math.trunc(pageSize) || 1);
+  if (!limit || limit < 1) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: true };
+  }
+  const totalCap = Math.trunc(limit);
+  const offset = (safePage - 1) * safePageSize;
+  if (offset >= totalCap) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: false };
+  }
+  return {
+    page: safePage,
+    pageSize: Math.min(safePageSize, totalCap - offset),
+    shouldFetch: true
+  };
+}
+async function executeAthenaReadQuery({
+  client,
+  page,
+  pageSize,
+  query
+}) {
+  const db = client.db;
+  const baseBuilder = db.from(query.table, {
+    schema: query.schema
+  });
+  const countBuilder = applyAthenaReadQueryFilters(
+    db.from(query.table, { schema: query.schema }),
+    query.filters
+  );
+  const countResult = await countBuilder.select(query.countColumn, {
+    count: "exact",
+    head: true
+  });
+  const pageFetch = resolveAthenaReadQueryPageFetch({
+    limit: query.limit,
+    page,
+    pageSize
+  });
+  if (!pageFetch.shouldFetch) {
+    return {
+      rows: [],
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: 0
+      })
+    };
+  }
+  if ((query.mode ?? "findMany") === "select") {
+    const selectBuilder = applyAthenaReadQuerySelectOrder(
+      applyAthenaReadQueryFilters(baseBuilder, query.filters),
+      query.orderBy
+    );
+    const result2 = await selectBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+      count: "exact"
+    });
+    const rows2 = flattenAthenaReadQueryRows(
+      Array.isArray(result2.data) ? result2.data : [],
+      query.columns,
+      query.rowKey
+    );
+    return {
+      debugAst: getAthenaDebugAst(result2) ?? void 0,
+      rows: rows2,
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count, result2.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: rows2.length
+      })
+    };
+  }
+  const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
+  const findManyOptions = {
+    ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
+    select: buildAthenaReadQueryFindManySelect(query.columns),
+    ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
+  };
+  const result = await baseBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).findMany(findManyOptions);
+  const rows = flattenAthenaReadQueryRows(
+    Array.isArray(result.data) ? result.data : [],
+    query.columns,
+    query.rowKey
+  );
+  return {
+    debugAst: getAthenaDebugAst(result) ?? void 0,
+    rows,
+    totalItems: resolveTotalItemsFromPage({
+      countCandidates: [countResult.count, result.count],
+      limit: query.limit,
+      page: pageFetch.page,
+      pageSize,
+      rowCount: rows.length
+    })
+  };
+}
+var executeAthenaTableQuery = executeAthenaReadQuery;
+
 // src/schema/definitions.ts
 function defineModel(input) {
   return input;
@@ -10790,7 +11239,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -10799,7 +11248,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord12(source)) {
+  if (!isRecord13(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -11763,6 +12212,13 @@ var GATEWAY_API_KEY_ENV_KEYS = [
   "ATHENA_GATEWAY_API_KEY",
   "ATHENA_GENERATOR_API_KEY"
 ];
+var GATEWAY_CLIENT_ENV_KEYS = [
+  "ATHENA_CLIENT",
+  "ATHENA_GATEWAY_CLIENT",
+  "ATHENA_GENERATOR_CLIENT",
+  "NEXT_PUBLIC_ATHENA_CLIENT",
+  "NEXT_PUBLIC_ATHENA_GATEWAY_CLIENT"
+];
 var GENERATOR_SCHEMA_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMAS"];
 var OUTPUT_FORMAT_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_FORMAT"];
 var OUTPUT_PRESET_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_PRESET"];
@@ -12063,11 +12519,13 @@ function normalizeProviderConfig(provider) {
       GATEWAY_API_KEY_ENV_KEYS
     );
     const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? "postgres";
+    const client = normalizeOptionalString(provider.client, GATEWAY_CLIENT_ENV_KEYS);
     return {
       ...provider,
       gatewayUrl,
       apiKey,
       database,
+      ...client ? { client } : {},
       schemas: normalizeSchemaSelection(provider.schemas)
     };
   }
@@ -12261,6 +12719,7 @@ function buildEnvironmentProviderConfig() {
   const apiKey = resolveFallbackValue(GATEWAY_API_KEY_ENV_KEYS);
   if (gatewayUrl && apiKey) {
     const backend = resolveOptionalOneOf(GATEWAY_BACKEND_ENV_KEYS, BACKEND_TYPE_VALUES);
+    const client = resolveFallbackValue(GATEWAY_CLIENT_ENV_KEYS);
     return {
       kind: "postgres",
       mode: "gateway",
@@ -12268,7 +12727,8 @@ function buildEnvironmentProviderConfig() {
       apiKey,
       database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
       schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS)),
-      backend
+      backend,
+      ...client ? { client } : {}
     };
   }
   return void 0;
@@ -12316,93 +12776,576 @@ async function loadGeneratorConfig(options = {}) {
   }
 }
 
-// src/generator/env.ts
-function readEnvStringValue2(key) {
-  if (typeof process === "undefined" || !process.env) {
-    return void 0;
-  }
-  const value = process.env[key];
-  if (typeof value !== "string") {
-    return void 0;
+// src/generator/schema-discovery.ts
+var DISCOVER_POSTGRES_SCHEMAS_SQL = `
+  SELECT DISTINCT n.nspname AS schema_name
+  FROM pg_namespace n
+  JOIN pg_class c ON c.relnamespace = n.oid
+  WHERE c.relkind IN ('r', 'p')
+    AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+    AND n.nspname NOT LIKE 'pg_toast%'
+    AND n.nspname NOT LIKE 'pg_temp_%'
+    AND n.nspname NOT LIKE 'pg_toast_temp_%'
+  ORDER BY n.nspname;
+`.trim();
+var SYSTEM_SCHEMA_PREFIXES = ["pg_"];
+var SYSTEM_SCHEMAS = /* @__PURE__ */ new Set(["pg_catalog", "information_schema"]);
+function normalizeDiscoveredSchemas(input) {
+  const schemas = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of input) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMAS.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMA_PREFIXES.some((prefix) => schema.startsWith(prefix))) {
+      continue;
+    }
+    seen.add(schema);
+    schemas.push(schema);
   }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function throwMissingEnvVar(key) {
-  throw new Error(
-    `Generator config env var ${key} is missing or empty. Set ${key} or provide a default value.`
-  );
+  return schemas;
 }
-function resolveEnvValue(key, options, resolver) {
-  const rawValue = readEnvStringValue2(key);
-  if (rawValue === void 0) {
-    if (options?.default !== void 0) {
-      return options.default;
+function mergeSchemaSelections(configured, discovered) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of configured ?? []) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
     }
-    if (options?.optional) {
-      return void 0;
+    seen.add(schema);
+    result.push(schema);
+  }
+  for (const value of discovered) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
     }
-    return throwMissingEnvVar(key);
+    seen.add(schema);
+    result.push(schema);
   }
-  return resolver(rawValue);
+  return result.length > 0 ? result : ["public"];
 }
-function resolveStringEnv(key, options) {
-  return resolveEnvValue(key, options, (value) => value);
+function schemasEqual(left, right) {
+  const a = normalizeDiscoveredSchemas(left ?? []);
+  const b = normalizeDiscoveredSchemas(right ?? []);
+  if (a.length !== b.length) {
+    return false;
+  }
+  const set = new Set(a);
+  return b.every((schema) => set.has(schema));
 }
-function resolveBooleanEnv(key, options) {
-  return resolveEnvValue(key, options, (value) => parseBooleanFlag2(value, false));
+function coerceSchemaName(row) {
+  const raw = row.schema_name ?? row.schemaName ?? row.nspname;
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
 }
-function resolveListEnv(key, options) {
-  return resolveEnvValue(key, options, (value) => {
-    const separator = options?.separator ?? ",";
-    return value.split(separator).map((entry) => entry.trim()).filter((entry, index, entries) => entry.length > 0 && entries.indexOf(entry) === index);
-  })?.slice();
+async function loadPgPoolConstructor2() {
+  const module = await import('pg');
+  const poolConstructor = module.Pool ?? module.default?.Pool;
+  if (!poolConstructor) {
+    throw new Error(
+      '@xylex-group/athena: Unable to load the PostgreSQL driver for schema discovery. Ensure "pg" is installed and this API runs in a Node.js server runtime.'
+    );
+  }
+  return poolConstructor;
 }
-function resolveJsonEnv(key, options) {
-  return resolveEnvValue(key, options, (value) => {
-    try {
-      return JSON.parse(value);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Generator config env var ${key} must contain valid JSON. ${message}`);
-    }
-  });
+async function discoverDirectSchemas(config) {
+  const PoolConstructor = await loadPgPoolConstructor2();
+  const pool = new PoolConstructor({ connectionString: config.connectionString });
+  try {
+    const result = await pool.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+    const names = result.rows.map(coerceSchemaName).filter((value) => Boolean(value));
+    return normalizeDiscoveredSchemas(names);
+  } finally {
+    await pool.end();
+  }
 }
-function resolveOneOfEnv(key, allowedValues, options) {
-  return resolveEnvValue(key, options, (value) => {
-    if (allowedValues.includes(value)) {
-      return value;
+async function discoverGatewaySchemas(config) {
+  const client = createClient({
+    db: { url: config.gatewayUrl },
+    key: config.apiKey,
+    client: config.client,
+    env: typeof process !== "undefined" ? process.env : void 0,
+    backend: {
+      type: config.backend ?? "postgresql"
     }
+  });
+  const result = await client.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+  if (result.error || result.status < 200 || result.status >= 300) {
     throw new Error(
-      `Generator config env var ${key} must be one of: ${allowedValues.join(", ")}. Received: ${value}.`
+      result.error?.message ?? `Gateway schema discovery failed with status ${result.status}`
     );
-  });
-}
-function generatorEnvString(key, options) {
-  return resolveStringEnv(key, options);
-}
-function generatorEnvBoolean(key, options) {
-  return resolveBooleanEnv(key, options);
-}
-function generatorEnvList(key, options) {
-  return resolveListEnv(key, options);
-}
-function generatorEnvJson(key, options) {
-  return resolveJsonEnv(key, options);
-}
-function generatorEnvOneOf(key, allowedValues, options) {
-  return resolveOneOfEnv(key, allowedValues, options);
+  }
+  const names = (result.data ?? []).map(coerceSchemaName).filter((value) => Boolean(value));
+  return normalizeDiscoveredSchemas(names);
 }
-var generatorEnv = Object.assign(generatorEnvString, {
-  boolean: generatorEnvBoolean,
-  list: generatorEnvList,
-  json: generatorEnvJson,
-  oneOf: generatorEnvOneOf
-});
-
-// src/utils/slugify.ts
-function slugify(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+async function discoverPostgresSchemas(provider) {
+  if (provider.kind === "postgres" && provider.mode === "direct") {
+    return discoverDirectSchemas(provider);
+  }
+  if (provider.kind === "postgres" && provider.mode === "gateway") {
+    return discoverGatewaySchemas(provider);
+  }
+  throw new Error(
+    `Schema discovery is only implemented for postgres direct/gateway providers (received ${provider.kind}/${"mode" in provider ? provider.mode : "unknown"}).`
+  );
+}
+
+// src/generator/config-file.ts
+function hasEnv(keys) {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var DIRECT_CONNECTION_KEYS = [
+  "ATHENA_GENERATOR_PG_URL",
+  "DATABASE_URL",
+  "PG_URL",
+  "POSTGRES_URL",
+  "POSTGRESQL_URL"
+];
+var GATEWAY_URL_KEYS = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
+var GATEWAY_KEY_KEYS = [
+  "ATHENA_API_KEY",
+  "ATHENA_GATEWAY_API_KEY",
+  "ATHENA_GENERATOR_API_KEY"
+];
+function detectGeneratorProviderMode(preferred = "auto") {
+  if (preferred === "direct" || preferred === "gateway") {
+    return preferred;
+  }
+  const hasDirect = hasEnv(DIRECT_CONNECTION_KEYS);
+  const hasGateway = hasEnv(GATEWAY_URL_KEYS) && hasEnv(GATEWAY_KEY_KEYS);
+  if (hasDirect) {
+    return "direct";
+  }
+  if (hasGateway) {
+    return "gateway";
+  }
+  return "direct";
+}
+function formatStringArray(values, indent) {
+  if (values.length === 0) {
+    return "[]";
+  }
+  const inner = values.map((value) => `${indent}  ${JSON.stringify(value)}`).join(",\n");
+  return `[
+${inner},
+${indent}]`;
+}
+function buildDirectProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "direct",
+    connectionString: generatorEnv("DATABASE_URL"),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { optional: true }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function buildGatewayProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "gateway",
+    gatewayUrl: generatorEnv("ATHENA_URL"),
+    apiKey: generatorEnv("ATHENA_API_KEY"),
+    client: generatorEnv("ATHENA_CLIENT", { optional: true }),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { default: "postgres" }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function renderGeneratorConfigFile(options) {
+  const schemas = options.schemas && options.schemas.length > 0 ? [...options.schemas] : [...DEFAULT_POSTGRES_SCHEMAS];
+  const providerBlock = options.mode === "gateway" ? buildGatewayProviderBlock(schemas) : buildDirectProviderBlock(schemas);
+  return `import { defineGeneratorConfig, generatorEnv } from "@xylex-group/athena";
+
+export default defineGeneratorConfig({
+${providerBlock},
+  output: {
+    format: "table-builder",
+    preset: "athena-direct",
+    targets: {
+      model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+      schema: "athena/schemas/{schema_kebab}.ts",
+      database: "athena/relations.ts",
+      registry: "athena/registry.generated.ts",
+    },
+    placeholderMap: {
+      namespace: "athena",
+    },
+  },
+  naming: {
+    modelType: "pascal",
+    modelConst: "camel",
+    schemaConst: "camel",
+    databaseConst: "camel",
+    registryConst: "camel",
+  },
+  features: {
+    emitRelations: true,
+    emitRegistry: true,
+  },
+  experimental: {
+    postgresGatewayIntrospection: false,
+    scyllaProviderContracts: true,
+  },
+});
+`;
+}
+function resolveConfigPath(cwd, configPath) {
+  if (configPath) {
+    const absolutePath2 = path.resolve(cwd, configPath);
+    return {
+      absolutePath: absolutePath2,
+      relativePath: configPath.replace(/\\/g, "/"),
+      exists: fs.existsSync(absolutePath2)
+    };
+  }
+  const discovered = findGeneratorConfigPath(cwd);
+  if (discovered) {
+    const relativePath = discovered.startsWith(cwd) ? discovered.slice(cwd.length).replace(/^[/\\]/, "").replace(/\\/g, "/") : "athena.config.ts";
+    return {
+      absolutePath: discovered,
+      relativePath,
+      exists: true
+    };
+  }
+  const absolutePath = path.resolve(cwd, "athena.config.ts");
+  return {
+    absolutePath,
+    relativePath: "athena.config.ts",
+    exists: false
+  };
+}
+function providerModeFromConfig(provider, preferred) {
+  if (provider && provider.kind === "postgres") {
+    if (provider.mode === "gateway") {
+      return "gateway";
+    }
+    if (provider.mode === "direct") {
+      return "direct";
+    }
+  }
+  return detectGeneratorProviderMode(preferred);
+}
+function schemasFromNormalized(config) {
+  if (config.provider.kind !== "postgres") {
+    return [...DEFAULT_POSTGRES_SCHEMAS];
+  }
+  return normalizeSchemaSelection(config.provider.schemas);
+}
+function patchSchemasInConfigSource(source, schemas) {
+  const formattedInline = `[${schemas.map((value) => JSON.stringify(value)).join(", ")}]`;
+  const formattedMultiline = formatStringArray(schemas, "    ");
+  const listDefaultPattern = /(schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*)(\[[^\]]*\])/m;
+  if (listDefaultPattern.test(source)) {
+    return source.replace(listDefaultPattern, `$1${formattedInline}`);
+  }
+  const literalPattern = /(schemas\s*:\s*)(\[[^\]]*\])/m;
+  if (literalPattern.test(source)) {
+    const usesMultiline = /schemas\s*:\s*\[\s*\n/.test(source);
+    return source.replace(
+      literalPattern,
+      `$1${usesMultiline ? formattedMultiline : formattedInline}`
+    );
+  }
+  const modeLine = /(mode\s*:\s*["'](?:direct|gateway)["']\s*,)/m;
+  if (modeLine.test(source)) {
+    return source.replace(
+      modeLine,
+      `$1
+    schemas: ${formattedInline},`
+    );
+  }
+  return void 0;
+}
+function extractLiteralSchemas(source) {
+  const listDefaultMatch = source.match(
+    /schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*(\[[^\]]*\])/m
+  );
+  const literalMatch = listDefaultMatch ?? source.match(/schemas\s*:\s*(\[[^\]]*\])/m);
+  if (!literalMatch) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(literalMatch[1].replace(/'/g, '"'));
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveDiscoveredSchemas(options) {
+  if (options.explicit && options.explicit.length > 0) {
+    return {
+      schemas: normalizeSchemaSelection(options.explicit),
+      discovered: false
+    };
+  }
+  if (!options.discoverSchemas) {
+    if (options.loaded) {
+      return {
+        schemas: schemasFromNormalized(options.loaded.config),
+        discovered: false
+      };
+    }
+    return {
+      schemas: [...DEFAULT_POSTGRES_SCHEMAS],
+      discovered: false
+    };
+  }
+  try {
+    let provider = options.provider;
+    if (!provider && options.loaded) {
+      provider = options.loaded.config.provider;
+    }
+    if (!provider) {
+      const probeConfig = {
+        provider: options.mode === "gateway" ? { kind: "postgres", mode: "gateway" } : { kind: "postgres", mode: "direct" }
+      };
+      const normalized = normalizeGeneratorConfig(probeConfig);
+      provider = normalized.provider;
+    }
+    const discovered = await discoverPostgresSchemas(provider);
+    if (discovered.length === 0) {
+      const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+      return { schemas: fallback, discovered: true };
+    }
+    if (options.loaded) {
+      return {
+        schemas: mergeSchemaSelections(schemasFromNormalized(options.loaded.config), discovered),
+        discovered: true
+      };
+    }
+    return { schemas: discovered, discovered: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+    return {
+      schemas: fallback,
+      discovered: false,
+      discoveryError: message
+    };
+  }
+}
+async function ensureGeneratorConfigFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const discoverSchemas = options.discoverSchemas !== false;
+  const force = options.force === true;
+  const preferredMode = options.mode ?? "auto";
+  const pathInfo = resolveConfigPath(cwd, options.configPath);
+  const changes = [];
+  let loaded = options.loaded;
+  if (!loaded && pathInfo.exists && !force) {
+    try {
+      loaded = await loadGeneratorConfig({
+        cwd,
+        configPath: pathInfo.absolutePath
+      });
+    } catch {
+    }
+  }
+  const mode = providerModeFromConfig(loaded?.config.provider ?? options.provider, preferredMode);
+  const schemaResolution = await resolveDiscoveredSchemas({
+    discoverSchemas,
+    provider: options.provider ?? loaded?.config.provider,
+    loaded,
+    explicit: options.schemas,
+    mode
+  });
+  if (schemaResolution.discoveryError) {
+    changes.push(`schema-discovery-failed: ${schemaResolution.discoveryError}`);
+  } else if (schemaResolution.discovered) {
+    changes.push(`schemas-discovered: ${schemaResolution.schemas.join(",")}`);
+  }
+  if (!pathInfo.exists || force) {
+    const content = renderGeneratorConfigFile({
+      mode,
+      schemas: schemaResolution.schemas
+    });
+    if (!pathInfo.exists) {
+      changes.push("created-modern-config");
+    } else {
+      changes.push("force-rewrote-config");
+    }
+    if (!dryRun) {
+      await promises.mkdir(path.dirname(pathInfo.absolutePath), { recursive: true });
+      await promises.writeFile(pathInfo.absolutePath, content, "utf8");
+    }
+    return {
+      action: pathInfo.exists ? "updated" : "created",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content,
+      schemas: schemaResolution.schemas,
+      changes,
+      mode,
+      reason: pathInfo.exists ? "force rewrite" : "config file missing"
+    };
+  }
+  const existingSource = await promises.readFile(pathInfo.absolutePath, "utf8");
+  const existingLiteralSchemas = extractLiteralSchemas(existingSource);
+  const existingSchemas = existingLiteralSchemas ?? (loaded ? schemasFromNormalized(loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS]);
+  if (schemasEqual(existingSchemas, schemaResolution.schemas)) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: changes.length > 0 ? changes : ["schemas-already-current"],
+      mode,
+      reason: "schemas already match discovered/configured set"
+    };
+  }
+  const patched = patchSchemasInConfigSource(existingSource, schemaResolution.schemas);
+  if (!patched) {
+    return {
+      action: "skipped",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [
+        ...changes,
+        "could-not-patch-schemas-surgically",
+        "re-run with force=true to rewrite full template"
+      ],
+      mode,
+      reason: "existing config schemas could not be updated surgically without risking a destructive rewrite"
+    };
+  }
+  if (patched === existingSource) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [...changes, "patch-noop"],
+      mode,
+      reason: "patch produced identical content"
+    };
+  }
+  changes.push(
+    `schemas-updated: ${existingSchemas.join(",")} -> ${schemaResolution.schemas.join(",")}`
+  );
+  if (!dryRun) {
+    await promises.writeFile(pathInfo.absolutePath, patched, "utf8");
+  }
+  return {
+    action: "updated",
+    path: pathInfo.relativePath,
+    absolutePath: pathInfo.absolutePath,
+    content: patched,
+    schemas: schemaResolution.schemas,
+    changes,
+    mode,
+    reason: "auto-filled provider.schemas"
+  };
+}
+
+// src/generator/env.ts
+function readEnvStringValue2(key) {
+  if (typeof process === "undefined" || !process.env) {
+    return void 0;
+  }
+  const value = process.env[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function throwMissingEnvVar(key) {
+  throw new Error(
+    `Generator config env var ${key} is missing or empty. Set ${key} or provide a default value.`
+  );
+}
+function resolveEnvValue(key, options, resolver) {
+  const rawValue = readEnvStringValue2(key);
+  if (rawValue === void 0) {
+    if (options?.default !== void 0) {
+      return options.default;
+    }
+    if (options?.optional) {
+      return void 0;
+    }
+    return throwMissingEnvVar(key);
+  }
+  return resolver(rawValue);
+}
+function resolveStringEnv(key, options) {
+  return resolveEnvValue(key, options, (value) => value);
+}
+function resolveBooleanEnv(key, options) {
+  return resolveEnvValue(key, options, (value) => parseBooleanFlag2(value, false));
+}
+function resolveListEnv(key, options) {
+  return resolveEnvValue(key, options, (value) => {
+    const separator = options?.separator ?? ",";
+    return value.split(separator).map((entry) => entry.trim()).filter((entry, index, entries) => entry.length > 0 && entries.indexOf(entry) === index);
+  })?.slice();
+}
+function resolveJsonEnv(key, options) {
+  return resolveEnvValue(key, options, (value) => {
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Generator config env var ${key} must contain valid JSON. ${message}`);
+    }
+  });
+}
+function resolveOneOfEnv(key, allowedValues, options) {
+  return resolveEnvValue(key, options, (value) => {
+    if (allowedValues.includes(value)) {
+      return value;
+    }
+    throw new Error(
+      `Generator config env var ${key} must be one of: ${allowedValues.join(", ")}. Received: ${value}.`
+    );
+  });
+}
+function generatorEnvString(key, options) {
+  return resolveStringEnv(key, options);
+}
+function generatorEnvBoolean(key, options) {
+  return resolveBooleanEnv(key, options);
+}
+function generatorEnvList(key, options) {
+  return resolveListEnv(key, options);
+}
+function generatorEnvJson(key, options) {
+  return resolveJsonEnv(key, options);
+}
+function generatorEnvOneOf(key, allowedValues, options) {
+  return resolveOneOfEnv(key, allowedValues, options);
+}
+var generatorEnv = Object.assign(generatorEnvString, {
+  boolean: generatorEnvBoolean,
+  list: generatorEnvList,
+  json: generatorEnvJson,
+  oneOf: generatorEnvOneOf
+});
+
+// src/utils/slugify.ts
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
 }
 
 // src/generator/naming.ts
@@ -13041,7 +13984,7 @@ function renderModelArtifact(descriptor, config) {
   const relationsAssignment = config.features.emitRelations && relationEntries.length > 0 ? `
 Object.assign(${descriptor.tableConstName}.meta, {
   relations: {
-${relationEntries.map(([relationKey2, relationValue]) => `    ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+${relationEntries.map(([relationKey3, relationValue]) => `    ${renderObjectKey(relationKey3)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
   }
 })
 ` : "";
@@ -13118,7 +14061,7 @@ function renderModelArtifact2(databaseName, descriptor, config) {
   const relationEntries = Object.entries(descriptor.table.relations);
   const relationBlock = config.features.emitRelations && relationEntries.length > 0 ? `,
     relations: {
-${relationEntries.map(([relationKey2, relationValue]) => `      ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+${relationEntries.map(([relationKey3, relationValue]) => `      ${renderObjectKey(relationKey3)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
     }` : "";
   const content = `import { defineModel } from '@xylex-group/athena'
 
@@ -13227,6 +14170,11 @@ var AthenaGatewayPostgresIntrospectionProvider = class {
     this.client = createClient({
       db: { url: this.config.gatewayUrl },
       key: this.config.apiKey,
+      // Multi-tenant gateways reject DEFAULT_CLIENT; prefer explicit config.
+      // Also pass process.env so ATHENA_CLIENT / ATHENA_GATEWAY_CLIENT still resolve
+      // when the field was not normalized into provider config.
+      client: this.config.client,
+      env: typeof process !== "undefined" ? process.env : void 0,
       backend: {
         type: this.config.backend ?? "postgresql"
       }
@@ -14127,23 +15075,80 @@ async function writeArtifacts(files, cwd, config, dryRun) {
     skippedFiles
   };
 }
+function withPostgresSchemas(config, schemas) {
+  if (config.provider.kind !== "postgres") {
+    return config;
+  }
+  return {
+    ...config,
+    provider: {
+      ...config.provider,
+      schemas
+    }
+  };
+}
 async function runSchemaGenerator(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const writeConfig = options.writeConfig !== false;
+  const discoverSchemas = options.discoverSchemas !== false;
   const configOptions = {
     cwd,
     configPath: options.configPath
   };
-  const { configPath, config } = await loadGeneratorConfig(configOptions);
+  const loaded = await loadGeneratorConfig(configOptions);
+  let { configPath, config } = loaded;
+  let configEnsure;
+  let effectiveSchemas = resolveProviderSchemas(config.provider);
+  const canDiscoverLive = discoverSchemas && config.provider.kind === "postgres" && !options.provider;
+  if (canDiscoverLive) {
+    try {
+      const discovered = await discoverPostgresSchemas(config.provider);
+      if (discovered.length > 0) {
+        effectiveSchemas = mergeSchemaSelections(effectiveSchemas, discovered);
+      }
+    } catch {
+    }
+  }
+  config = withPostgresSchemas(config, effectiveSchemas);
+  const shouldEnsureConfig = writeConfig && config.provider.kind === "postgres" && !options.provider;
+  if (shouldEnsureConfig) {
+    const ensureResult = await ensureGeneratorConfigFile({
+      cwd,
+      configPath: options.configPath,
+      dryRun,
+      // Schemas already resolved above — avoid a second discovery round-trip.
+      discoverSchemas: false,
+      provider: config.provider,
+      loaded: { configPath, config },
+      schemas: effectiveSchemas,
+      mode: config.provider.mode
+    });
+    configEnsure = {
+      action: ensureResult.action,
+      path: ensureResult.path,
+      schemas: ensureResult.schemas,
+      changes: ensureResult.changes,
+      reason: ensureResult.reason
+    };
+    if (ensureResult.action === "created" || ensureResult.action === "updated" || ensureResult.action === "unchanged" && configPath === "[environment defaults]") {
+      configPath = ensureResult.absolutePath;
+      if (ensureResult.schemas.length > 0) {
+        effectiveSchemas = ensureResult.schemas;
+        config = withPostgresSchemas(config, effectiveSchemas);
+      }
+    }
+  }
   const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
   const snapshot = await provider.inspect({
-    schemas: resolveProviderSchemas(config.provider)
+    schemas: effectiveSchemas
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
   const writeResult = await writeArtifacts(
     generated.files,
     cwd,
     config,
-    options.dryRun === true
+    dryRun
   );
   return {
     ...generated,
@@ -14151,7 +15156,8 @@ async function runSchemaGenerator(options = {}) {
     config,
     writtenFiles: writeResult.writtenFiles,
     writtenDetails: writeResult.writtenDetails,
-    skippedFiles: writeResult.skippedFiles
+    skippedFiles: writeResult.skippedFiles,
+    configEnsure
   };
 }
 
@@ -14220,15 +15226,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord13(value)) {
+  if (!isRecord14(value)) {
     return null;
   }
-  const session = isRecord13(value.session) ? value.session : void 0;
-  const user = isRecord13(value.user) ? value.user : void 0;
+  const session = isRecord14(value.session) ? value.session : void 0;
+  const user = isRecord14(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -14238,7 +15244,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {
@@ -14649,12 +15655,439 @@ async function ensureActiveOrganization(options) {
   }
 }
 
+// src/tables/catalog.ts
+var POSTGRES_CATALOG_SQL2 = {
+  columns: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      a.attname AS column_name,
+      format_type(a.atttypid, a.atttypmod) AS data_type,
+      NOT a.attnotnull AS is_nullable
+    FROM pg_attribute a
+    JOIN pg_class c ON c.oid = a.attrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE c.relkind IN ('r', 'p')
+      AND a.attnum > 0
+      AND NOT a.attisdropped
+      AND n.nspname = ANY($1::text[])
+    ORDER BY n.nspname, c.relname, a.attnum;
+  `,
+  foreignKeys: `
+    SELECT
+      sn.nspname AS source_schema,
+      sc.relname AS source_table,
+      con.conname AS constraint_name,
+      ARRAY_AGG(sa.attname ORDER BY cols.ordinality) AS source_columns,
+      tn.nspname AS target_schema,
+      tc.relname AS target_table,
+      ARRAY_AGG(ta.attname ORDER BY cols.ordinality) AS target_columns,
+      EXISTS (
+        SELECT 1
+        FROM pg_constraint uq
+        WHERE uq.conrelid = con.conrelid
+          AND uq.contype IN ('p', 'u')
+          AND uq.conkey = con.conkey
+      ) AS source_is_unique
+    FROM pg_constraint con
+    JOIN pg_class sc ON sc.oid = con.conrelid
+    JOIN pg_namespace sn ON sn.oid = sc.relnamespace
+    JOIN pg_class tc ON tc.oid = con.confrelid
+    JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+    JOIN unnest(con.conkey, con.confkey) WITH ORDINALITY AS cols(source_attnum, target_attnum, ordinality) ON TRUE
+    JOIN pg_attribute sa ON sa.attrelid = con.conrelid AND sa.attnum = cols.source_attnum
+    JOIN pg_attribute ta ON ta.attrelid = con.confrelid AND ta.attnum = cols.target_attnum
+    WHERE con.contype = 'f'
+      AND sn.nspname = ANY($1::text[])
+      AND tn.nspname = ANY($1::text[])
+    GROUP BY
+      sn.nspname,
+      sc.relname,
+      con.conname,
+      tn.nspname,
+      tc.relname,
+      con.conkey,
+      con.conrelid
+    ORDER BY sn.nspname, sc.relname, con.conname;
+  `,
+  primaryKeys: `
+    SELECT
+      n.nspname AS schema_name,
+      c.relname AS table_name,
+      ARRAY_AGG(a.attname ORDER BY ck.ordinality) AS columns
+    FROM pg_constraint con
+    JOIN pg_class c ON c.oid = con.conrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    JOIN unnest(con.conkey) WITH ORDINALITY AS ck(attnum, ordinality) ON TRUE
+    JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ck.attnum
+    WHERE con.contype = 'p'
+      AND n.nspname = ANY($1::text[])
+    GROUP BY n.nspname, c.relname
+    ORDER BY n.nspname, c.relname;
+  `
+};
+function parseAthenaTableSchemaScope(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(
+    (entry, index, values) => entry.length > 0 && values.indexOf(entry) === index
+  );
+}
+function escapeSqlLiteral2(value) {
+  return value.replace(/'/g, "''");
+}
+function buildSchemaArrayLiteral2(schemas) {
+  const literals = schemas.map((schema) => `'${escapeSqlLiteral2(schema)}'`).join(", ");
+  return `ARRAY[${literals}]`;
+}
+function inlineSchemaLiteral2(sql, schemas) {
+  return sql.replace(
+    /\$1::text\[\]/g,
+    `${buildSchemaArrayLiteral2(schemas)}::text[]`
+  );
+}
+function buildAthenaTableCatalogQueries(schemas) {
+  return {
+    columns: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.columns, schemas),
+    foreignKeys: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.foreignKeys, schemas),
+    primaryKeys: inlineSchemaLiteral2(POSTGRES_CATALOG_SQL2.primaryKeys, schemas)
+  };
+}
+function tableKey2(schema, table2) {
+  return `${schema}.${table2}`;
+}
+function relationKey2(...parts) {
+  const base = parts.join("_").replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
+  return base.length > 0 ? base : "relation";
+}
+function parsePostgresArrayLiteral2(text) {
+  const body = text.slice(1, -1).trim();
+  if (!body) {
+    return [];
+  }
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function coerceStringArray2(value) {
+  if (value == null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (typeof value !== "string") {
+    return [];
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    return [];
+  }
+  if (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) {
+    return parsePostgresArrayLiteral2(trimmedValue);
+  }
+  return trimmedValue.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function createTableCatalog() {
+  const tables = /* @__PURE__ */ new Map();
+  const ensureTable = (schema, name) => {
+    const id = tableKey2(schema, name);
+    const existingTable = tables.get(id);
+    if (existingTable) {
+      return existingTable;
+    }
+    const nextTable = {
+      columns: [],
+      id,
+      name,
+      primaryKey: [],
+      relationMap: /* @__PURE__ */ new Map(),
+      schema
+    };
+    tables.set(id, nextTable);
+    return nextTable;
+  };
+  const upsertRelation = (table2, key, relation) => {
+    table2.relationMap.set(key, relation);
+  };
+  return {
+    addColumnRows(columnRows) {
+      for (const row of columnRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        table2.columns.push({
+          dataType: row.data_type,
+          isNullable: row.is_nullable,
+          isPrimaryKey: false,
+          name: row.column_name
+        });
+      }
+    },
+    addForeignKeyRows(foreignKeyRows) {
+      for (const row of foreignKeyRows) {
+        const sourceTable = ensureTable(row.source_schema, row.source_table);
+        const targetTable = ensureTable(row.target_schema, row.target_table);
+        upsertRelation(
+          sourceTable,
+          relationKey2(row.constraint_name, row.target_table),
+          {
+            name: row.constraint_name,
+            targetSchema: row.target_schema,
+            targetTable: row.target_table
+          }
+        );
+        upsertRelation(targetTable, relationKey2(row.source_table), {
+          name: relationKey2(row.source_table, row.constraint_name),
+          targetSchema: row.source_schema,
+          targetTable: row.source_table
+        });
+      }
+    },
+    addManyToManyRows(foreignKeyRows) {
+      const foreignKeysBySourceTable = /* @__PURE__ */ new Map();
+      for (const foreignKey of foreignKeyRows) {
+        const key = tableKey2(foreignKey.source_schema, foreignKey.source_table);
+        const current = foreignKeysBySourceTable.get(key) ?? {
+          foreignKeys: [],
+          schema: foreignKey.source_schema,
+          table: foreignKey.source_table
+        };
+        current.foreignKeys.push(foreignKey);
+        foreignKeysBySourceTable.set(key, current);
+      }
+      for (const candidate of foreignKeysBySourceTable.values()) {
+        const bridgeTable = tables.get(
+          tableKey2(candidate.schema, candidate.table)
+        );
+        if (!bridgeTable || candidate.foreignKeys.length !== 2) {
+          continue;
+        }
+        const combinedForeignColumns = Array.from(
+          new Set(
+            candidate.foreignKeys.flatMap(
+              (foreignKey) => coerceStringArray2(foreignKey.source_columns)
+            )
+          )
+        );
+        if (bridgeTable.primaryKey.length === 0 || combinedForeignColumns.length !== bridgeTable.primaryKey.length || !bridgeTable.primaryKey.every(
+          (column) => combinedForeignColumns.includes(column)
+        )) {
+          continue;
+        }
+        const [firstForeignKey, secondForeignKey] = candidate.foreignKeys;
+        const firstTarget = tables.get(
+          tableKey2(firstForeignKey.target_schema, firstForeignKey.target_table)
+        );
+        const secondTarget = tables.get(
+          tableKey2(
+            secondForeignKey.target_schema,
+            secondForeignKey.target_table
+          )
+        );
+        if (!(firstTarget && secondTarget)) {
+          continue;
+        }
+        upsertRelation(
+          firstTarget,
+          relationKey2(candidate.table, secondForeignKey.target_table),
+          {
+            name: relationKey2(
+              candidate.table,
+              secondForeignKey.constraint_name
+            ),
+            targetSchema: secondForeignKey.target_schema,
+            targetTable: secondForeignKey.target_table
+          }
+        );
+        upsertRelation(
+          secondTarget,
+          relationKey2(candidate.table, firstForeignKey.target_table),
+          {
+            name: relationKey2(candidate.table, firstForeignKey.constraint_name),
+            targetSchema: firstForeignKey.target_schema,
+            targetTable: firstForeignKey.target_table
+          }
+        );
+      }
+    },
+    addPrimaryKeyRows(primaryKeyRows) {
+      for (const row of primaryKeyRows) {
+        const table2 = ensureTable(row.schema_name, row.table_name);
+        const primaryKey = coerceStringArray2(row.columns);
+        table2.primaryKey = primaryKey;
+        for (const columnName of primaryKey) {
+          const column = table2.columns.find(
+            (candidate) => candidate.name === columnName
+          );
+          if (column) {
+            column.isPrimaryKey = true;
+          }
+        }
+      }
+    },
+    toResponse(database) {
+      return {
+        database,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tables: [...tables.values()].map((table2) => ({
+          columns: [...table2.columns].sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          id: table2.id,
+          name: table2.name,
+          primaryKey: [...table2.primaryKey],
+          relations: [...table2.relationMap.values()].map((relation) => ({
+            columns: tables.get(
+              tableKey2(relation.targetSchema, relation.targetTable)
+            )?.columns ?? [],
+            name: relation.name,
+            targetSchema: relation.targetSchema,
+            targetTable: relation.targetTable
+          })).sort(
+            (left, right) => left.name.localeCompare(right.name)
+          ),
+          schema: table2.schema
+        })).sort(
+          (left, right) => left.id.localeCompare(right.id)
+        )
+      };
+    }
+  };
+}
+async function queryRows(client, query) {
+  const result = await client.query(query);
+  if (result.error || result.status < 200 || result.status >= 300) {
+    const errorMessage = typeof result.error === "string" ? result.error : result.error && typeof result.error === "object" && "message" in result.error && typeof result.error.message === "string" ? result.error.message : `Athena gateway query failed with status ${result.status}.`;
+    throw new Error(errorMessage);
+  }
+  return Array.isArray(result.data) ? result.data : [];
+}
+function isAthenaTableSchemaConfig(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const config = value;
+  return typeof config.gatewayUrl === "string" && typeof config.gatewayKey === "string" && typeof config.gatewayDatabase === "string" && typeof config.schemaScope === "string" && typeof config.clientName === "string";
+}
+function hasAthenaTableSchemaCredentials(config) {
+  return config.gatewayUrl.trim().length > 0 && config.gatewayKey.trim().length > 0 && config.gatewayDatabase.trim().length > 0;
+}
+async function fetchAthenaTableCatalog(config, options = {}) {
+  const schemas = parseAthenaTableSchemaScope(config.schemaScope);
+  if (schemas.length === 0) {
+    return {
+      database: config.gatewayDatabase,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tables: []
+    };
+  }
+  const queries = buildAthenaTableCatalogQueries(schemas);
+  const client = options.client ?? createClient({
+    url: config.gatewayUrl.trim(),
+    key: config.gatewayKey.trim(),
+    client: config.clientName.trim() || void 0
+  });
+  const [columnRows, primaryKeyRows, foreignKeyRows] = await Promise.all([
+    queryRows(client, queries.columns),
+    queryRows(client, queries.primaryKeys),
+    queryRows(client, queries.foreignKeys)
+  ]);
+  const catalog = createTableCatalog();
+  catalog.addColumnRows(columnRows);
+  catalog.addPrimaryKeyRows(primaryKeyRows);
+  catalog.addForeignKeyRows(foreignKeyRows);
+  catalog.addManyToManyRows(foreignKeyRows);
+  return catalog.toResponse(config.gatewayDatabase);
+}
+var fetchTableCatalog = fetchAthenaTableCatalog;
+
+// src/tables/schema-handlers.ts
+var ATHENA_TABLE_SCHEMA_ROUTE = "/api/tables/schema";
+function json2(body, init) {
+  const headers = new Headers(init?.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+async function handleAthenaTableSchemaPost(request2, options) {
+  const payload = await request2.json().catch(() => null);
+  let config = isAthenaTableSchemaConfig(
+    payload?.config
+  ) ? payload.config : null;
+  if (config && options?.resolveConfig) {
+    config = await options.resolveConfig(config, request2);
+  }
+  if (!config || !isAthenaTableSchemaConfig(config)) {
+    return json2(
+      {
+        error: "The Athena tables showcase config is invalid."
+      },
+      { status: 400 }
+    );
+  }
+  if (!hasAthenaTableSchemaCredentials(config)) {
+    return json2(
+      {
+        error: "Gateway URL, API key, and database are required for schema introspection."
+      },
+      { status: 400 }
+    );
+  }
+  try {
+    const response = await fetchAthenaTableCatalog(
+      config,
+      {
+        client: options?.client
+      }
+    );
+    return json2(response);
+  } catch (error) {
+    return json2(
+      {
+        error: error instanceof Error ? error.message : "Athena schema introspection failed."
+      },
+      { status: 500 }
+    );
+  }
+}
+function createAthenaTableSchemaHandlers(options) {
+  return {
+    POST: (request2) => handleAthenaTableSchemaPost(request2, options)
+  };
+}
+
 exports.ATHENA_AUTH_ADMIN_LIMITS = ATHENA_AUTH_ADMIN_LIMITS;
 exports.ATHENA_AUTH_BASE_ERROR_CODES = ATHENA_AUTH_BASE_ERROR_CODES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = ATHENA_AUTH_MAX_ADMIN_JSON_BYTES;
 exports.ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = ATHENA_AUTH_MAX_TEMPLATE_VARIABLES;
 exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH;
+exports.ATHENA_TABLE_SCHEMA_ROUTE = ATHENA_TABLE_SCHEMA_ROUTE;
 exports.AthenaBillingError = AthenaBillingError;
 exports.AthenaChatError = AthenaChatError;
 exports.AthenaConfigurationError = AthenaConfigurationError;
@@ -14669,13 +16102,31 @@ exports.Backend = Backend;
 exports.DEFAULT_MULTIPART_PART_SIZE_BYTES = DEFAULT_MULTIPART_PART_SIZE_BYTES;
 exports.DEFAULT_MULTIPART_THRESHOLD_BYTES = DEFAULT_MULTIPART_THRESHOLD_BYTES;
 exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
+exports.applyAthenaReadQueryFilters = applyAthenaReadQueryFilters;
+exports.applyAthenaReadQuerySelectLimit = applyAthenaReadQuerySelectLimit;
+exports.applyAthenaReadQuerySelectOrder = applyAthenaReadQuerySelectOrder;
+exports.applyAthenaTableFilters = applyAthenaTableFilters;
+exports.applyAthenaTableSelectLimit = applyAthenaTableSelectLimit;
+exports.applyAthenaTableSelectOrder = applyAthenaTableSelectOrder;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
 exports.billingSdkManifest = billingSdkManifest;
 exports.boolean = boolean;
+exports.buildAthenaReadQueryFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+exports.buildAthenaReadQueryFindManySelect = buildAthenaReadQueryFindManySelect;
+exports.buildAthenaReadQueryFindManyWhere = buildAthenaReadQueryFindManyWhere;
+exports.buildAthenaReadQuerySelectString = buildAthenaReadQuerySelectString;
+exports.buildAthenaTableCatalogQueries = buildAthenaTableCatalogQueries;
+exports.buildAthenaTableFindManyOrderBy = buildAthenaTableFindManyOrderBy;
+exports.buildAthenaTableFindManySelect = buildAthenaTableFindManySelect;
+exports.buildAthenaTableFindManyWhere = buildAthenaTableFindManyWhere;
+exports.buildAthenaTableSelectString = buildAthenaTableSelectString;
 exports.chatSdkManifest = chatSdkManifest;
+exports.clampAthenaReadQueryTotalItems = clampAthenaReadQueryTotalItems;
+exports.clampAthenaTableTotalItems = clampAthenaTableTotalItems;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
+exports.createAthenaTableSchemaHandlers = createAthenaTableSchemaHandlers;
 exports.createAuthReactEmailInput = createAuthReactEmailInput;
 exports.createBillingModule = createBillingModule;
 exports.createClient = createClient;
@@ -14689,33 +16140,54 @@ exports.defineGeneratorConfig = defineGeneratorConfig;
 exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
+exports.detectGeneratorProviderMode = detectGeneratorProviderMode;
+exports.discoverPostgresSchemas = discoverPostgresSchemas;
 exports.ensureActiveOrganization = ensureActiveOrganization;
+exports.ensureGeneratorConfigFile = ensureGeneratorConfigFile;
 exports.enumeration = enumeration;
+exports.executeAthenaReadQuery = executeAthenaReadQuery;
+exports.executeAthenaTableQuery = executeAthenaTableQuery;
+exports.fetchAthenaTableCatalog = fetchAthenaTableCatalog;
+exports.fetchTableCatalog = fetchTableCatalog;
 exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
+exports.flattenAthenaReadQueryRows = flattenAthenaReadQueryRows;
+exports.flattenAthenaRows = flattenAthenaRows;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
 exports.getAthenaDebugAst = getAthenaDebugAst;
+exports.handleAthenaTableSchemaPost = handleAthenaTableSchemaPost;
+exports.hasAthenaTableSchemaCredentials = hasAthenaTableSchemaCredentials;
 exports.identifier = identifier;
 exports.isAthenaGatewayError = isAthenaGatewayError;
+exports.isAthenaTableSchemaConfig = isAthenaTableSchemaConfig;
 exports.isOk = isOk;
 exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
+exports.mergeSchemaSelections = mergeSchemaSelections;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
+exports.normalizeAthenaReadQueryOrderBy = normalizeAthenaReadQueryOrderBy;
+exports.normalizeAthenaTableOrderBy = normalizeAthenaTableOrderBy;
+exports.normalizeDiscoveredSchemas = normalizeDiscoveredSchemas;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
 exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
+exports.parseAthenaTableSchemaScope = parseAthenaTableSchemaScope;
 exports.parseBooleanFlag = parseBooleanFlag2;
+exports.patchSchemasInConfigSource = patchSchemasInConfigSource;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
+exports.renderGeneratorConfigFile = renderGeneratorConfigFile;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
+exports.resolveAthenaReadQueryPageFetch = resolveAthenaReadQueryPageFetch;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
 exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;
 exports.resolveStoragePath = resolveStoragePath;
 exports.runSchemaGenerator = runSchemaGenerator;
+exports.schemasEqual = schemasEqual;
 exports.storageSdkManifest = storageSdkManifest;
 exports.string = string;
 exports.table = table;