@xylex-group/athena 1.9.0 → 2.0.0

package/dist/index.cjs

@@ -503,460 +503,1109 @@ function identifier(...segments) {
   return new SqlIdentifierPath(expandedSegments);
 }
 
-// src/client.ts
-var DEFAULT_COLUMNS = "*";
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
-function formatResult(response) {
-  const result = {
-    data: response.data ?? null,
-    error: response.error ?? null,
-    errorDetails: response.errorDetails ?? null,
-    status: response.status,
-    raw: response.raw
-  };
-  if (response.count !== void 0) {
-    result.count = response.count;
-  }
-  return result;
+// src/auth/client.ts
+var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
+var FALLBACK_SDK_VERSION2 = "1.0.0";
+var SDK_NAME2 = "xylex-group/athena-auth";
+var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
+var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
-function toSingleResult(response) {
-  const payload = response.data;
-  const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
-  return {
-    ...response,
-    data: singleData
-  };
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function mergeOptions(...options) {
-  return options.reduce((acc, next) => {
-    if (!next) return acc;
-    return { ...acc, ...next };
-  }, void 0);
+function normalizeHeaderValue2(value) {
+  return value ? value : void 0;
 }
-function asAthenaJsonObject(value) {
-  return value;
+function parseResponseBody2(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
 }
-function asAthenaJsonObjectArray(values) {
-  return values;
+function resolveRequestId2(headers) {
+  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
 }
-function createMutationQuery(executor, defaultColumns = DEFAULT_COLUMNS) {
-  let selectedColumns = defaultColumns === null ? void 0 : defaultColumns;
-  let selectedOptions;
-  let promise = null;
-  const run = (columns, options) => {
-    const payloadColumns = columns ?? selectedColumns;
-    const payloadOptions = options ?? selectedOptions;
-    if (!promise) {
-      promise = executor(payloadColumns, payloadOptions);
+function resolveErrorMessage2(payload, fallback) {
+  if (isRecord2(payload)) {
+    const messageCandidates = [payload.error, payload.message, payload.details];
+    for (const candidate of messageCandidates) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
     }
-    return promise;
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function toErrorDetails(input) {
+  return {
+    code: input.code,
+    message: input.message,
+    status: input.status,
+    endpoint: input.endpoint,
+    method: input.method,
+    requestId: input.requestId,
+    hint: input.hint,
+    cause: input.cause
   };
-  const mutationQuery = {
-    select(columns = selectedColumns, options) {
-      selectedColumns = columns;
-      selectedOptions = options ?? selectedOptions;
-      return run(columns, options);
-    },
-    returning(columns = selectedColumns, options) {
-      return mutationQuery.select(columns, options);
-    },
-    single(columns = selectedColumns, options) {
-      selectedColumns = columns;
-      selectedOptions = options ?? selectedOptions;
-      return run(columns, options).then(toSingleResult);
-    },
-    maybeSingle(columns = selectedColumns, options) {
-      return mutationQuery.single(columns, options);
-    },
-    then(onfulfilled, onrejected) {
-      return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
-    },
-    catch(onrejected) {
-      return run(selectedColumns, selectedOptions).catch(onrejected);
-    },
-    finally(onfinally) {
-      return run(selectedColumns, selectedOptions).finally(onfinally);
+}
+function mergeCallOptions(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base,
+    ...override,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
     }
   };
-  return mutationQuery;
-}
-function getResourceId(state) {
-  const candidate = state.conditions.find(
-    (condition) => condition.operator === "eq" && (condition.column === "resource_id" || condition.column === "id")
-  );
-  return candidate?.value?.toString();
 }
-function stringifyFilterValue(value) {
-  if (Array.isArray(value)) {
-    return value.join(",");
+function extractFetchOptions(input) {
+  if (!input) {
+    return {
+      payload: void 0,
+      fetchOptions: void 0
+    };
   }
-  return String(value);
-}
-function isUuidString(value) {
-  return UUID_PATTERN.test(value.trim());
-}
-function isUuidIdentifierColumn(column) {
-  return column === "id" || /(?:^|_)uuid(?:_|$)/i.test(column) || /_id$/i.test(column);
-}
-function shouldUseUuidTextComparison(column, value) {
-  return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
+  const { fetchOptions, ...rest } = input;
+  const hasPayloadKeys = Object.keys(rest).length > 0;
+  return {
+    payload: hasPayloadKeys ? rest : void 0,
+    fetchOptions
+  };
 }
-function normalizeCast(cast) {
-  const normalized = cast.trim().toLowerCase();
-  if (!SAFE_CAST_PATTERN.test(normalized)) {
-    throw new Error(`Invalid cast type "${cast}"`);
+function buildHeaders2(config, options) {
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Athena-Sdk": SDK_HEADER_VALUE2
+  };
+  const apiKey = options?.apiKey ?? config.apiKey;
+  if (apiKey) {
+    headers.apikey = apiKey;
+    headers["x-api-key"] = apiKey;
   }
-  return normalized;
-}
-function escapeSqlStringLiteral(value) {
-  return value.replace(/'/g, "''");
-}
-function toSqlLiteral(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  return `'${escapeSqlStringLiteral(value)}'`;
-}
-function withCast(expression, cast) {
-  if (!cast) return expression;
-  return `${expression}::${normalizeCast(cast)}`;
+  const bearerToken = options?.bearerToken ?? config.bearerToken;
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+  const mergedExtraHeaders = {
+    ...config.headers ?? {},
+    ...options?.headers ?? {}
+  };
+  Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    const normalized = normalizeHeaderValue2(value);
+    if (normalized) {
+      headers[key] = normalized;
+    }
+  });
+  return headers;
 }
-function buildSelectColumnsClause(columns) {
-  if (Array.isArray(columns)) {
-    return columns.map((column) => quoteQualifiedIdentifier(column)).join(", ");
+function appendQueryParam(searchParams, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    value.forEach((item) => {
+      searchParams.append(key, String(item));
+    });
+    return;
   }
-  return quoteSelectColumnsExpression(columns);
+  searchParams.append(key, String(value));
 }
-function resolveTableNameForCall(tableName, schema) {
-  if (!schema) return tableName;
-  const normalizedSchema = schema.trim();
-  if (!normalizedSchema) {
-    throw new Error("schema option must be a non-empty string");
+function buildRequestUrl(baseUrl, endpoint, query) {
+  const url = `${baseUrl}${endpoint}`;
+  if (!query || Object.keys(query).length === 0) return url;
+  const searchParams = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => appendQueryParam(searchParams, key, value));
+  const queryText = searchParams.toString();
+  return queryText ? `${url}?${queryText}` : url;
+}
+function inferDefaultMethod(endpoint) {
+  if (endpoint.startsWith("/reset-password/")) {
+    return "GET";
   }
-  if (tableName.includes(".")) {
-    if (tableName.startsWith(`${normalizedSchema}.`)) {
-      return tableName;
-    }
-    throw new Error(
-      `schema option "${normalizedSchema}" conflicts with schema-qualified table "${tableName}"`
-    );
+  switch (endpoint) {
+    case "/get-session":
+    case "/list-sessions":
+    case "/verify-email":
+    case "/change-email/verify":
+    case "/delete-user/verify":
+    case "/email-list":
+    case "/email/list":
+    case "/delete-user/callback":
+    case "/list-accounts":
+    case "/passkey/generate-register-options":
+    case "/passkey/list-user-passkeys":
+    case "/.well-known/webauthn":
+    case "/admin/list-users":
+    case "/admin/athena-client/list":
+    case "/admin/audit-log/list":
+    case "/admin/email/get":
+    case "/admin/email-failure/list":
+    case "/admin/email-failure/get":
+    case "/admin/email-template/get":
+    case "/admin/email-template/list":
+    case "/admin/email/list":
+    case "/api-key/get":
+    case "/api-key/list":
+    case "/organization/get-full-organization":
+    case "/organization/list":
+    case "/organization/get-invitation":
+    case "/organization/list-invitations":
+    case "/organization/list-user-invitations":
+    case "/organization/list-members":
+    case "/organization/get-active-member":
+    case "/health":
+    case "/ok":
+    case "/error":
+      return "GET";
+    default:
+      return "POST";
   }
-  return `${normalizedSchema}.${tableName}`;
 }
-function conditionToSqlClause(condition) {
-  if (!condition.column) return null;
-  const column = withCast(quoteQualifiedIdentifier(condition.column), condition.column_cast);
-  const value = condition.value;
-  const sqlOperator = {
-    eq: "=",
-    neq: "!=",
-    gt: ">",
-    gte: ">=",
-    lt: "<",
-    lte: "<=",
-    like: "LIKE",
-    ilike: "ILIKE"
+async function callAuthEndpoint(config, context, body, query, options) {
+  const baseUrl = normalizeBaseUrl(options?.baseUrl ?? config.baseUrl);
+  const url = buildRequestUrl(baseUrl, context.endpoint, query);
+  const headers = buildHeaders2(config, options);
+  const credentials = options?.credentials ?? config.credentials ?? "include";
+  const requestInit = {
+    method: context.method,
+    headers,
+    credentials,
+    signal: options?.signal
   };
-  switch (condition.operator) {
-    case "eq":
-    case "neq":
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte":
-    case "like":
-    case "ilike": {
-      if (Array.isArray(value) || value === void 0) return null;
-      const rhs = withCast(toSqlLiteral(value), condition.value_cast);
-      return `${column} ${sqlOperator[condition.operator]} ${rhs}`;
-    }
-    case "is": {
-      if (value === null) return `${column} IS NULL`;
-      if (value === true) return `${column} IS TRUE`;
-      if (value === false) return `${column} IS FALSE`;
-      return null;
+  if (context.method !== "GET") {
+    requestInit.body = JSON.stringify(body ?? {});
+  }
+  const fetcher = config.fetch ?? globalThis.fetch;
+  if (!fetcher) {
+    const details = toErrorDetails({
+      code: "UNKNOWN_ERROR",
+      message: "No fetch implementation available for auth client",
+      status: 0,
+      endpoint: context.endpoint,
+      method: context.method,
+      hint: "Use Node 18+ or provide `fetch` via createClient(..., { auth: { fetch } }) or createAuthClient({ fetch })"
+    });
+    return {
+      ok: false,
+      status: 0,
+      data: null,
+      error: details.message,
+      errorDetails: details,
+      raw: null
+    };
+  }
+  try {
+    const response = await fetcher(url, requestInit);
+    const rawText = await response.text();
+    const requestId = resolveRequestId2(response.headers);
+    const parsedBody = parseResponseBody2(rawText ?? "", response.headers.get("content-type"));
+    if (parsedBody.parseFailed) {
+      const details = toErrorDetails({
+        code: "INVALID_JSON",
+        message: "Auth server returned malformed JSON",
+        status: response.status,
+        endpoint: context.endpoint,
+        method: context.method,
+        requestId,
+        hint: "Verify the auth endpoint response body is valid JSON.",
+        cause: rawText.slice(0, 300)
+      });
+      return {
+        ok: false,
+        status: response.status,
+        data: null,
+        error: details.message,
+        errorDetails: details,
+        raw: parsedBody.parsed
+      };
     }
-    case "in": {
-      if (!Array.isArray(value)) return null;
-      if (value.length === 0) return "FALSE";
-      const values = value.map((item) => withCast(toSqlLiteral(item), condition.value_cast));
-      return `${column} IN (${values.join(", ")})`;
+    const parsed = parsedBody.parsed;
+    if (!response.ok) {
+      const details = toErrorDetails({
+        code: "HTTP_ERROR",
+        message: resolveErrorMessage2(
+          parsed,
+          `Auth endpoint ${context.method} ${context.endpoint} failed with status ${response.status}`
+        ),
+        status: response.status,
+        endpoint: context.endpoint,
+        method: context.method,
+        requestId
+      });
+      return {
+        ok: false,
+        status: response.status,
+        data: null,
+        error: details.message,
+        errorDetails: details,
+        raw: parsed
+      };
     }
-    default:
-      return null;
+    return {
+      ok: true,
+      status: response.status,
+      data: parsed ?? null,
+      error: null,
+      errorDetails: null,
+      raw: parsed
+    };
+  } catch (callError) {
+    const message = callError instanceof Error ? callError.message : String(callError);
+    const details = toErrorDetails({
+      code: "NETWORK_ERROR",
+      message: `Network error while calling ${context.method} ${context.endpoint}: ${message}`,
+      status: 0,
+      endpoint: context.endpoint,
+      method: context.method,
+      cause: message,
+      hint: "Check auth server URL, DNS, and network reachability."
+    });
+    return {
+      ok: false,
+      status: 0,
+      data: null,
+      error: details.message,
+      errorDetails: details,
+      raw: null
+    };
   }
 }
-function buildTypedSelectQuery(input) {
-  const whereClauses = [];
-  for (const condition of input.conditions) {
-    const clause = conditionToSqlClause(condition);
-    if (!clause) return null;
-    whereClauses.push(clause);
-  }
-  let limit = input.limit;
-  let offset = input.offset;
-  if (limit === void 0 && input.pageSize !== void 0) {
-    limit = input.pageSize;
-  }
-  if (offset === void 0 && input.pageSize !== void 0 && input.currentPage !== void 0 && input.currentPage > 0) {
-    offset = (input.currentPage - 1) * input.pageSize;
-  }
-  const sqlParts = [
-    `SELECT ${buildSelectColumnsClause(input.columns)} FROM ${quoteQualifiedIdentifier(input.tableName)}`
-  ];
-  if (whereClauses.length > 0) {
-    sqlParts.push(`WHERE ${whereClauses.join(" AND ")}`);
-  }
-  if (input.order?.field) {
-    const direction = input.order.direction === "descending" ? "DESC" : "ASC";
-    sqlParts.push(`ORDER BY ${quoteQualifiedIdentifier(input.order.field)} ${direction}`);
-  }
-  if (limit !== void 0) {
-    sqlParts.push(`LIMIT ${Math.max(0, Math.trunc(limit))}`);
-  }
-  if (offset !== void 0) {
-    sqlParts.push(`OFFSET ${Math.max(0, Math.trunc(offset))}`);
-  }
-  return `${sqlParts.join(" ")};`;
+function executePostWithCompatibleInput(config, context, input, options) {
+  const { payload, fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, payload ?? {}, void 0, mergedOptions);
 }
-function createFilterMethods(state, addCondition, self) {
-  return {
-    eq(column, value) {
-      const columnName = String(column);
-      if (shouldUseUuidTextComparison(columnName, value)) {
-        addCondition("eq", columnName, value, { columnCast: "text" });
-      } else {
-        addCondition("eq", columnName, value);
+function executePostWithOptionalInput(config, context, input, options) {
+  const { fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, {}, void 0, mergedOptions);
+}
+function executeGetWithCompatibleInput(config, context, input, options) {
+  const { fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  return callAuthEndpoint(config, context, void 0, void 0, mergedOptions);
+}
+function executeGetWithQueryCompatibleInput(config, context, input, options) {
+  const { payload, fetchOptions } = extractFetchOptions(input);
+  const mergedOptions = mergeCallOptions(fetchOptions, options);
+  const query = payload?.query;
+  return callAuthEndpoint(
+    config,
+    context,
+    void 0,
+    query,
+    mergedOptions
+  );
+}
+function createAuthClient(config = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const resolvedConfig = {
+    ...config,
+    baseUrl: normalizedBaseUrl
+  };
+  const request = (input, options) => {
+    const method = input.method ?? (input.body !== void 0 ? "POST" : inferDefaultMethod(input.endpoint));
+    const mergedOptions = mergeCallOptions(input.fetchOptions, options);
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: input.endpoint, method },
+      input.body,
+      input.query,
+      mergedOptions
+    );
+  };
+  const postGeneric = (endpoint, input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "POST",
+        body: payload ?? {},
+        fetchOptions
+      },
+      options
+    );
+  };
+  const getGeneric = (endpoint, input, options) => {
+    const { fetchOptions } = extractFetchOptions(input);
+    return request(
+      {
+        endpoint,
+        method: "GET",
+        fetchOptions
+      },
+      options
+    );
+  };
+  const getWithQuery = (endpoint, input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const query = payload?.query;
+    return request(
+      {
+        endpoint,
+        method: "GET",
+        query,
+        fetchOptions
+      },
+      options
+    );
+  };
+  const listUserEmailsWithFallback = async (input, options) => {
+    const primary = await getWithQuery(
+      "/email/list",
+      input,
+      options
+    );
+    if (primary.ok || primary.status !== 404 || primary.errorDetails?.code !== "HTTP_ERROR") {
+      return primary;
+    }
+    return getWithQuery(
+      "/email-list",
+      input,
+      options
+    );
+  };
+  const healthWithFallback = async (input, options) => {
+    const primary = await getGeneric("/health", input, options);
+    if (primary.ok || primary.status !== 404 || primary.errorDetails?.code !== "HTTP_ERROR") {
+      return primary;
+    }
+    const fallback = await getGeneric("/ok", input, options);
+    if (!fallback.ok) {
+      return {
+        ...fallback,
+        data: null
+      };
+    }
+    const fallbackStatus = isRecord2(fallback.data) && typeof fallback.data.ok === "boolean" ? fallback.data.ok ? "ok" : "error" : "ok";
+    return {
+      ...fallback,
+      data: {
+        status: fallbackStatus
       }
-      return self;
-    },
-    eqCast(column, value, cast) {
-      addCondition("eq", String(column), value, { valueCast: cast });
-      return self;
-    },
-    eqUuid(column, value) {
-      addCondition("eq", String(column), value, { valueCast: "uuid" });
-      return self;
-    },
-    match(filters) {
-      Object.entries(filters).forEach(([column, value]) => {
-        if (value === void 0) {
-          return;
-        }
-        if (shouldUseUuidTextComparison(column, value)) {
-          addCondition("eq", column, value, { columnCast: "text" });
-        } else {
-          addCondition("eq", column, value);
-        }
-      });
-      return self;
+    };
+  };
+  const signOut = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/sign-out", method: "POST" },
+    input,
+    options
+  );
+  const revokeSessions = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/revoke-sessions", method: "POST" },
+    input,
+    options
+  );
+  const revokeOtherSessions = (input, options) => executePostWithOptionalInput(
+    resolvedConfig,
+    { endpoint: "/revoke-other-sessions", method: "POST" },
+    input,
+    options
+  );
+  const revokeSession = (input, options) => executePostWithCompatibleInput(
+    resolvedConfig,
+    { endpoint: "/revoke-session", method: "POST" },
+    input,
+    options
+  );
+  const deleteUser = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: "/delete-user", method: "POST" },
+      payload ?? {},
+      void 0,
+      mergedOptions
+    );
+  };
+  const deleteUserCallback = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    const query = payload ?? {};
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint: "/delete-user/callback", method: "GET" },
+      void 0,
+      {
+        token: query.token,
+        callbackURL: query.callbackURL
+      },
+      mergedOptions
+    );
+  };
+  const resolveResetPasswordToken = (input, options) => {
+    const { payload, fetchOptions } = extractFetchOptions(input);
+    const mergedOptions = mergeCallOptions(fetchOptions, options);
+    const query = payload;
+    const token = query?.token?.trim();
+    if (!token) {
+      throw new Error("resolveResetPasswordToken requires a non-empty token");
+    }
+    const endpoint = `/reset-password/${encodeURIComponent(token)}`;
+    return callAuthEndpoint(
+      resolvedConfig,
+      { endpoint, method: "GET" },
+      void 0,
+      query?.callbackURL ? { callbackURL: query.callbackURL } : void 0,
+      mergedOptions
+    );
+  };
+  const organization = {
+    create: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/create", method: "POST" },
+      input,
+      options
+    ),
+    update: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/update", method: "POST" },
+      input,
+      options
+    ),
+    delete: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/delete", method: "POST" },
+      input,
+      options
+    ),
+    setActive: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/set-active", method: "POST" },
+      input,
+      options
+    ),
+    list: (input, options) => getGeneric(
+      "/organization/list",
+      input,
+      options
+    ),
+    getFull: (input, options) => executeGetWithQueryCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/get-full-organization", method: "GET" },
+      input,
+      options
+    ),
+    checkSlug: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/check-slug", method: "POST" },
+      input,
+      options
+    ),
+    leave: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/leave", method: "POST" },
+      input,
+      options
+    ),
+    listUserInvitations: (input, options) => executeGetWithQueryCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/organization/list-user-invitations", method: "GET" },
+      input,
+      options
+    ),
+    hasPermission: (input, options) => postGeneric(
+      "/organization/has-permission",
+      input,
+      options
+    ),
+    invitation: {
+      cancel: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/cancel-invitation", method: "POST" },
+        input,
+        options
+      ),
+      accept: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/accept-invitation", method: "POST" },
+        input,
+        options
+      ),
+      get: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/get-invitation", method: "GET" },
+        input,
+        options
+      ),
+      reject: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/reject-invitation", method: "POST" },
+        input,
+        options
+      ),
+      list: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/list-invitations", method: "GET" },
+        input,
+        options
+      )
     },
-    range(from, to) {
-      state.offset = from;
-      state.limit = to - from + 1;
-      return self;
+    member: {
+      remove: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/remove-member", method: "POST" },
+        input,
+        options
+      ),
+      updateRole: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/update-member-role", method: "POST" },
+        input,
+        options
+      ),
+      invite: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/invite-member", method: "POST" },
+        input,
+        options
+      ),
+      getActive: (input, options) => executeGetWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/get-active-member", method: "GET" },
+        input,
+        options
+      ),
+      list: (input, options) => executeGetWithQueryCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/organization/list-members", method: "GET" },
+        input,
+        options
+      )
+    }
+  };
+  const authResetPassword = Object.assign(
+    (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/reset-password", method: "POST" },
+      input,
+      options
+    ),
+    {
+      token: resolveResetPasswordToken
+    }
+  );
+  const sessionRevokeBinding = (input, options) => {
+    if (Array.isArray(input)) {
+      if (input.length === 0) {
+        throw new Error("session.revoke requires at least one session token");
+      }
+      if (input.length === 1) {
+        return revokeSession(input[0], options);
+      }
+      return revokeSessions(void 0, options);
+    }
+    const parsed = input;
+    const tokens = Array.isArray(parsed.tokens) ? parsed.tokens.filter((token2) => token2.trim().length > 0) : void 0;
+    if (tokens && tokens.length > 1) {
+      return revokeSessions(
+        parsed.fetchOptions ? { fetchOptions: parsed.fetchOptions } : void 0,
+        options
+      );
+    }
+    if (tokens && tokens.length === 1) {
+      return revokeSession(
+        { token: tokens[0], fetchOptions: parsed.fetchOptions },
+        options
+      );
+    }
+    const token = parsed.token?.trim();
+    if (!token) {
+      throw new Error("session.revoke requires a non-empty token or a non-empty token list");
+    }
+    return revokeSession(
+      {
+        token,
+        fetchOptions: parsed.fetchOptions
+      },
+      options
+    );
+  };
+  const adminUserSessionRevokeBinding = (input, options) => {
+    const requireUserId = (userId) => {
+      const trimmed = String(userId ?? "").trim();
+      if (!trimmed) {
+        throw new Error("admin.user.session.revoke requires a non-empty userId");
+      }
+      return trimmed;
+    };
+    const requireSinglePluralUserId = (sessions2) => {
+      const uniqueUserIds = [...new Set(sessions2.map((session) => requireUserId(session.userId)))];
+      if (uniqueUserIds.length !== 1) {
+        throw new Error("admin.user.session.revoke requires the same userId across plural payloads");
+      }
+      return { userId: uniqueUserIds[0] };
+    };
+    if (Array.isArray(input)) {
+      if (input.length === 0) {
+        throw new Error("admin.user.session.revoke requires at least one payload item");
+      }
+      if (input.length === 1) {
+        return postGeneric(
+          "/admin/revoke-user-session",
+          {
+            ...input[0],
+            userId: requireUserId(input[0].userId)
+          },
+          options
+        );
+      }
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        requireSinglePluralUserId(input),
+        options
+      );
+    }
+    const parsed = input;
+    const sessions = parsed.sessions;
+    if (sessions && sessions.length === 0) {
+      throw new Error("admin.user.session.revoke requires at least one payload item");
+    }
+    if (sessions && sessions.length === 1) {
+      return postGeneric(
+        "/admin/revoke-user-session",
+        {
+          ...sessions[0],
+          userId: requireUserId(sessions[0].userId),
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    if (sessions && sessions.length > 1) {
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        {
+          ...requireSinglePluralUserId(sessions),
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    const normalizedUserId = requireUserId(parsed.userId);
+    if (!parsed.sessionToken) {
+      return postGeneric(
+        "/admin/revoke-user-sessions",
+        {
+          userId: normalizedUserId,
+          fetchOptions: parsed.fetchOptions
+        },
+        options
+      );
+    }
+    return postGeneric(
+      "/admin/revoke-user-session",
+      {
+        ...parsed,
+        userId: normalizedUserId
+      },
+      options
+    );
+  };
+  const auth = {
+    getSession: (input, options) => getGeneric("/get-session", input, options),
+    signOut,
+    forgetPassword: (input, options) => postGeneric("/forget-password", input, options),
+    resetPassword: authResetPassword,
+    setPassword: (input, options) => postGeneric("/set-password", input, options),
+    verifyEmail: (input, options) => {
+      const queryInput = {
+        query: {
+          token: input.token,
+          callbackURL: input.callbackURL
+        },
+        fetchOptions: input.fetchOptions
+      };
+      return getWithQuery(
+        "/verify-email",
+        queryInput,
+        options
+      );
     },
-    limit(count) {
-      state.limit = count;
-      return self;
+    sendVerificationEmail: (input, options) => postGeneric("/send-verification-email", input, options),
+    changeEmail: (input, options) => postGeneric("/change-email", input, options),
+    changeEmailVerify: (input, options) => getWithQuery("/change-email/verify", input, options),
+    deleteUserVerify: (input, options) => getWithQuery("/delete-user/verify", input, options),
+    changePassword: (input, options) => postGeneric("/change-password", input, options),
+    user: {
+      update: (input, options) => postGeneric("/update-user", input, options),
+      delete: (input, options) => postGeneric("/delete-user", input, options),
+      email: {
+        list: listUserEmailsWithFallback
+      }
     },
-    offset(count) {
-      state.offset = count;
-      return self;
+    session: {
+      list: (input, options) => getGeneric("/list-sessions", input, options),
+      revoke: sessionRevokeBinding,
+      revokeOther: revokeOtherSessions
     },
-    currentPage(value) {
-      state.currentPage = value;
-      return self;
+    social: {
+      link: (input, options) => postGeneric("/link-social", input, options)
     },
-    pageSize(value) {
-      state.pageSize = value;
-      return self;
+    account: {
+      list: (input, options) => getGeneric("/list-accounts", input, options),
+      unlink: (input, options) => postGeneric("/unlink-account", input, options)
     },
-    totalPages(value) {
-      state.totalPages = value;
-      return self;
+    deleteUser: {
+      callback: deleteUserCallback
     },
-    order(column, options) {
-      state.order = {
-        field: String(column),
-        direction: options?.ascending === false ? "descending" : "ascending"
-      };
-      return self;
+    refreshToken: (input, options) => postGeneric("/refresh-token", input, options),
+    getAccessToken: (input, options) => postGeneric("/get-access-token", input, options),
+    health: healthWithFallback,
+    ok: (input, options) => getGeneric("/ok", input, options),
+    error: (input, options) => getGeneric("/error", input, options),
+    twoFactor: {
+      getTotpUri: (input, options) => postGeneric("/two-factor/get-totp-uri", input, options),
+      verifyTotp: (input, options) => postGeneric("/two-factor/verify-totp", input, options),
+      sendOtp: (input, options) => postGeneric("/two-factor/send-otp", input, options),
+      verifyOtp: (input, options) => postGeneric("/two-factor/verify-otp", input, options),
+      verifyBackupCode: (input, options) => postGeneric("/two-factor/verify-backup-code", input, options),
+      generateBackupCodes: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/two-factor/generate-backup-codes", method: "POST" },
+        input,
+        options
+      ),
+      enable: (input, options) => postGeneric("/two-factor/enable", input, options),
+      disable: (input, options) => postGeneric("/two-factor/disable", input, options)
     },
-    gt(column, value) {
-      addCondition("gt", String(column), value);
-      return self;
+    passkey: {
+      generateRegisterOptions: (input, options) => getGeneric("/passkey/generate-register-options", input, options),
+      generateAuthenticateOptions: (input, options) => postGeneric("/passkey/generate-authenticate-options", input, options),
+      verifyRegistration: (input, options) => postGeneric("/passkey/verify-registration", input, options),
+      verifyAuthentication: (input, options) => postGeneric("/passkey/verify-authentication", input, options),
+      listUserPasskeys: (input, options) => getGeneric("/passkey/list-user-passkeys", input, options),
+      deletePasskey: (input, options) => postGeneric("/passkey/delete-passkey", input, options),
+      updatePasskey: (input, options) => postGeneric("/passkey/update-passkey", input, options),
+      getRelatedOrigins: (input, options) => getGeneric("/.well-known/webauthn", input, options)
     },
-    gte(column, value) {
-      addCondition("gte", String(column), value);
-      return self;
+    admin: {
+      role: {
+        set: (input, options) => postGeneric("/admin/set-role", input, options)
+      },
+      user: {
+        list: (input, options) => getWithQuery("/admin/list-users", input, options),
+        create: (input, options) => postGeneric("/admin/create-user", input, options),
+        unban: (input, options) => postGeneric("/admin/unban-user", input, options),
+        ban: (input, options) => postGeneric("/admin/ban-user", input, options),
+        impersonate: (input, options) => postGeneric("/admin/impersonate-user", input, options),
+        stopImpersonating: (input, options) => postGeneric("/admin/stop-impersonating", input, options),
+        remove: (input, options) => postGeneric("/admin/remove-user", input, options),
+        setPassword: (input, options) => postGeneric("/admin/set-user-password", input, options),
+        session: {
+          list: (input, options) => postGeneric("/admin/list-user-sessions", input, options),
+          revoke: adminUserSessionRevokeBinding
+        }
+      },
+      hasPermission: (input, options) => postGeneric("/admin/has-permission", input, options),
+      apiKey: {
+        create: (input, options) => postGeneric("/admin/api-key/create", input, options)
+      },
+      athenaClient: {
+        create: (input, options) => postGeneric("/admin/athena-client/create", input, options),
+        list: (input, options) => getWithQuery("/admin/athena-client/list", input, options)
+      },
+      auditLog: {
+        list: (input, options) => getWithQuery("/admin/audit-log/list", input, options)
+      },
+      email: {
+        list: (input, options) => getWithQuery("/admin/email/list", input, options),
+        get: (input, options) => getWithQuery("/admin/email/get", input, options),
+        create: (input, options) => postGeneric("/admin/email/create", input, options),
+        update: (input, options) => postGeneric("/admin/email/update", input, options),
+        delete: (input, options) => postGeneric("/admin/email/delete", input, options),
+        failure: {
+          list: (input, options) => getWithQuery("/admin/email-failure/list", input, options),
+          get: (input, options) => getWithQuery("/admin/email-failure/get", input, options),
+          create: (input, options) => postGeneric("/admin/email-failure/create", input, options),
+          update: (input, options) => postGeneric("/admin/email-failure/update", input, options),
+          delete: (input, options) => postGeneric("/admin/email-failure/delete", input, options)
+        },
+        template: {
+          list: (input, options) => getWithQuery("/admin/email-template/list", input, options),
+          get: (input, options) => getWithQuery("/admin/email-template/get", input, options),
+          create: (input, options) => postGeneric("/admin/email-template/create", input, options),
+          update: (input, options) => postGeneric("/admin/email-template/update", input, options),
+          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options)
+        }
+      },
+      emailTemplate: {
+        get: (input, options) => getWithQuery("/admin/email-template/get", input, options),
+        create: (input, options) => postGeneric("/admin/email-template/create", input, options),
+        delete: (input, options) => postGeneric("/admin/email-template/delete", input, options),
+        list: (input, options) => getWithQuery("/admin/email-template/list", input, options),
+        update: (input, options) => postGeneric("/admin/email-template/update", input, options)
+      }
     },
-    lt(column, value) {
-      addCondition("lt", String(column), value);
-      return self;
-    },
-    lte(column, value) {
-      addCondition("lte", String(column), value);
-      return self;
-    },
-    neq(column, value) {
-      addCondition("neq", String(column), value);
-      return self;
-    },
-    like(column, value) {
-      addCondition("like", String(column), value);
-      return self;
-    },
-    ilike(column, value) {
-      addCondition("ilike", String(column), value);
-      return self;
-    },
-    is(column, value) {
-      addCondition("is", String(column), value);
-      return self;
-    },
-    in(column, values) {
-      addCondition("in", String(column), values);
-      return self;
+    apiKey: {
+      create: (input, options) => postGeneric("/api-key/create", input, options),
+      get: (input, options) => getWithQuery("/api-key/get", input, options),
+      update: (input, options) => postGeneric("/api-key/update", input, options),
+      delete: (input, options) => postGeneric("/api-key/delete", input, options),
+      list: (input, options) => getWithQuery("/api-key/list", input, options),
+      verify: (input, options) => postGeneric("/api-key/verify", input, options),
+      deleteAllExpired: (input, options) => executePostWithOptionalInput(
+        resolvedConfig,
+        { endpoint: "/api-key/delete-all-expired-api-keys", method: "POST" },
+        input,
+        options
+      )
     },
-    contains(column, values) {
-      addCondition("contains", String(column), values);
-      return self;
+    signIn: {
+      email: (input, options) => postGeneric("/sign-in/email", input, options),
+      username: (input, options) => postGeneric("/sign-in/username", input, options),
+      social: (input, options) => postGeneric("/sign-in/social", input, options)
     },
-    containedBy(column, values) {
-      addCondition("containedBy", String(column), values);
-      return self;
+    signUp: {
+      email: (input, options) => postGeneric("/sign-up/email", input, options)
     },
-    not(columnOrExpression, operator, value) {
-      const expression = String(columnOrExpression);
-      if (operator != null && value !== void 0) {
-        addCondition("not", void 0, `${expression}.${operator}.${stringifyFilterValue(value)}`);
-      } else {
-        addCondition("not", void 0, expression);
+    organization,
+    callback: {
+      provider: (input, options) => {
+        const { payload, fetchOptions } = extractFetchOptions(input);
+        const parsed = payload;
+        const provider = String(parsed?.provider ?? "").trim();
+        if (!provider) {
+          throw new Error("callback.provider requires a non-empty provider value");
+        }
+        const code = String(parsed?.code ?? "").trim();
+        const state = String(parsed?.state ?? "").trim();
+        if (!code || !state) {
+          throw new Error("callback.provider requires non-empty code and state values");
+        }
+        const endpoint = `/callback/${encodeURIComponent(provider)}`;
+        return request({
+          endpoint,
+          method: "GET",
+          query: {
+            code,
+            state
+          },
+          fetchOptions
+        }, options);
       }
-      return self;
-    },
-    or(expression) {
-      addCondition("or", void 0, expression);
-      return self;
     }
   };
-}
-function toRpcSelect(columns) {
-  if (!columns) return void 0;
-  return Array.isArray(columns) ? columns.join(",") : columns;
-}
-function createRpcFilterMethods(filters, self) {
-  const addFilter = (operator, column, value) => {
-    filters.push({ column, operator, value });
-  };
   return {
-    eq(column, value) {
-      addFilter("eq", column, value);
-      return self;
-    },
-    neq(column, value) {
-      addFilter("neq", column, value);
-      return self;
-    },
-    gt(column, value) {
-      addFilter("gt", column, value);
-      return self;
-    },
-    gte(column, value) {
-      addFilter("gte", column, value);
-      return self;
-    },
-    lt(column, value) {
-      addFilter("lt", column, value);
-      return self;
-    },
-    lte(column, value) {
-      addFilter("lte", column, value);
-      return self;
-    },
-    like(column, value) {
-      addFilter("like", column, value);
-      return self;
+    baseUrl: normalizedBaseUrl,
+    request,
+    signIn: {
+      email: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/email", method: "POST" },
+        input,
+        options
+      ),
+      username: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/username", method: "POST" },
+        input,
+        options
+      ),
+      social: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-in/social", method: "POST" },
+        input,
+        options
+      )
     },
-    ilike(column, value) {
-      addFilter("ilike", column, value);
-      return self;
+    signUp: {
+      email: (input, options) => executePostWithCompatibleInput(
+        resolvedConfig,
+        { endpoint: "/sign-up/email", method: "POST" },
+        input,
+        options
+      )
     },
-    is(column, value) {
-      addFilter("is", column, value);
-      return self;
+    signOut,
+    logout: signOut,
+    getSession: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/get-session", method: "GET" },
+      input,
+      options
+    ),
+    listSessions: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/list-sessions", method: "GET" },
+      input,
+      options
+    ),
+    revokeSession,
+    clearSession: revokeSession,
+    revokeSessions,
+    clearSessions: revokeSessions,
+    revokeOtherSessions,
+    clearOtherSessions: revokeOtherSessions,
+    forgetPassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/forget-password", method: "POST" },
+      input,
+      options
+    ),
+    resetPassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/reset-password", method: "POST" },
+      input,
+      options
+    ),
+    resolveResetPasswordToken,
+    verifyEmail: (input, options) => {
+      const { payload, fetchOptions } = extractFetchOptions(input);
+      const mergedOptions = mergeCallOptions(fetchOptions, options);
+      const query = payload;
+      return callAuthEndpoint(
+        resolvedConfig,
+        { endpoint: "/verify-email", method: "GET" },
+        void 0,
+        query ? {
+          token: query.token,
+          callbackURL: query.callbackURL
+        } : void 0,
+        mergedOptions
+      );
     },
-    in(column, values) {
-      addFilter("in", column, values);
-      return self;
-    }
+    sendVerificationEmail: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/send-verification-email", method: "POST" },
+      input,
+      options
+    ),
+    changeEmail: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/change-email", method: "POST" },
+      input,
+      options
+    ),
+    changePassword: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/change-password", method: "POST" },
+      input,
+      options
+    ),
+    updateUser: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/update-user", method: "POST" },
+      input,
+      options
+    ),
+    deleteUser,
+    deleteUserCallback,
+    linkSocial: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/link-social", method: "POST" },
+      input,
+      options
+    ),
+    listAccounts: (input, options) => executeGetWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/list-accounts", method: "GET" },
+      input,
+      options
+    ),
+    unlinkAccount: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/unlink-account", method: "POST" },
+      input,
+      options
+    ),
+    refreshToken: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/refresh-token", method: "POST" },
+      input,
+      options
+    ),
+    getAccessToken: (input, options) => executePostWithCompatibleInput(
+      resolvedConfig,
+      { endpoint: "/get-access-token", method: "POST" },
+      input,
+      options
+    ),
+    organization,
+    auth
   };
 }
-function createRpcBuilder(functionName, args, baseOptions, client) {
-  const state = {
-    filters: []
+
+// 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
   };
-  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);
+  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 = executeRpc(payloadColumns, payloadOptions);
+      promise = executor(payloadColumns, payloadOptions);
     }
     return promise;
   };
-  const builder = {};
-  const filterMethods = createRpcFilterMethods(state.filters, builder);
-  Object.assign(builder, filterMethods, {
+  const mutationQuery = {
     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;
+    returning(columns = selectedColumns, options) {
+      return mutationQuery.select(columns, options);
     },
-    offset(count) {
-      state.offset = count;
-      return builder;
+    single(columns = selectedColumns, options) {
+      selectedColumns = columns;
+      selectedOptions = options ?? selectedOptions;
+      return run(columns, options).then(toSingleResult);
     },
-    range(from, to) {
-      state.offset = from;
-      state.limit = to - from + 1;
-      return builder;
+    maybeSingle(columns = selectedColumns, options) {
+      return mutationQuery.single(columns, options);
     },
     then(onfulfilled, onrejected) {
       return run(selectedColumns, selectedOptions).then(onfulfilled, onrejected);
@@ -967,129 +1616,518 @@ function createRpcBuilder(functionName, args, baseOptions, client) {
     finally(onfinally) {
       return run(selectedColumns, selectedOptions).finally(onfinally);
     }
-  });
-  return builder;
+  };
+  return mutationQuery;
 }
-function createTableBuilder(tableName, client) {
-  const state = {
-    conditions: []
+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"
   };
-  const addCondition = (operator, column, value, hints) => {
-    const condition = { operator };
-    if (column) {
-      condition.column = column;
-      if (operator === "eq") {
-        condition.eq_column = column;
-      }
+  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}`;
     }
-    if (value !== void 0) {
-      condition.value = value;
-      if (operator === "eq") {
-        condition.eq_value = value;
-      }
+    case "is": {
+      if (value === null) return `${column} IS NULL`;
+      if (value === true) return `${column} IS TRUE`;
+      if (value === false) return `${column} IS FALSE`;
+      return null;
     }
-    if (hints?.valueCast) {
-      condition.value_cast = hints.valueCast;
-      if (operator === "eq") {
-        condition.eq_value_cast = hints.valueCast;
-      }
+    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(", ")})`;
     }
-    if (hints?.columnCast) {
-      condition.column_cast = hints.columnCast;
-      if (operator === "eq") {
-        condition.eq_column_cast = hints.columnCast;
+    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);
       }
-    }
-    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
+      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);
+        }
       });
-      if (query) {
-        const queryResponse = await client.queryGateway({ query }, options);
-        return formatResult(queryResponse);
+      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 = {
-      table_name: resolvedTableName,
-      columns,
-      conditions,
+      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,
-      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
+      order: state.order
     };
-    const response = await client.fetchGateway(payload, options);
+    const response = await client.rpcGateway(payload, mergedOptions);
     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;
+  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, {
-    reset() {
-      state.conditions = [];
-      state.limit = void 0;
-      state.offset = void 0;
-      state.order = void 0;
-      state.currentPage = void 0;
-      state.pageSize = void 0;
-      state.totalPages = void 0;
-      return builder;
+    select(columns = selectedColumns, options) {
+      selectedColumns = columns;
+      selectedOptions = options ?? selectedOptions;
+      return run(columns, options);
     },
-    select(columns = DEFAULT_COLUMNS, options) {
-      return createSelectChain(columns, options);
+    async single(columns, options) {
+      const result = await run(columns, options);
+      return toSingleResult(result);
     },
-    insert(values, options) {
-      if (Array.isArray(values)) {
-        const executeInsertMany = async (columns, selectOptions) => {
-          const mergedOptions = mergeOptions(options, selectOptions);
-          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
-          const payload = {
+    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;
+      state.currentPage = void 0;
+      state.pageSize = void 0;
+      state.totalPages = void 0;
+      return builder;
+    },
+    select(columns = DEFAULT_COLUMNS, options) {
+      return createSelectChain(columns, options);
+    },
+    insert(values, options) {
+      if (Array.isArray(values)) {
+        const executeInsertMany = async (columns, selectOptions) => {
+          const mergedOptions = mergeOptions(options, selectOptions);
+          const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
+          const payload = {
             table_name: resolvedTableName,
             insert_body: asAthenaJsonObjectArray(values)
           };
@@ -1241,6 +2279,7 @@ function createClientFromConfig(config) {
     backend: config.backend,
     headers: config.headers
   });
+  const auth = createAuthClient(config.auth);
   return {
     from(table) {
       return createTableBuilder(table, gateway);
@@ -1257,7 +2296,8 @@ function createClientFromConfig(config) {
         gateway
       );
     },
-    query: createQueryBuilder(gateway)
+    query: createQueryBuilder(gateway),
+    auth: auth.auth
   };
 }
 var DEFAULT_BACKEND = { type: "athena" };
@@ -1331,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
@@ -1371,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;
@@ -1393,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) {
@@ -1410,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;
@@ -1576,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,
@@ -2318,7 +3373,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -2327,7 +3382,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord3(source)) {
+  if (!isRecord4(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -2432,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: {
@@ -2467,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) {
@@ -3223,497 +4305,6 @@ async function runSchemaGenerator(options = {}) {
   };
 }
 
-// src/auth/client.ts
-var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
-var FALLBACK_SDK_VERSION2 = "1.0.0";
-var SDK_NAME2 = "xylex-group/athena-auth";
-var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
-var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
-function normalizeBaseUrl(baseUrl) {
-  return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
-}
-function isRecord4(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeHeaderValue2(value) {
-  return value ? value : void 0;
-}
-function parseResponseBody2(rawText, contentType) {
-  if (!rawText) {
-    return { parsed: null, parseFailed: false };
-  }
-  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
-  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
-  if (!looksJson) {
-    return { parsed: rawText, parseFailed: false };
-  }
-  try {
-    return { parsed: JSON.parse(rawText), parseFailed: false };
-  } catch {
-    return { parsed: rawText, parseFailed: true };
-  }
-}
-function resolveRequestId2(headers) {
-  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
-}
-function resolveErrorMessage2(payload, fallback) {
-  if (isRecord4(payload)) {
-    const messageCandidates = [payload.error, payload.message, payload.details];
-    for (const candidate of messageCandidates) {
-      if (typeof candidate === "string" && candidate.trim().length > 0) {
-        return candidate.trim();
-      }
-    }
-  }
-  if (typeof payload === "string" && payload.trim().length > 0) {
-    return payload.trim();
-  }
-  return fallback;
-}
-function toErrorDetails(input) {
-  return {
-    code: input.code,
-    message: input.message,
-    status: input.status,
-    endpoint: input.endpoint,
-    method: input.method,
-    requestId: input.requestId,
-    hint: input.hint,
-    cause: input.cause
-  };
-}
-function mergeCallOptions(base, override) {
-  if (!base && !override) return void 0;
-  return {
-    ...base,
-    ...override,
-    headers: {
-      ...base?.headers ?? {},
-      ...override?.headers ?? {}
-    }
-  };
-}
-function extractFetchOptions(input) {
-  if (!input) {
-    return {
-      payload: void 0,
-      fetchOptions: void 0
-    };
-  }
-  const { fetchOptions, ...rest } = input;
-  const hasPayloadKeys = Object.keys(rest).length > 0;
-  return {
-    payload: hasPayloadKeys ? rest : void 0,
-    fetchOptions
-  };
-}
-function 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 appendQueryParam(searchParams, key, value) {
-  if (value === void 0 || value === null) return;
-  if (Array.isArray(value)) {
-    value.forEach((item) => {
-      searchParams.append(key, String(item));
-    });
-    return;
-  }
-  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";
-  }
-  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 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 ?? {});
-  }
-  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 })"
-    });
-    return {
-      ok: false,
-      status: 0,
-      data: null,
-      error: details.message,
-      errorDetails: details,
-      raw: null
-    };
-  }
-  try {
-    const response = await fetcher(url, requestInit);
-    const rawText = await response.text();
-    const requestId = resolveRequestId2(response.headers);
-    const parsedBody = parseResponseBody2(rawText ?? "", response.headers.get("content-type"));
-    if (parsedBody.parseFailed) {
-      const details = toErrorDetails({
-        code: "INVALID_JSON",
-        message: "Auth server returned malformed JSON",
-        status: response.status,
-        endpoint: context.endpoint,
-        method: context.method,
-        requestId,
-        hint: "Verify the auth endpoint response body is valid JSON.",
-        cause: rawText.slice(0, 300)
-      });
-      return {
-        ok: false,
-        status: response.status,
-        data: null,
-        error: details.message,
-        errorDetails: details,
-        raw: parsedBody.parsed
-      };
-    }
-    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 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);
-}
-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
-    );
-  };
-  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
-    )
-  };
-}
-
 exports.AthenaClient = AthenaClient;
 exports.AthenaError = AthenaError;
 exports.AthenaErrorCategory = AthenaErrorCategory;
@@ -3743,6 +4334,7 @@ exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
+exports.parseBooleanFlag = parseBooleanFlag;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;