@effect-auth/core 0.1.0-alpha.1 → 0.1.0-alpha.13

package/dist/Client.js

@@ -0,0 +1,985 @@
+import { Effect, Layer, ManagedRuntime, Schema } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/unstable/http";
+import { HttpApiClient } from "effect/unstable/httpapi";
+import { AdminSecurityTimelineListQuery, AdminSessionListQuery, AdminSessionRevokeAllBody, AdminSessionRevokeBody, AdminSessionsHttpBody, AdminTrustedDeviceListQuery, AdminTrustedDeviceRevokeBody, AuthApi, AuthUnauthenticatedError, ActiveSessionsHttpBody, ApiKeyCreateBody, ApiKeyCreatedBody, ApiKeysBody, ApiKeyRevokeBody, AuthenticatedHttpBody, CurrentSessionHttpBody, EmailOtpStartedBody, EmailOtpStartBody, EmailOtpVerifyBody, EmailVerificationStartBody, EmailVerificationVerifyBody, LoginApprovalApproveBody, LoginApprovalFinalizeBody, LoginNotificationReportBody, LoginApprovalReviewStatusBody, LoginApprovalReviewStatusHttpBody, JwtIntrospectBody, JwtIntrospectionBody, JwtJwksBody, JwtRevokeBody, MagicLinkStartedBody, MagicLinkStartBody, MagicLinkVerifyBody, MfaOptionsBody, MfaOptionsResultBody, OAuthAccountUnlinkBody, OAuthAccountUnlinkResolutionBody, OAuthAuthorizationStartedBody, OAuthAuthorizationStartBody, OAuthLinkConfirmationConfirmBody, OAuthLinkConfirmationConfirmedBody, OAuthLinkConfirmationInspectBody, OAuthLinkConfirmationPendingBody, OAuthLinkConfirmationStartBody, OAuthLinkConfirmationStartedBody, OidcDiscoveryMetadataBody, PasskeyAuthenticationFinishBody, PasskeyAuthenticationStartBody, PasskeyAuthenticationStartedBody, PasskeyCredentialRevokeBody, PasskeyCredentialsBody, PasskeyMfaStartBody, PasskeyMfaVerifyBody, PasskeyRegisteredBody, PasskeyRegistrationFinishBody, PasskeyRegistrationStartBody, PasskeyRegistrationStartedBody, PasswordChangeBody, PasswordAuthSuccess, PasswordResetStartBody, PasswordResetVerifyBody, PasswordSetBody, SessionRevokeBody, PasswordSignInBody, PasswordSignUpBody, RecoveryCodeGenerateBody, RecoveryCodeMfaVerifyBody, RecoveryCodeMfaVerifyForFlowBody, RefreshTokenRefreshBody, RefreshTokenRefreshedBody, RecoveryCodeRevokeBody, RecoveryCodesBody, RecoveryCodesGeneratedBody, RecoveryCodeVerifyBody, RecoveryCodeVerifyResultBody, SecurityTimelineEventsBody, SecurityTimelineListQuery, StepUpOptionsResultBody, StepUpPasskeyStartBody, StepUpPasskeyVerifyBody, StepUpRecoveryCodeVerifyBody, StepUpTotpVerifyBody, TrustedDeviceRevokeBody, TrustedDevicesBody, TotpEnrollmentConfirmBody, TotpEnrollmentStartedBody, TotpEnrollmentStartBody, TotpFactorHttpBody, TotpFactorRevokeBody, TotpFactorsBody, TotpMfaVerifyBody, TotpMfaVerifyForFlowBody, TotpVerifyBody, TotpVerifyResultBody, } from "./HttpApi.js";
+const defaultRequestInit = { credentials: "include" };
+const defaultPasskeyPrefix = "/auth/passkey";
+const defaultPasskeyClientPaths = {
+    registrationStart: "/register/start",
+    registrationFinish: "/register/finish",
+    authenticationStart: "/authenticate/start",
+    authenticationFinish: "/authenticate/finish",
+    credentialList: "/credentials",
+    credentialRevoke: "/credentials/revoke",
+};
+const defaultTotpPrefix = "/auth/totp";
+const defaultTotpClientPaths = {
+    enrollmentStart: "/enroll/start",
+    enrollmentConfirm: "/enroll/confirm",
+    verify: "/verify",
+    factorList: "/factors",
+    factorRevoke: "/factors/revoke",
+};
+const defaultRecoveryCodePrefix = "/auth/recovery-codes";
+const defaultRecoveryCodeClientPaths = {
+    generate: "/generate",
+    verify: "/verify",
+    list: "/codes",
+    revoke: "/codes/revoke",
+};
+const defaultApiKeyPrefix = "/auth/api-keys";
+const defaultApiKeyClientPaths = {
+    create: "/",
+    list: "/",
+    revoke: "/revoke",
+};
+const defaultRefreshTokenPrefix = "/auth/token";
+const defaultRefreshTokenClientPaths = {
+    refresh: "/refresh",
+};
+const defaultJwtPrefix = "/auth/jwt";
+const defaultJwtClientPaths = {
+    introspect: "/introspect",
+    revoke: "/revoke",
+};
+const defaultJwtDiscoveryPrefix = "/.well-known";
+const defaultJwtDiscoveryClientPaths = {
+    jwks: "/jwks.json",
+    openidConfiguration: "/openid-configuration",
+};
+const defaultMfaPrefix = "/auth/mfa";
+const defaultMfaClientPaths = {
+    options: "/options",
+    totpVerify: "/totp/verify",
+    totpVerifyForFlow: "/totp/verify-flow",
+    recoveryCodeVerify: "/recovery-code/verify",
+    recoveryCodeVerifyForFlow: "/recovery-code/verify-flow",
+    passkeyStart: "/passkey/start",
+    passkeyVerify: "/passkey/verify",
+};
+const defaultStepUpPrefix = "/auth/step-up";
+const defaultStepUpClientPaths = {
+    options: "/options",
+    totpVerify: "/totp/verify",
+    recoveryCodeVerify: "/recovery-code/verify",
+    passkeyStart: "/passkey/start",
+    passkeyVerify: "/passkey/verify",
+};
+const defaultSecurityTimelinePrefix = "/auth/security";
+const defaultSecurityTimelineClientPaths = {
+    list: "/timeline",
+};
+const defaultAdminSecurityTimelinePrefix = "/auth/admin/security";
+const defaultAdminSecurityTimelineClientPaths = {
+    list: "/timeline",
+};
+const defaultAdminSessionPrefix = "/auth/admin/sessions";
+const defaultAdminSessionClientPaths = {
+    list: "/",
+    revoke: "/revoke",
+    revokeAll: "/revoke-all",
+};
+const defaultTrustedDevicePrefix = "/auth/trusted-devices";
+const defaultTrustedDeviceClientPaths = {
+    list: "/",
+    revoke: "/revoke",
+};
+const defaultAdminTrustedDevicePrefix = "/auth/admin/trusted-devices";
+const defaultAdminTrustedDeviceClientPaths = {
+    list: "/",
+    revoke: "/revoke",
+};
+const defaultOAuthPrefix = "/auth/oauth";
+const defaultOAuthClientPaths = {
+    authorizationStart: "/start",
+    accountUnlink: "/unlink",
+    linkConfirmationStart: "/link-confirmation/start",
+    linkConfirmationInspect: "/link-confirmation/inspect",
+    linkConfirmationConfirm: "/link-confirmation/confirm",
+};
+const joinPath = (prefix, path) => {
+    const normalizedPrefix = prefix.replace(/\/+$/, "");
+    const normalizedPath = path.replace(/^\/+/, "");
+    if (normalizedPath.length === 0) {
+        return normalizedPrefix.length === 0 ? "/" : normalizedPrefix;
+    }
+    if (normalizedPath.startsWith("?") || normalizedPath.startsWith("#")) {
+        return `${normalizedPrefix}${normalizedPath}`;
+    }
+    return normalizedPrefix.length === 0
+        ? `/${normalizedPath}`
+        : `${normalizedPrefix}/${normalizedPath}`;
+};
+const clientUrl = (baseUrl, path) => (baseUrl === undefined ? path : String(new URL(path, baseUrl)));
+const pathWithSearch = (path, searchParams) => {
+    const search = searchParams.toString();
+    if (search.length === 0) {
+        return path;
+    }
+    return `${path}${path.includes("?") ? "&" : "?"}${search}`;
+};
+const responseJson = async (response) => {
+    const text = await response.text();
+    if (text.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text };
+    }
+};
+const throwFailedResponse = async (response) => {
+    const body = await responseJson(response);
+    throw body ?? {
+        code: `http_${response.status}`,
+        message: response.statusText || "Request failed",
+    };
+};
+const requestHeaders = (requestInit, body) => {
+    const headers = new Headers(requestInit.headers);
+    if (body !== undefined && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    return headers;
+};
+const authClientErrorShape = (error) => typeof error === "object" && error !== null
+    ? error
+    : undefined;
+export const authClientErrorMessage = (error) => {
+    const shape = authClientErrorShape(error);
+    if (typeof shape?.message === "string") {
+        return shape.message;
+    }
+    if (typeof shape?.code === "string") {
+        return shape.code;
+    }
+    return error instanceof Error ? error.message : "Request failed";
+};
+export const createPasskeyClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultPasskeyPrefix;
+    const paths = {
+        ...defaultPasskeyClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodePasskeyRegistrationStart = Schema.decodeUnknownEffect(PasskeyRegistrationStartBody);
+    const decodePasskeyRegistrationFinish = Schema.decodeUnknownEffect(PasskeyRegistrationFinishBody);
+    const decodePasskeyAuthenticationStart = Schema.decodeUnknownEffect(PasskeyAuthenticationStartBody);
+    const decodePasskeyAuthenticationFinish = Schema.decodeUnknownEffect(PasskeyAuthenticationFinishBody);
+    const decodePasskeyCredentialRevoke = Schema.decodeUnknownEffect(PasskeyCredentialRevokeBody);
+    const decodePasskeyRegistrationStarted = Schema.decodeUnknownEffect(PasskeyRegistrationStartedBody);
+    const decodePasskeyRegistered = Schema.decodeUnknownEffect(PasskeyRegisteredBody);
+    const decodePasskeyAuthenticationStarted = Schema.decodeUnknownEffect(PasskeyAuthenticationStartedBody);
+    const decodeAuthenticated = Schema.decodeUnknownEffect(AuthenticatedHttpBody);
+    const decodePasskeyCredentials = Schema.decodeUnknownEffect(PasskeyCredentialsBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        registration: {
+            start: async (input, requestOptions) => request("POST", paths.registrationStart, await decode(decodePasskeyRegistrationStart(input)), requestOptions, decodePasskeyRegistrationStarted),
+            finish: async (input, requestOptions) => request("POST", paths.registrationFinish, await decode(decodePasskeyRegistrationFinish(input)), requestOptions, decodePasskeyRegistered),
+        },
+        authentication: {
+            start: async (input, requestOptions) => request("POST", paths.authenticationStart, await decode(decodePasskeyAuthenticationStart(input)), requestOptions, decodePasskeyAuthenticationStarted),
+            finish: async (input, requestOptions) => request("POST", paths.authenticationFinish, await decode(decodePasskeyAuthenticationFinish(input)), requestOptions, decodeAuthenticated),
+        },
+        credentials: {
+            list: (requestOptions) => request("GET", paths.credentialList, undefined, requestOptions, decodePasskeyCredentials),
+            revoke: async (input, requestOptions) => requestNoContent(paths.credentialRevoke, await decode(decodePasskeyCredentialRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createTotpClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultTotpPrefix;
+    const paths = {
+        ...defaultTotpClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeTotpEnrollmentStart = Schema.decodeUnknownEffect(TotpEnrollmentStartBody);
+    const decodeTotpEnrollmentConfirm = Schema.decodeUnknownEffect(TotpEnrollmentConfirmBody);
+    const decodeTotpVerify = Schema.decodeUnknownEffect(TotpVerifyBody);
+    const decodeTotpFactorRevoke = Schema.decodeUnknownEffect(TotpFactorRevokeBody);
+    const decodeTotpEnrollmentStarted = Schema.decodeUnknownEffect(TotpEnrollmentStartedBody);
+    const decodeTotpFactor = Schema.decodeUnknownEffect(TotpFactorHttpBody);
+    const decodeTotpVerifyResult = Schema.decodeUnknownEffect(TotpVerifyResultBody);
+    const decodeTotpFactors = Schema.decodeUnknownEffect(TotpFactorsBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        enrollment: {
+            start: async (input, requestOptions) => request("POST", paths.enrollmentStart, await decode(decodeTotpEnrollmentStart(input)), requestOptions, decodeTotpEnrollmentStarted),
+            confirm: async (input, requestOptions) => request("POST", paths.enrollmentConfirm, await decode(decodeTotpEnrollmentConfirm(input)), requestOptions, decodeTotpFactor),
+        },
+        verification: {
+            verify: async (input, requestOptions) => request("POST", paths.verify, await decode(decodeTotpVerify(input)), requestOptions, decodeTotpVerifyResult),
+        },
+        factors: {
+            list: (requestOptions) => request("GET", paths.factorList, undefined, requestOptions, decodeTotpFactors),
+            revoke: async (input, requestOptions) => requestNoContent(paths.factorRevoke, await decode(decodeTotpFactorRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createRecoveryCodeClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultRecoveryCodePrefix;
+    const paths = {
+        ...defaultRecoveryCodeClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeRecoveryCodeGenerate = Schema.decodeUnknownEffect(RecoveryCodeGenerateBody);
+    const decodeRecoveryCodeVerify = Schema.decodeUnknownEffect(RecoveryCodeVerifyBody);
+    const decodeRecoveryCodeRevoke = Schema.decodeUnknownEffect(RecoveryCodeRevokeBody);
+    const decodeRecoveryCodesGenerated = Schema.decodeUnknownEffect(RecoveryCodesGeneratedBody);
+    const decodeRecoveryCodeVerifyResult = Schema.decodeUnknownEffect(RecoveryCodeVerifyResultBody);
+    const decodeRecoveryCodes = Schema.decodeUnknownEffect(RecoveryCodesBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        generation: {
+            generate: async (input, requestOptions) => request("POST", paths.generate, await decode(decodeRecoveryCodeGenerate(input)), requestOptions, decodeRecoveryCodesGenerated),
+        },
+        verification: {
+            verify: async (input, requestOptions) => request("POST", paths.verify, await decode(decodeRecoveryCodeVerify(input)), requestOptions, decodeRecoveryCodeVerifyResult),
+        },
+        codes: {
+            list: (requestOptions) => request("GET", paths.list, undefined, requestOptions, decodeRecoveryCodes),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeRecoveryCodeRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createApiKeyClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultApiKeyPrefix;
+    const paths = {
+        ...defaultApiKeyClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeApiKeyCreate = Schema.decodeUnknownEffect(ApiKeyCreateBody);
+    const decodeApiKeyRevoke = Schema.decodeUnknownEffect(ApiKeyRevokeBody);
+    const decodeApiKeyCreated = Schema.decodeUnknownEffect(ApiKeyCreatedBody);
+    const decodeApiKeys = Schema.decodeUnknownEffect(ApiKeysBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        keys: {
+            create: async (input, requestOptions) => request("POST", paths.create, await decode(decodeApiKeyCreate(input)), requestOptions, decodeApiKeyCreated),
+            list: (requestOptions) => request("GET", paths.list, undefined, requestOptions, decodeApiKeys),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeApiKeyRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createRefreshTokenClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultRefreshTokenPrefix;
+    const paths = {
+        ...defaultRefreshTokenClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeRefreshTokenRefresh = Schema.decodeUnknownEffect(RefreshTokenRefreshBody);
+    const decodeRefreshTokenRefreshed = Schema.decodeUnknownEffect(RefreshTokenRefreshedBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    return {
+        token: {
+            refresh: async (input, requestOptions) => request(paths.refresh, await decode(decodeRefreshTokenRefresh(input)), requestOptions, decodeRefreshTokenRefreshed),
+        },
+    };
+};
+export const createJwtClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultJwtPrefix;
+    const paths = {
+        ...defaultJwtClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeJwtIntrospect = Schema.decodeUnknownEffect(JwtIntrospectBody);
+    const decodeJwtRevoke = Schema.decodeUnknownEffect(JwtRevokeBody);
+    const decodeJwtIntrospection = Schema.decodeUnknownEffect(JwtIntrospectionBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        token: {
+            introspect: async (input, requestOptions) => request(paths.introspect, await decode(decodeJwtIntrospect(input)), requestOptions, decodeJwtIntrospection),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeJwtRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createJwtDiscoveryClient = (options = {}) => {
+    const requestInit = {
+        credentials: "same-origin",
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultJwtDiscoveryPrefix;
+    const paths = {
+        ...defaultJwtDiscoveryClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeJwtJwks = Schema.decodeUnknownEffect(JwtJwksBody);
+    const decodeOidcDiscoveryMetadata = Schema.decodeUnknownEffect(OidcDiscoveryMetadataBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (path, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "GET",
+            headers: requestHeaders(requestInit, undefined),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    return {
+        keys: {
+            jwks: (requestOptions) => request(paths.jwks, requestOptions, decodeJwtJwks),
+        },
+        metadata: {
+            openidConfiguration: (requestOptions) => request(paths.openidConfiguration, requestOptions, decodeOidcDiscoveryMetadata),
+        },
+    };
+};
+export const createMfaClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultMfaPrefix;
+    const paths = {
+        ...defaultMfaClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeMfaOptions = Schema.decodeUnknownEffect(MfaOptionsBody);
+    const decodeTotpMfaVerify = Schema.decodeUnknownEffect(TotpMfaVerifyBody);
+    const decodeTotpMfaVerifyForFlow = Schema.decodeUnknownEffect(TotpMfaVerifyForFlowBody);
+    const decodeRecoveryCodeMfaVerify = Schema.decodeUnknownEffect(RecoveryCodeMfaVerifyBody);
+    const decodeRecoveryCodeMfaVerifyForFlow = Schema.decodeUnknownEffect(RecoveryCodeMfaVerifyForFlowBody);
+    const decodePasskeyMfaStart = Schema.decodeUnknownEffect(PasskeyMfaStartBody);
+    const decodePasskeyMfaVerify = Schema.decodeUnknownEffect(PasskeyMfaVerifyBody);
+    const decodePasskeyAuthenticationStarted = Schema.decodeUnknownEffect(PasskeyAuthenticationStartedBody);
+    const decodeMfaOptionsResult = Schema.decodeUnknownEffect(MfaOptionsResultBody);
+    const decodeAuthenticated = Schema.decodeUnknownEffect(AuthenticatedHttpBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    return {
+        options: async (input, requestOptions) => request(paths.options, await decode(decodeMfaOptions(input)), requestOptions, decodeMfaOptionsResult),
+        totp: {
+            verify: async (input, requestOptions) => request(paths.totpVerify, await decode(decodeTotpMfaVerify(input)), requestOptions, decodeAuthenticated),
+            verifyForFlow: async (input, requestOptions) => request(paths.totpVerifyForFlow, await decode(decodeTotpMfaVerifyForFlow(input)), requestOptions, decodeAuthenticated),
+        },
+        recoveryCode: {
+            verify: async (input, requestOptions) => request(paths.recoveryCodeVerify, await decode(decodeRecoveryCodeMfaVerify(input)), requestOptions, decodeAuthenticated),
+            verifyForFlow: async (input, requestOptions) => request(paths.recoveryCodeVerifyForFlow, await decode(decodeRecoveryCodeMfaVerifyForFlow(input)), requestOptions, decodeAuthenticated),
+        },
+        passkey: {
+            start: async (input, requestOptions) => request(paths.passkeyStart, await decode(decodePasskeyMfaStart(input)), requestOptions, decodePasskeyAuthenticationStarted),
+            verify: async (input, requestOptions) => request(paths.passkeyVerify, await decode(decodePasskeyMfaVerify(input)), requestOptions, decodeAuthenticated),
+        },
+    };
+};
+export const createStepUpClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultStepUpPrefix;
+    const paths = {
+        ...defaultStepUpClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeStepUpTotpVerify = Schema.decodeUnknownEffect(StepUpTotpVerifyBody);
+    const decodeStepUpRecoveryCodeVerify = Schema.decodeUnknownEffect(StepUpRecoveryCodeVerifyBody);
+    const decodeStepUpPasskeyStart = Schema.decodeUnknownEffect(StepUpPasskeyStartBody);
+    const decodeStepUpPasskeyVerify = Schema.decodeUnknownEffect(StepUpPasskeyVerifyBody);
+    const decodeStepUpOptions = Schema.decodeUnknownEffect(StepUpOptionsResultBody);
+    const decodePasskeyAuthenticationStarted = Schema.decodeUnknownEffect(PasskeyAuthenticationStartedBody);
+    const decodeAuthenticated = Schema.decodeUnknownEffect(AuthenticatedHttpBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    return {
+        options: (requestOptions) => request("GET", paths.options, undefined, requestOptions, decodeStepUpOptions),
+        totp: {
+            verify: async (input, requestOptions) => request("POST", paths.totpVerify, await decode(decodeStepUpTotpVerify(input)), requestOptions, decodeAuthenticated),
+        },
+        recoveryCode: {
+            verify: async (input, requestOptions) => request("POST", paths.recoveryCodeVerify, await decode(decodeStepUpRecoveryCodeVerify(input)), requestOptions, decodeAuthenticated),
+        },
+        passkey: {
+            start: async (input, requestOptions) => request("POST", paths.passkeyStart, await decode(decodeStepUpPasskeyStart(input)), requestOptions, decodePasskeyAuthenticationStarted),
+            verify: async (input, requestOptions) => request("POST", paths.passkeyVerify, await decode(decodeStepUpPasskeyVerify(input)), requestOptions, decodeAuthenticated),
+        },
+    };
+};
+export const createSecurityTimelineClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultSecurityTimelinePrefix;
+    const paths = {
+        ...defaultSecurityTimelineClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeSecurityTimelineList = Schema.decodeUnknownEffect(SecurityTimelineListQuery);
+    const decodeSecurityTimelineEvents = Schema.decodeUnknownEffect(SecurityTimelineEventsBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const listPath = (query) => {
+        const searchParams = new URLSearchParams();
+        if (query.limit !== undefined) {
+            searchParams.set("limit", String(query.limit));
+        }
+        if (query.beforeOccurredAt !== undefined) {
+            searchParams.set("beforeOccurredAt", String(query.beforeOccurredAt));
+        }
+        for (const type of query.types ?? []) {
+            searchParams.append("types", type);
+        }
+        for (const category of query.categories ?? []) {
+            searchParams.append("categories", category);
+        }
+        return pathWithSearch(paths.list, searchParams);
+    };
+    const request = async (path, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "GET",
+            headers: requestHeaders(requestInit, undefined),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeSecurityTimelineEvents(await responseJson(response)));
+    };
+    return {
+        events: {
+            list: async (input, requestOptions) => request(listPath(await decode(decodeSecurityTimelineList(input ?? {}))), requestOptions),
+        },
+    };
+};
+export const createAdminSecurityTimelineClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultAdminSecurityTimelinePrefix;
+    const paths = {
+        ...defaultAdminSecurityTimelineClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeAdminSecurityTimelineList = Schema.decodeUnknownEffect(AdminSecurityTimelineListQuery);
+    const decodeSecurityTimelineEvents = Schema.decodeUnknownEffect(SecurityTimelineEventsBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const listPath = (query) => {
+        const searchParams = new URLSearchParams();
+        searchParams.set("userId", query.userId);
+        if (query.limit !== undefined) {
+            searchParams.set("limit", String(query.limit));
+        }
+        if (query.beforeOccurredAt !== undefined) {
+            searchParams.set("beforeOccurredAt", String(query.beforeOccurredAt));
+        }
+        for (const type of query.types ?? []) {
+            searchParams.append("types", type);
+        }
+        for (const category of query.categories ?? []) {
+            searchParams.append("categories", category);
+        }
+        return pathWithSearch(paths.list, searchParams);
+    };
+    const request = async (path, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "GET",
+            headers: requestHeaders(requestInit, undefined),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeSecurityTimelineEvents(await responseJson(response)));
+    };
+    return {
+        events: {
+            list: async (input, requestOptions) => request(listPath(await decode(decodeAdminSecurityTimelineList(input))), requestOptions),
+        },
+    };
+};
+export const createAdminSessionClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultAdminSessionPrefix;
+    const paths = {
+        ...defaultAdminSessionClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeAdminSessionList = Schema.decodeUnknownEffect(AdminSessionListQuery);
+    const decodeAdminSessionRevoke = Schema.decodeUnknownEffect(AdminSessionRevokeBody);
+    const decodeAdminSessionRevokeAll = Schema.decodeUnknownEffect(AdminSessionRevokeAllBody);
+    const decodeAdminSessions = Schema.decodeUnknownEffect(AdminSessionsHttpBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const listPath = (query) => {
+        const searchParams = new URLSearchParams();
+        searchParams.set("userId", query.userId);
+        return pathWithSearch(paths.list === "/" ? "" : paths.list, searchParams);
+    };
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        sessions: {
+            list: async (input, requestOptions) => request("GET", listPath(await decode(decodeAdminSessionList(input))), undefined, requestOptions, decodeAdminSessions),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeAdminSessionRevoke(input)), requestOptions),
+            revokeAll: async (input, requestOptions) => requestNoContent(paths.revokeAll, await decode(decodeAdminSessionRevokeAll(input)), requestOptions),
+        },
+    };
+};
+export const createTrustedDeviceClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultTrustedDevicePrefix;
+    const paths = {
+        ...defaultTrustedDeviceClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeTrustedDeviceRevoke = Schema.decodeUnknownEffect(TrustedDeviceRevokeBody);
+    const decodeTrustedDevices = Schema.decodeUnknownEffect(TrustedDevicesBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        devices: {
+            list: (requestOptions) => request("GET", paths.list, undefined, requestOptions, decodeTrustedDevices),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeTrustedDeviceRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createAdminTrustedDeviceClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultAdminTrustedDevicePrefix;
+    const paths = {
+        ...defaultAdminTrustedDeviceClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeAdminTrustedDeviceList = Schema.decodeUnknownEffect(AdminTrustedDeviceListQuery);
+    const decodeAdminTrustedDeviceRevoke = Schema.decodeUnknownEffect(AdminTrustedDeviceRevokeBody);
+    const decodeTrustedDevices = Schema.decodeUnknownEffect(TrustedDevicesBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const listPath = (query) => {
+        const searchParams = new URLSearchParams();
+        searchParams.set("userId", query.userId);
+        return pathWithSearch(paths.list === "/" ? "" : paths.list, searchParams);
+    };
+    const request = async (method, path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method,
+            headers: requestHeaders(requestInit, body),
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    const requestNoContent = async (path, body, requestOptions) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+    };
+    return {
+        devices: {
+            list: async (input, requestOptions) => request("GET", listPath(await decode(decodeAdminTrustedDeviceList(input))), undefined, requestOptions, decodeTrustedDevices),
+            revoke: async (input, requestOptions) => requestNoContent(paths.revoke, await decode(decodeAdminTrustedDeviceRevoke(input)), requestOptions),
+        },
+    };
+};
+export const createOAuthClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prefix = options.prefix ?? defaultOAuthPrefix;
+    const paths = {
+        ...defaultOAuthClientPaths,
+        ...options.paths,
+    };
+    const url = (path) => clientUrl(options.baseUrl, joinPath(prefix, path));
+    const decodeOAuthAuthorizationStart = Schema.decodeUnknownEffect(OAuthAuthorizationStartBody);
+    const decodeOAuthAccountUnlink = Schema.decodeUnknownEffect(OAuthAccountUnlinkBody);
+    const decodeOAuthLinkConfirmationStart = Schema.decodeUnknownEffect(OAuthLinkConfirmationStartBody);
+    const decodeOAuthLinkConfirmationInspect = Schema.decodeUnknownEffect(OAuthLinkConfirmationInspectBody);
+    const decodeOAuthLinkConfirmationConfirm = Schema.decodeUnknownEffect(OAuthLinkConfirmationConfirmBody);
+    const decodeOAuthAuthorizationStarted = Schema.decodeUnknownEffect(OAuthAuthorizationStartedBody);
+    const decodeOAuthAccountUnlinkResolution = Schema.decodeUnknownEffect(OAuthAccountUnlinkResolutionBody);
+    const decodeOAuthLinkConfirmationStarted = Schema.decodeUnknownEffect(OAuthLinkConfirmationStartedBody);
+    const decodeOAuthLinkConfirmationPending = Schema.decodeUnknownEffect(OAuthLinkConfirmationPendingBody);
+    const decodeOAuthLinkConfirmationConfirmed = Schema.decodeUnknownEffect(OAuthLinkConfirmationConfirmedBody);
+    const decode = (effect) => Effect.runPromise(effect);
+    const request = async (path, body, requestOptions, decodeResponse) => {
+        const response = await fetch(url(path), {
+            ...requestInit,
+            method: "POST",
+            headers: requestHeaders(requestInit, body),
+            body: JSON.stringify(body),
+            signal: requestOptions?.signal,
+        });
+        if (!response.ok) {
+            return throwFailedResponse(response);
+        }
+        return decode(decodeResponse(await responseJson(response)));
+    };
+    return {
+        authorization: {
+            start: async (input, requestOptions) => request(paths.authorizationStart, await decode(decodeOAuthAuthorizationStart(input)), requestOptions, decodeOAuthAuthorizationStarted),
+        },
+        accounts: {
+            unlink: async (input, requestOptions) => request(paths.accountUnlink, await decode(decodeOAuthAccountUnlink(input)), requestOptions, decodeOAuthAccountUnlinkResolution),
+        },
+        linkConfirmation: {
+            start: async (input, requestOptions) => request(paths.linkConfirmationStart, await decode(decodeOAuthLinkConfirmationStart(input)), requestOptions, decodeOAuthLinkConfirmationStarted),
+            inspect: async (input, requestOptions) => request(paths.linkConfirmationInspect, await decode(decodeOAuthLinkConfirmationInspect(input)), requestOptions, decodeOAuthLinkConfirmationPending),
+            confirm: async (input, requestOptions) => request(paths.linkConfirmationConfirm, await decode(decodeOAuthLinkConfirmationConfirm(input)), requestOptions, decodeOAuthLinkConfirmationConfirmed),
+        },
+    };
+};
+export const createAuthClient = (options = {}) => {
+    const requestInit = {
+        ...defaultRequestInit,
+        ...options.requestInit,
+    };
+    const fetchLayer = FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.RequestInit, requestInit)), options.fetch === undefined
+        ? (layer) => layer
+        : Layer.provide(Layer.succeed(FetchHttpClient.Fetch, options.fetch)));
+    const runtime = ManagedRuntime.make(fetchLayer);
+    const clientEffect = HttpApiClient.make(AuthApi, {
+        baseUrl: options.baseUrl,
+    });
+    const decodePasswordSignIn = Schema.decodeUnknownEffect(PasswordSignInBody);
+    const decodePasswordSignUp = Schema.decodeUnknownEffect(PasswordSignUpBody);
+    const decodePasswordResetStart = Schema.decodeUnknownEffect(PasswordResetStartBody);
+    const decodePasswordResetVerify = Schema.decodeUnknownEffect(PasswordResetVerifyBody);
+    const decodePasswordSet = Schema.decodeUnknownEffect(PasswordSetBody);
+    const decodePasswordChange = Schema.decodeUnknownEffect(PasswordChangeBody);
+    const decodeSessionRevoke = Schema.decodeUnknownEffect(SessionRevokeBody);
+    const decodeEmailVerificationStart = Schema.decodeUnknownEffect(EmailVerificationStartBody);
+    const decodeEmailVerificationVerify = Schema.decodeUnknownEffect(EmailVerificationVerifyBody);
+    const decodeEmailOtpStart = Schema.decodeUnknownEffect(EmailOtpStartBody);
+    const decodeEmailOtpVerify = Schema.decodeUnknownEffect(EmailOtpVerifyBody);
+    const decodeMagicLinkStart = Schema.decodeUnknownEffect(MagicLinkStartBody);
+    const decodeMagicLinkVerify = Schema.decodeUnknownEffect(MagicLinkVerifyBody);
+    const decodeLoginApprovalApprove = Schema.decodeUnknownEffect(LoginApprovalApproveBody);
+    const decodeLoginApprovalStatus = Schema.decodeUnknownEffect(LoginApprovalReviewStatusBody);
+    const decodeLoginApprovalFinalize = Schema.decodeUnknownEffect(LoginApprovalFinalizeBody);
+    const decodeLoginNotificationReport = Schema.decodeUnknownEffect(LoginNotificationReportBody);
+    const run = (effect, requestOptions = {}) => runtime.runPromise(effect, requestOptions);
+    const withClient = (effect, requestOptions) => run(Effect.flatMap(clientEffect, effect), requestOptions);
+    return {
+        password: {
+            signIn: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordSignIn(input), (payload) => client.password.signIn({ payload })), requestOptions),
+            signUp: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordSignUp(input), (payload) => client.password.signUp({ payload })), requestOptions),
+            reset: {
+                start: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordResetStart(input), (payload) => client.password.resetStart({ payload })), requestOptions),
+                verify: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordResetVerify(input), (payload) => client.password.resetVerify({ payload })), requestOptions),
+            },
+            set: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordSet(input), (payload) => client.password.set({ payload })), requestOptions),
+            change: (input, requestOptions) => withClient((client) => Effect.flatMap(decodePasswordChange(input), (payload) => client.password.change({ payload })), requestOptions),
+        },
+        session: {
+            current: (requestOptions) => withClient((client) => client.session.current(), requestOptions),
+            currentOrUndefined: (requestOptions) => withClient((client) => client.session.current().pipe(Effect.catchIf((error) => error instanceof AuthUnauthenticatedError, () => Effect.succeed(undefined))), requestOptions),
+            refresh: (requestOptions) => withClient((client) => client.session.refresh(), requestOptions),
+            logout: (requestOptions) => withClient((client) => client.session.logout(), requestOptions),
+            list: (requestOptions) => withClient((client) => client.session.list(), requestOptions),
+            revoke: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeSessionRevoke(input), (payload) => client.session.revoke({ payload })), requestOptions),
+            revokeOthers: (requestOptions) => withClient((client) => client.session.revokeOthers(), requestOptions),
+        },
+        emailVerification: {
+            start: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeEmailVerificationStart(input), (payload) => client.emailVerification.start({ payload })), requestOptions),
+            verify: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeEmailVerificationVerify(input), (payload) => client.emailVerification.verify({ payload })), requestOptions),
+        },
+        emailOtp: {
+            start: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeEmailOtpStart(input), (payload) => client.emailOtp.start({ payload })), requestOptions),
+            verify: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeEmailOtpVerify(input), (payload) => client.emailOtp.verify({ payload })), requestOptions),
+        },
+        magicLink: {
+            start: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeMagicLinkStart(input), (payload) => client.magicLink.start({ payload })), requestOptions),
+            verify: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeMagicLinkVerify(input), (payload) => client.magicLink.verify({ payload })), requestOptions),
+        },
+        loginApproval: {
+            approve: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeLoginApprovalApprove(input), (payload) => client.loginApproval.approve({ payload })), requestOptions),
+            status: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeLoginApprovalStatus(input), (payload) => client.loginApproval.status({ payload })), requestOptions),
+            finalize: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeLoginApprovalFinalize(input), (payload) => client.loginApproval.finalize({ payload })), requestOptions),
+        },
+        security: {
+            reportLogin: (input, requestOptions) => withClient((client) => Effect.flatMap(decodeLoginNotificationReport(input), (payload) => client.security.reportLogin({ payload })), requestOptions),
+        },
+        dispose: () => runtime.dispose(),
+    };
+};
+//# sourceMappingURL=Client.js.map