@xylex-group/athena 1.6.1 → 1.7.0

package/dist/index.js

@@ -1966,8 +1966,73 @@ function toTypeKind(code) {
 function escapeSqlLiteral(value) {
   return value.replace(/'/g, "''");
 }
+function parsePostgresArrayLiteral(text) {
+  const body = text.slice(1, -1).trim();
+  if (!body) return [];
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of body) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values.map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function coerceStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item : String(item)).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return coerceStringArray(parsed);
+      } catch {
+      }
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      return parsePostgresArrayLiteral(trimmed);
+    }
+    return trimmed.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  return [];
+}
+function normalizePostgresCatalogSchemas(schemas) {
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of schemas ?? []) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    normalized.push(schema);
+  }
+  return normalized.length > 0 ? normalized : ["public"];
+}
 function buildSchemaArrayLiteral(schemas) {
-  const normalized = schemas.length > 0 ? schemas : ["public"];
+  const normalized = normalizePostgresCatalogSchemas(schemas);
   const literals = normalized.map((schema) => `'${escapeSqlLiteral(schema)}'`).join(", ");
   return `ARRAY[${literals}]`;
 }
@@ -2005,8 +2070,10 @@ var PostgresCatalogSnapshotAssembler = class {
   addPrimaryKeyRows(primaryKeyRows) {
     for (const row of primaryKeyRows) {
       const table = this.ensureTable(row.schema_name, row.table_name);
-      table.primaryKey = row.columns;
-      for (const columnName of row.columns) {
+      const primaryKeyColumns = coerceStringArray(row.columns);
+      row.columns = primaryKeyColumns;
+      table.primaryKey = primaryKeyColumns;
+      for (const columnName of primaryKeyColumns) {
         const column = table.columns[columnName];
         if (column) {
           column.isPrimaryKey = true;
@@ -2018,23 +2085,27 @@ var PostgresCatalogSnapshotAssembler = class {
     for (const row of foreignKeyRows) {
       const sourceTable = this.ensureTable(row.source_schema, row.source_table);
       const targetTable = this.ensureTable(row.target_schema, row.target_table);
+      const sourceColumns = coerceStringArray(row.source_columns);
+      const targetColumns = coerceStringArray(row.target_columns);
+      row.source_columns = sourceColumns;
+      row.target_columns = targetColumns;
       const sourceRelationKind = row.source_is_unique ? "one-to-one" : "many-to-one";
       this.upsertRelation(sourceTable, relationKey(row.constraint_name, row.target_table), {
         name: row.constraint_name,
         kind: sourceRelationKind,
-        sourceColumns: row.source_columns,
+        sourceColumns,
         targetSchema: row.target_schema,
         targetModel: row.target_table,
-        targetColumns: row.target_columns
+        targetColumns
       });
       const targetRelationKind = row.source_is_unique ? "one-to-one" : "one-to-many";
       this.upsertRelation(targetTable, relationKey(row.source_table), {
         name: relationKey(row.source_table, row.constraint_name),
         kind: targetRelationKind,
-        sourceColumns: row.target_columns,
+        sourceColumns: targetColumns,
         targetSchema: row.source_schema,
         targetModel: row.source_table,
-        targetColumns: row.source_columns
+        targetColumns: sourceColumns
       });
     }
   }
@@ -2162,12 +2233,14 @@ var PostgresIntrospectionProvider = class {
   backend = "postgresql";
   connectionString;
   database;
+  schemas;
   constructor(options) {
     this.connectionString = options.connectionString;
     this.database = options.database ?? "postgres";
+    this.schemas = normalizePostgresCatalogSchemas(options.schemas);
   }
   async inspect(options) {
-    const schemas = options?.schemas && options.schemas.length > 0 ? options.schemas : ["public"];
+    const schemas = options?.schemas && options.schemas.length > 0 ? normalizePostgresCatalogSchemas(options.schemas) : this.schemas;
     const pool = new Pool({
       connectionString: this.connectionString
     });
@@ -2198,6 +2271,37 @@ var PostgresIntrospectionProvider = class {
 function createPostgresIntrospectionProvider(options) {
   return new PostgresIntrospectionProvider(options);
 }
+
+// src/generator/schema-selection.ts
+var DEFAULT_POSTGRES_SCHEMAS = ["public"];
+function collectSchemaNames(input) {
+  if (!input) {
+    return [];
+  }
+  const values = typeof input === "string" ? [input] : input;
+  return values.flatMap((value) => String(value).split(","));
+}
+function normalizeSchemaSelection(input) {
+  const schemas = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of collectSchemaNames(input)) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    schemas.push(schema);
+  }
+  return schemas.length > 0 ? schemas : [...DEFAULT_POSTGRES_SCHEMAS];
+}
+function resolveProviderSchemas(providerConfig) {
+  if (providerConfig.kind === "postgres") {
+    return normalizeSchemaSelection(providerConfig.schemas);
+  }
+  return [...DEFAULT_POSTGRES_SCHEMAS];
+}
+
+// src/generator/config.ts
 var DEFAULT_CONFIG_CANDIDATES = [
   "athena.config.ts",
   "athena.config.js",
@@ -2207,10 +2311,10 @@ var DEFAULT_CONFIG_CANDIDATES = [
   ".athena.config.js"
 ];
 var DEFAULT_TARGETS = {
-  model: "src/generated/{database_kebab}/{schema_kebab}/{model_kebab}.model.ts",
-  schema: "src/generated/{database_kebab}/{schema_kebab}/index.ts",
-  database: "src/generated/{database_kebab}/index.ts",
-  registry: "src/generated/index.ts"
+  model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+  schema: "athena/schemas/{schema_kebab}.ts",
+  database: "athena/relations.ts",
+  registry: "athena/config.ts"
 };
 var DEFAULT_NAMING = {
   modelType: "pascal",
@@ -2238,6 +2342,15 @@ function normalizeOutputConfig(output) {
     }
   };
 }
+function normalizeProviderConfig(provider) {
+  if (provider.kind === "postgres") {
+    return {
+      ...provider,
+      schemas: normalizeSchemaSelection(provider.schemas)
+    };
+  }
+  return provider;
+}
 function isAthenaGeneratorConfig(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -2247,7 +2360,7 @@ function isAthenaGeneratorConfig(value) {
 }
 function normalizeGeneratorConfig(input) {
   return {
-    provider: input.provider,
+    provider: normalizeProviderConfig(input.provider),
     output: normalizeOutputConfig(input.output),
     naming: {
       ...DEFAULT_NAMING,
@@ -2744,12 +2857,19 @@ export const ${registryConstName} = defineRegistry({
   };
 }
 function assertNoDuplicatePaths(files) {
-  const seen = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
-    if (seen.has(file.path)) {
-      throw new Error(`Generator output collision detected for path: ${file.path}`);
+    const existing = seen.get(file.path);
+    if (existing) {
+      throw new Error(
+        [
+          `Generator output collision detected for path: ${file.path}`,
+          `Collision: ${existing.kind} and ${file.kind}.`,
+          "When syncing multiple schemas, include a schema placeholder such as {schema} or {schema_kebab} in model/schema output targets."
+        ].join(" ")
+      );
     }
-    seen.add(file.path);
+    seen.set(file.path, file);
   }
 }
 var ArtifactComposer = class {
@@ -2909,11 +3029,13 @@ var AthenaGatewayPostgresIntrospectionProvider = class {
         type: this.config.backend ?? "postgresql"
       }
     });
+    this.schemas = normalizeSchemaSelection(this.config.schemas);
   }
   backend = "postgresql";
   client;
+  schemas;
   async inspect(options) {
-    const schemas = options?.schemas && options.schemas.length > 0 ? options.schemas : this.config.schemas && this.config.schemas.length > 0 ? this.config.schemas : ["public"];
+    const schemas = options?.schemas && options.schemas.length > 0 ? normalizeSchemaSelection(options.schemas) : this.schemas;
     const catalogClient = new AthenaGatewayCatalogClient(this.client);
     const queries = buildGatewayCatalogQueries(schemas);
     const [columnRows, enumMap, primaryKeyRows, foreignKeyRows] = await Promise.all([
@@ -2949,7 +3071,8 @@ var ScyllaIntrospectionProvider = class {
 function createPostgresProvider(config) {
   return createPostgresIntrospectionProvider({
     connectionString: config.connectionString,
-    database: config.database
+    database: config.database,
+    schemas: normalizeSchemaSelection(config.schemas)
   });
 }
 function resolveGeneratorProvider(providerConfig, experimentalFlags) {
@@ -2969,12 +3092,6 @@ function resolveGeneratorProvider(providerConfig, experimentalFlags) {
   }
   throw new Error(`Unsupported generator provider kind: ${providerConfig.kind ?? "unknown"}`);
 }
-function extractProviderSchemas(providerConfig) {
-  if (!("schemas" in providerConfig) || !providerConfig.schemas || providerConfig.schemas.length === 0) {
-    return void 0;
-  }
-  return providerConfig.schemas;
-}
 async function writeArtifacts(files, cwd) {
   const writtenFiles = [];
   for (const file of files) {
@@ -2994,7 +3111,7 @@ async function runSchemaGenerator(options = {}) {
   const { configPath, config } = await loadGeneratorConfig(configOptions);
   const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
   const snapshot = await provider.inspect({
-    schemas: extractProviderSchemas(config.provider)
+    schemas: resolveProviderSchemas(config.provider)
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
   const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
@@ -3005,6 +3122,497 @@ async function runSchemaGenerator(options = {}) {
   };
 }
 
-export { AthenaClient, AthenaError, AthenaErrorCategory, AthenaErrorCode, AthenaErrorKind, AthenaGatewayError, Backend, assertInt, coerceInt, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isAthenaGatewayError, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, runSchemaGenerator, unwrap, unwrapOne, unwrapRows, withRetry };
+// src/auth/client.ts
+var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
+var FALLBACK_SDK_VERSION2 = "1.0.0";
+var SDK_NAME2 = "xylex-group/athena-auth";
+var SDK_VERSION2 = typeof process !== "undefined" && process?.env?.npm_package_version ? process.env.npm_package_version : FALLBACK_SDK_VERSION2;
+var SDK_HEADER_VALUE2 = `${SDK_NAME2} ${SDK_VERSION2}`;
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeHeaderValue2(value) {
+  return value ? value : void 0;
+}
+function parseResponseBody2(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
+}
+function resolveRequestId2(headers) {
+  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
+}
+function resolveErrorMessage2(payload, fallback) {
+  if (isRecord3(payload)) {
+    const messageCandidates = [payload.error, payload.message, payload.details];
+    for (const candidate of messageCandidates) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+    }
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function toErrorDetails(input) {
+  return {
+    code: input.code,
+    message: input.message,
+    status: input.status,
+    endpoint: input.endpoint,
+    method: input.method,
+    requestId: input.requestId,
+    hint: input.hint,
+    cause: input.cause
+  };
+}
+function mergeCallOptions(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base,
+    ...override,
+    headers: {
+      ...base?.headers ?? {},
+      ...override?.headers ?? {}
+    }
+  };
+}
+function extractFetchOptions(input) {
+  if (!input) {
+    return {
+      payload: void 0,
+      fetchOptions: void 0
+    };
+  }
+  const { fetchOptions, ...rest } = input;
+  const hasPayloadKeys = Object.keys(rest).length > 0;
+  return {
+    payload: hasPayloadKeys ? rest : void 0,
+    fetchOptions
+  };
+}
+function 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
+    )
+  };
+}
+
+export { AthenaClient, AthenaError, AthenaErrorCategory, AthenaErrorCode, AthenaErrorKind, AthenaGatewayError, Backend, DEFAULT_POSTGRES_SCHEMAS, assertInt, coerceInt, createAuthClient, createClient, createPostgresIntrospectionProvider, createTypedClient, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, findGeneratorConfigPath, generateArtifactsFromSnapshot, identifier, isAthenaGatewayError, isOk, loadGeneratorConfig, normalizeAthenaError, normalizeGeneratorConfig, normalizeSchemaSelection, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, runSchemaGenerator, unwrap, unwrapOne, unwrapRows, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map