@xylex-group/athena 1.7.0 → 2.0.0

package/dist/index.cjs

@@ -503,544 +503,1614 @@ 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;
+// 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 isRecord2(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 };
   }
-  return result;
 }
-function toSingleResult(response) {
-  const payload = response.data;
-  const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
+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 (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();
+      }
+    }
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function toErrorDetails(input) {
   return {
-    ...response,
-    data: singleData
+    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 mergeOptions(...options) {
-  return options.reduce((acc, next) => {
-    if (!next) return acc;
-    return { ...acc, ...next };
-  }, 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 mergeCallOptions(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base,
+    ...override,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
     }
-    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);
-    }
+}
+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
   };
-  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 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}`;
+  }
+  const mergedExtraHeaders = {
+    ...config.headers ?? {},
+    ...options?.headers ?? {}
+  };
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    const normalized = normalizeHeaderValue2(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  return headers;
 }
-function stringifyFilterValue(value) {
+function appendQueryParam(searchParams, key, value) {
+  if (value === void 0 || value === null) return;
   if (Array.isArray(value)) {
-    return value.join(",");
+    value.forEach((item) => {
+      searchParams.append(key, String(item));
+    });
+    return;
   }
-  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);
+  searchParams.append(key, String(value));
 }
-function shouldUseUuidTextComparison(column, value) {
-  return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
+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 normalizeCast(cast) {
-  const normalized = cast.trim().toLowerCase();
-  if (!SAFE_CAST_PATTERN.test(normalized)) {
-    throw new Error(`Invalid cast type "${cast}"`);
+function inferDefaultMethod(endpoint) {
+  if (endpoint.startsWith("/reset-password/")) {
+    return "GET";
   }
-  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)}`;
-}
-function buildSelectColumnsClause(columns) {
-  if (Array.isArray(columns)) {
-    return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
+  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 quoteSelectColumnsExpression(columns);
 }
-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;
-    }
-    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;
-  }
-}
-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 (context.method !== "GET") {
+    requestInit.body = JSON.stringify(body ?? {});
   }
-  if (offset !== void 0) {
-    sqlParts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
+  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
+    };
   }
-  return `${sqlParts.join(" ")};`;
-}
-function createFilterMethods(state, addCondition, self) {
-  return {
-    eq(column, value) {
-      if (shouldUseUuidTextComparison(column, value)) {
-        addCondition("eq", column, value, { columnCast: "text" });
-      } else {
-        addCondition("eq", column, value);
-      }
-      return self;
-    },
-    eqCast(column, value, cast) {
-      addCondition("eq", column, value, { valueCast: cast });
-      return self;
-    },
-    eqUuid(column, value) {
-      addCondition("eq", column, value, { valueCast: "uuid" });
-      return self;
-    },
-    match(filters) {
-      Object.entries(filters).forEach(([column, value]) => {
-        if (shouldUseUuidTextComparison(column, value)) {
-          addCondition("eq", column, value, { columnCast: "text" });
-        } else {
-          addCondition("eq", column, value);
-        }
+  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 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: column,
-        direction: options?.ascending === false ? "descending" : "ascending"
+      return {
+        ok: false,
+        status: response.status,
+        data: null,
+        error: details.message,
+        errorDetails: details,
+        raw: parsedBody.parsed
       };
-      return self;
-    },
-    gt(column, value) {
-      addCondition("gt", column, value);
-      return self;
-    },
-    gte(column, value) {
-      addCondition("gte", column, value);
-      return self;
-    },
-    lt(column, value) {
-      addCondition("lt", column, value);
-      return self;
-    },
-    lte(column, value) {
-      addCondition("lte", column, value);
-      return self;
-    },
-    neq(column, value) {
-      addCondition("neq", column, value);
-      return self;
-    },
-    like(column, value) {
-      addCondition("like", column, value);
-      return self;
-    },
-    ilike(column, value) {
-      addCondition("ilike", column, value);
-      return self;
-    },
-    is(column, value) {
-      addCondition("is", column, value);
-      return self;
-    },
-    in(column, values) {
-      addCondition("in", column, values);
-      return self;
-    },
-    contains(column, values) {
-      addCondition("contains", column, values);
-      return self;
-    },
-    containedBy(column, values) {
-      addCondition("containedBy", column, values);
-      return self;
-    },
-    not(columnOrExpression, operator, value) {
-      if (operator != null && value !== void 0) {
-        addCondition("not", void 0, `${columnOrExpression}.${operator}.${stringifyFilterValue(value)}`);
-      } else {
-        addCondition("not", void 0, columnOrExpression);
-      }
-      return self;
-    },
-    or(expression) {
-      addCondition("or", void 0, expression);
-      return self;
     }
-  };
+    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
+      };
+    }
+    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 toRpcSelect(columns) {
-  if (!columns) return void 0;
-  return Array.isArray(columns) ? columns.join(",") : columns;
+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 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 executePostWithOptionalInput(config, context, input, options) {
+  const { fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, {}, void 0, mergedOptions);
 }
-function createRpcBuilder(functionName, args, baseOptions, client) {
-  const state = {
-    filters: []
+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
   };
-  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 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 run = (columns, options) => {
-    const payloadColumns = columns ?? selectedColumns;
-    const payloadOptions = options ?? selectedOptions;
-    if (!promise) {
-      promise = executeRpc(payloadColumns, payloadOptions);
-    }
-    return promise;
+  const postGeneric = (endpoint, input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "POST",
+        body: payload ?? {},
+        fetchOptions
+      },
+      options
+    );
   };
-  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 createTableBuilder(tableName, client) {
-  const state = {
-    conditions: []
+  const getGeneric = (endpoint, input, options) => {
+    const { fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "GET",
+        fetchOptions
+      },
+      options
+    );
   };
-  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;
-      }
+  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;
     }
-    if (hints?.valueCast) {
-      condition.value_cast = hints.valueCast;
-      if (operator === "eq") {
-        condition.eq_value_cast = hints.valueCast;
-      }
+    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;
     }
-    if (hints?.columnCast) {
-      condition.column_cast = hints.columnCast;
-      if (operator === "eq") {
-        condition.eq_column_cast = hints.columnCast;
-      }
+    const fallback = await getGeneric("/ok", input, options);
+    if (!fallback.ok) {
+      return {
+        ...fallback,
+        data: null
+      };
     }
-    state.conditions.push(condition);
-  };
-  const builder = {};
-  const filterMethods = createFilterMethods(state, addCondition, builder);
-  const runSelect = async (columns = DEFAULT_COLUMNS, options) => {
-    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,
-        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);
+    const fallbackStatus = isRecord2(fallback.data) && typeof fallback.data.ok === "boolean" ? fallback.data.ok ? "ok" : "error" : "ok";
+    return {
+      ...fallback,
+      data: {
+        status: fallbackStatus
       }
-    }
-    const payload = {
-      table_name: tableName,
-      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 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);
-      }
-    });
-    return chain;
   };
-  Object.assign(builder, filterMethods, {
-    reset() {
-      state.conditions = [];
+  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
+      )
+    },
+    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
+      );
+    },
+    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
+      }
+    },
+    session: {
+      list: (input, options) => getGeneric("/list-sessions", input, options),
+      revoke: sessionRevokeBinding,
+      revokeOther: revokeOtherSessions
+    },
+    social: {
+      link: (input, options) => postGeneric("/link-social", input, options)
+    },
+    account: {
+      list: (input, options) => getGeneric("/list-accounts", input, options),
+      unlink: (input, options) => postGeneric("/unlink-account", input, options)
+    },
+    deleteUser: {
+      callback: deleteUserCallback
+    },
+    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)
+    },
+    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)
+    },
+    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)
+      }
+    },
+    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
+      )
+    },
+    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)
+    },
+    signUp: {
+      email: (input, options) => postGeneric("/sign-up/email", input, options)
+    },
+    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 {
+    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
+    ),
+    organization,
+    auth
+  };
+}
+
+// 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;
+}
+function toSingleResult(response) {
+  const payload = response.data;
+  const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
+  return {
+    ...response,
+    data: singleData
+  };
+}
+function mergeOptions(...options) {
+  return options.reduce((acc, next) => {
+    if (!next) return acc;
+    return { ...acc, ...next };
+  }, void 0);
+}
+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 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 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(",");
+  }
+  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);
+}
+function normalizeCast(cast) {
+  const normalized = cast.trim().toLowerCase();
+  if (!SAFE_CAST_PATTERN.test(normalized)) {
+    throw new Error(`Invalid cast type "${cast}"`);
+  }
+  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)}`;
+}
+function buildSelectColumnsClause(columns) {
+  if (Array.isArray(columns)) {
+    return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
+  }
+  return quoteSelectColumnsExpression(columns);
+}
+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 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;
+  }
+}
+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 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 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;
+    },
+    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 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;
+}
+function createTableBuilder(tableName, client) {
+  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 formatResult(queryResponse);
+      }
+    }
+    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 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);
+      }
+    });
+    return chain;
+  };
+  Object.assign(builder, filterMethods, {
+    reset() {
+      state.conditions = [];
       state.limit = void 0;
       state.offset = void 0;
       state.order = void 0;
@@ -1056,9 +2126,10 @@ function createTableBuilder(tableName, client) {
       if (Array.isArray(values)) {
         const executeInsertMany = async (columns, selectOptions) => {
           const mergedOptions = mergeOptions(options, selectOptions);
+          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
           const payload = {
-            table_name: tableName,
-            insert_body: values
+            table_name: resolvedTableName,
+            insert_body: asAthenaJsonObjectArray(values)
           };
           if (columns) payload.columns = columns;
           if (mergedOptions?.count) payload.count = mergedOptions.count;
@@ -1073,9 +2144,10 @@ function createTableBuilder(tableName, client) {
       }
       const executeInsertOne = async (columns, selectOptions) => {
         const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
         const payload = {
-          table_name: tableName,
-          insert_body: values
+          table_name: resolvedTableName,
+          insert_body: asAthenaJsonObject(values)
         };
         if (columns) payload.columns = columns;
         if (mergedOptions?.count) payload.count = mergedOptions.count;
@@ -1092,10 +2164,11 @@ function createTableBuilder(tableName, client) {
       if (Array.isArray(values)) {
         const executeUpsertMany = async (columns, selectOptions) => {
           const mergedOptions = mergeOptions(options, selectOptions);
+          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
           const payload = {
-            table_name: tableName,
-            insert_body: values,
-            update_body: options?.updateBody ? options.updateBody : void 0
+            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;
@@ -1111,10 +2184,11 @@ function createTableBuilder(tableName, client) {
       }
       const executeUpsertOne = async (columns, selectOptions) => {
         const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
         const payload = {
-          table_name: tableName,
-          insert_body: values,
-          update_body: options?.updateBody ? options.updateBody : void 0
+          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;
@@ -1132,9 +2206,10 @@ function createTableBuilder(tableName, client) {
       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: tableName,
-          set: values,
+          table_name: resolvedTableName,
+          set: asAthenaJsonObject(values),
           conditions: filters,
           strip_nulls: mergedOptions?.stripNulls ?? true
         };
@@ -1160,8 +2235,9 @@ function createTableBuilder(tableName, client) {
       }
       const executeDelete = async (columns, selectOptions) => {
         const mergedOptions = mergeOptions(options, selectOptions);
+        const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
         const payload = {
-          table_name: tableName,
+          table_name: resolvedTableName,
           resource_id: resourceId,
           conditions: filters
         };
@@ -1203,6 +2279,7 @@ function createClientFromConfig(config) {
     backend: config.backend,
     headers: config.headers
   });
+  const auth = createAuthClient(config.auth);
   return {
     from(table) {
       return createTableBuilder(table, gateway);
@@ -1219,7 +2296,8 @@ function createClientFromConfig(config) {
         gateway
       );
     },
-    query: createQueryBuilder(gateway)
+    query: createQueryBuilder(gateway),
+    auth: auth.auth
   };
 }
 var DEFAULT_BACKEND = { type: "athena" };
@@ -1293,7 +2371,11 @@ 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();
+  const client = b.build();
+  if (options?.auth) {
+    client.auth = createAuthClient(options.auth).auth;
+  }
+  return client;
 }
 
 // src/gateway/types.ts
@@ -1333,6 +2415,17 @@ var AthenaErrorCategory = {
   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;
+}
 var AthenaError = class extends Error {
   code;
   kind;
@@ -1355,7 +2448,7 @@ var AthenaError = class extends Error {
     this.raw = input.raw;
   }
 };
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function safeStringify(value) {
@@ -1372,7 +2465,7 @@ function contextHint(context) {
   return `Identity: ${identity}`;
 }
 function isAthenaResultLike(value) {
-  return isRecord2(value) && "status" in value && "error" in value && "data" in value && typeof value.status === "number";
+  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;
@@ -1538,7 +2631,7 @@ function normalizeAthenaError(resultOrError, context) {
     };
   }
   if (resultOrError instanceof Error) {
-    const maybeStatus = isRecord2(resultOrError) && typeof resultOrError.status === "number" ? resultOrError.status : void 0;
+    const maybeStatus = isRecord3(resultOrError) && typeof resultOrError.status === "number" ? resultOrError.status : void 0;
     const kind2 = classifyKind(maybeStatus, void 0, resultOrError.message);
     return {
       kind: kind2,
@@ -2274,6 +3367,67 @@ function createPostgresIntrospectionProvider(options) {
   return new PostgresIntrospectionProvider(options);
 }
 
+// src/schema/model-form.ts
+function resolveNullishValue(mode) {
+  if (mode === "undefined") return void 0;
+  if (mode === "null") return null;
+  return "";
+}
+function isRecord4(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNullableColumn(model, key) {
+  const nullable = model.meta.nullable;
+  return nullable?.[key] === true;
+}
+function toModelFormDefaults(model, values, options) {
+  const source = values;
+  if (!isRecord4(source)) {
+    return {};
+  }
+  const mode = options?.nullishMode ?? "empty-string";
+  const nullishValue = resolveNullishValue(mode);
+  const result = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === null && isNullableColumn(model, key)) {
+      result[key] = nullishValue;
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function toModelPayload(model, formValues, options) {
+  const emptyStringAsNull = options?.emptyStringAsNull ?? true;
+  const stripUndefined = options?.stripUndefined ?? true;
+  const result = {};
+  for (const [key, rawValue] of Object.entries(formValues)) {
+    if (rawValue === void 0 && stripUndefined) {
+      continue;
+    }
+    if (emptyStringAsNull && rawValue === "" && isNullableColumn(model, key)) {
+      result[key] = null;
+      continue;
+    }
+    result[key] = rawValue;
+  }
+  return result;
+}
+function createModelFormAdapter(model) {
+  return {
+    model,
+    toDefaults(values, options) {
+      return toModelFormDefaults(model, values, options);
+    },
+    toInsert(values, options) {
+      return toModelPayload(model, values, options);
+    },
+    toUpdate(values, options) {
+      return toModelPayload(model, values, options);
+    }
+  };
+}
+
 // src/generator/schema-selection.ts
 var DEFAULT_POSTGRES_SCHEMAS = ["public"];
 function collectSchemaNames(input) {
@@ -2333,6 +3487,39 @@ var DEFAULT_EXPERIMENTAL_FLAGS = {
   postgresGatewayIntrospection: false,
   scyllaProviderContracts: true
 };
+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: {
@@ -2368,14 +3555,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) {
@@ -2985,633 +4166,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 isRecord3(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 (isRecord3(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
   };
 }
 
@@ -3627,6 +4317,7 @@ exports.assertInt = assertInt;
 exports.coerceInt = coerceInt;
 exports.createAuthClient = createAuthClient;
 exports.createClient = createClient;
+exports.createModelFormAdapter = createModelFormAdapter;
 exports.createPostgresIntrospectionProvider = createPostgresIntrospectionProvider;
 exports.createTypedClient = createTypedClient;
 exports.defineDatabase = defineDatabase;
@@ -3643,12 +4334,15 @@ exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
+exports.parseBooleanFlag = parseBooleanFlag;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
 exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;
 exports.runSchemaGenerator = runSchemaGenerator;
+exports.toModelFormDefaults = toModelFormDefaults;
+exports.toModelPayload = toModelPayload;
 exports.unwrap = unwrap;
 exports.unwrapOne = unwrapOne;
 exports.unwrapRows = unwrapRows;