@authhero/adapter-interfaces 2.5.0 → 2.6.1

package/dist/types/adapters/index.d.ts

@@ -0,0 +1,217 @@
+import { ActionsAdapter } from "./Actions";
+import { ActionExecutionsAdapter } from "./ActionExecutions";
+import { ActionVersionsAdapter } from "./ActionVersions";
+import { FlowsAdapter } from "./Flows";
+import { CacheAdapter } from "./Cache";
+import { ClientsAdapter } from "./Clients";
+import { ClientConnectionsAdapter } from "./ClientConnections";
+import { ClientGrantsAdapter } from "./ClientGrants";
+import { ClientRegistrationTokensAdapter } from "./ClientRegistrationTokens";
+import { CodesAdapter } from "./Codes";
+import { PasswordsAdapter } from "./Passwords";
+import { SessionsAdapter } from "./Sessions";
+import { TenantsDataAdapter } from "./Tenants";
+import { UserDataAdapter } from "./Users";
+import { LogsDataAdapter } from "./Logs";
+import { LogStreamsAdapter } from "./LogStreams";
+import { MigrationSourcesAdapter } from "./MigrationSources";
+import { ConnectionsAdapter } from "./Connections";
+import { CustomDomainsAdapter } from "./CustomDomains";
+import { KeysAdapter } from "./Keys";
+import { BrandingAdapter } from "./Branding";
+import { HooksAdapter } from "./Hooks";
+import { HookCodeAdapter } from "./HookCode";
+import { ThemesAdapter } from "./Themes";
+import { LoginSessionsAdapter } from "./LoginSessions";
+import { PromptSettingsAdapter } from "./PromptSettings";
+import { EmailProvidersAdapter } from "./EmailProviders";
+import { EmailTemplatesAdapter } from "./EmailTemplates";
+import { RefreshTokensAdapter } from "./RefreshTokens";
+import { FormsAdapter } from "./Forms";
+import { ResourceServersAdapter } from "./ResourceServers";
+import { RolePermissionsAdapter } from "./RolePermissions";
+import { UserPermissionsAdapter } from "./UserPermissions";
+import { RolesAdapter } from "./Roles";
+import { UserRolesAdapter } from "./UserRoles";
+import { OrganizationsAdapter } from "./Organizations";
+import { OrganizationConnectionsAdapter } from "./OrganizationConnections";
+import { UserOrganizationsAdapter } from "./UserOrganizations";
+import { InvitesAdapter } from "./Invites";
+import { GeoAdapter } from "./Geo";
+import { AuthenticationMethodsAdapter } from "./AuthenticationMethods";
+import { StatsAdapter } from "./Stats";
+import { AnalyticsAdapter } from "./Analytics";
+import { UniversalLoginTemplatesAdapter } from "./UniversalLoginTemplates";
+import { CustomTextAdapter } from "./CustomText";
+import { EmailServiceAdapter } from "./EmailService";
+import { SmsServiceAdapter } from "./SmsService";
+import { OutboxAdapter } from "./Outbox";
+import { RateLimitAdapter } from "./RateLimit";
+/**
+ * Parameters for cleaning up expired sessions
+ */
+export interface SessionCleanupParams {
+    /** Optional tenant ID to scope cleanup to a specific tenant */
+    tenant_id?: string;
+    /** Optional user ID to scope cleanup to a specific user */
+    user_id?: string;
+}
+export interface DataAdapters {
+    actions: ActionsAdapter;
+    actionExecutions: ActionExecutionsAdapter;
+    actionVersions: ActionVersionsAdapter;
+    branding: BrandingAdapter;
+    cache?: CacheAdapter;
+    clients: ClientsAdapter;
+    clientConnections: ClientConnectionsAdapter;
+    clientGrants: ClientGrantsAdapter;
+    clientRegistrationTokens?: ClientRegistrationTokensAdapter;
+    codes: CodesAdapter;
+    connections: ConnectionsAdapter;
+    customDomains: CustomDomainsAdapter;
+    emailProviders: EmailProvidersAdapter;
+    emailTemplates: EmailTemplatesAdapter;
+    flows: FlowsAdapter;
+    forms: FormsAdapter;
+    geo?: GeoAdapter;
+    hookCode: HookCodeAdapter;
+    hooks: HooksAdapter;
+    invites: InvitesAdapter;
+    keys: KeysAdapter;
+    loginSessions: LoginSessionsAdapter;
+    logs: LogsDataAdapter;
+    logStreams?: LogStreamsAdapter;
+    /**
+     * Optional tenant-level migration sources for lazy refresh-token re-mint
+     * against upstream IdPs (Auth0, Cognito, Okta, generic OIDC). When unset,
+     * unrecognized refresh tokens fail with `invalid_grant` as usual.
+     */
+    migrationSources?: MigrationSourcesAdapter;
+    passwords: PasswordsAdapter;
+    promptSettings: PromptSettingsAdapter;
+    refreshTokens: RefreshTokensAdapter;
+    resourceServers: ResourceServersAdapter;
+    rolePermissions: RolePermissionsAdapter;
+    userPermissions: UserPermissionsAdapter;
+    roles: RolesAdapter;
+    sessions: SessionsAdapter;
+    stats?: StatsAdapter;
+    /**
+     * Optional richer analytics surface, exposed via `/api/v2/analytics/*`.
+     * Returns ClickHouse-style `{ meta, data }` responses with filtering and
+     * grouping. Unlike `stats`, this is not Auth0 wire-compatible.
+     */
+    analytics?: AnalyticsAdapter;
+    tenants: TenantsDataAdapter;
+    themes: ThemesAdapter;
+    universalLoginTemplates: UniversalLoginTemplatesAdapter;
+    customText: CustomTextAdapter;
+    users: UserDataAdapter;
+    userRoles: UserRolesAdapter;
+    organizations: OrganizationsAdapter;
+    organizationConnections: OrganizationConnectionsAdapter;
+    authenticationMethods: AuthenticationMethodsAdapter;
+    userOrganizations: UserOrganizationsAdapter;
+    emailService?: EmailServiceAdapter;
+    smsService?: SmsServiceAdapter;
+    /** Optional outbox adapter for transactional audit event capture */
+    outbox?: OutboxAdapter;
+    /**
+     * Optional rate-limit adapter for short-window abuse protection
+     * (e.g. backed by the Cloudflare Workers Rate Limiter binding).
+     * Auth flows treat this as opt-in: when undefined, no extra
+     * throttling is applied.
+     */
+    rateLimit?: RateLimitAdapter;
+    /**
+     * Execute a callback within a database transaction.
+     * The callback receives a set of adapters scoped to the transaction.
+     * If the callback throws, the transaction is rolled back.
+     */
+    transaction<T>(fn: (trxAdapters: DataAdapters) => Promise<T>): Promise<T>;
+    /**
+     * Optional session cleanup function.
+     * Cleans up expired login_sessions, sessions, and refresh_tokens.
+     * Can be scoped to a specific tenant and/or user.
+     */
+    sessionCleanup?: (params?: SessionCleanupParams) => Promise<void>;
+    /**
+     * Multi-tenancy configuration set by withRuntimeFallback.
+     * Used by the tenants route for access control and by runtime helpers
+     * (e.g. `getEnrichedClient`) to decide which control plane to inherit from.
+     */
+    multiTenancyConfig?: {
+        controlPlaneTenantId?: string;
+        controlPlaneClientId?: string;
+        /**
+         * Per-tenant override for runtime inheritance lookups. When defined,
+         * runtime helpers must consult it for the tenant being read instead of
+         * relying on the static `controlPlaneTenantId` / `controlPlaneClientId`.
+         * Return `undefined` to opt that tenant out of inheritance.
+         *
+         * Access control, sync direction, and tenant management routing always
+         * use the static `controlPlaneTenantId` and are not affected by this
+         * resolver.
+         */
+        resolveControlPlane?: (params: {
+            tenant_id: string;
+        }) => {
+            tenantId: string;
+            clientId?: string;
+        } | undefined | Promise<{
+            tenantId: string;
+            clientId?: string;
+        } | undefined>;
+    };
+}
+export * from "./Actions";
+export * from "./ActionExecutions";
+export * from "./ActionVersions";
+export * from "./Flows";
+export * from "./Cache";
+export * from "./Clients";
+export * from "./ClientConnections";
+export * from "./ClientGrants";
+export * from "./ClientRegistrationTokens";
+export * from "./Keys";
+export * from "./RolePermissions";
+export * from "./UserPermissions";
+export * from "./UserRoles";
+export * from "./Organizations";
+export * from "./OrganizationConnections";
+export * from "./UserOrganizations";
+export * from "./Invites";
+export * from "./Geo";
+export * from "./Stats";
+export * from "./Analytics";
+export * from "./UniversalLoginTemplates";
+export * from "./CustomText";
+export * from "./AuthenticationMethods";
+export * from "./LogStreams";
+export * from "./MigrationSources";
+export * from "./EmailService";
+export * from "./SmsService";
+export * from "./Outbox";
+export * from "./RateLimit";
+export * from "./HookCode";
+export * from "./CodeExecutor";
+export * from "./RefreshTokens";
+export * from "./Branding";
+export * from "./Codes";
+export * from "./Connections";
+export * from "./CustomDomains";
+export * from "./EmailProviders";
+export * from "./EmailTemplates";
+export * from "./Forms";
+export * from "./Hooks";
+export * from "./LoginSessions";
+export * from "./Logs";
+export * from "./Passwords";
+export * from "./PromptSettings";
+export * from "./ResourceServers";
+export * from "./Roles";
+export * from "./Sessions";
+export * from "./TenantSettings";
+export * from "./Tenants";
+export * from "./Themes";
+export * from "./Users";

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./utils";
+export type * from "./types";
+export type * from "./adapters";

package/dist/types/types/Action.d.ts

@@ -0,0 +1,87 @@
+import { z } from "@hono/zod-openapi";
+export declare const actionTriggerSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const actionDependencySchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>;
+export declare const actionSecretSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const actionInsertSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    supported_triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    runtime: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    is_system: z.ZodOptional<z.ZodBoolean>;
+    inherit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ActionInsert = z.infer<typeof actionInsertSchema>;
+export declare const actionUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    supported_triggers: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    runtime: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>>;
+    secrets: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    is_system: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    inherit: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        built: "built";
+    }>>;
+    deployed_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActionUpdate = z.infer<typeof actionUpdateSchema>;
+export declare const actionSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    supported_triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    runtime: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>;
+    is_system: z.ZodOptional<z.ZodBoolean>;
+    inherit: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodString;
+    tenant_id: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        draft: "draft";
+        built: "built";
+    }>>;
+    deployed_at: z.ZodOptional<z.ZodString>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type Action = z.infer<typeof actionSchema>;

package/dist/types/types/ActionExecution.d.ts

@@ -0,0 +1,128 @@
+import { z } from "@hono/zod-openapi";
+export declare const actionExecutionTriggerIdSchema: z.ZodString;
+export declare const actionExecutionStatusSchema: z.ZodEnum<{
+    unspecified: "unspecified";
+    pending: "pending";
+    final: "final";
+    partial: "partial";
+    canceled: "canceled";
+    suspended: "suspended";
+}>;
+export type ActionExecutionStatus = z.infer<typeof actionExecutionStatusSchema>;
+export declare const actionExecutionErrorSchema: z.ZodObject<{
+    id: z.ZodString;
+    msg: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActionExecutionError = z.infer<typeof actionExecutionErrorSchema>;
+export declare const actionExecutionResultSchema: z.ZodObject<{
+    action_name: z.ZodString;
+    error: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        msg: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    started_at: z.ZodString;
+    ended_at: z.ZodString;
+}, z.core.$strip>;
+export type ActionExecutionResult = z.infer<typeof actionExecutionResultSchema>;
+export declare const actionExecutionLogEntrySchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        log: "log";
+        info: "info";
+        warn: "warn";
+        debug: "debug";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ActionExecutionLogEntry = z.infer<typeof actionExecutionLogEntrySchema>;
+export declare const actionExecutionLogsSchema: z.ZodArray<z.ZodObject<{
+    action_name: z.ZodString;
+    lines: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            log: "log";
+            info: "info";
+            warn: "warn";
+            debug: "debug";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type ActionExecutionLogs = z.infer<typeof actionExecutionLogsSchema>;
+export declare const actionExecutionSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenant_id: z.ZodString;
+    trigger_id: z.ZodString;
+    status: z.ZodEnum<{
+        unspecified: "unspecified";
+        pending: "pending";
+        final: "final";
+        partial: "partial";
+        canceled: "canceled";
+        suspended: "suspended";
+    }>;
+    results: z.ZodArray<z.ZodObject<{
+        action_name: z.ZodString;
+        error: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            msg: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        started_at: z.ZodString;
+        ended_at: z.ZodString;
+    }, z.core.$strip>>;
+    logs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action_name: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            level: z.ZodEnum<{
+                error: "error";
+                log: "log";
+                info: "info";
+                warn: "warn";
+                debug: "debug";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type ActionExecution = z.infer<typeof actionExecutionSchema>;
+export declare const actionExecutionInsertSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        unspecified: "unspecified";
+        pending: "pending";
+        final: "final";
+        partial: "partial";
+        canceled: "canceled";
+        suspended: "suspended";
+    }>;
+    trigger_id: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        action_name: z.ZodString;
+        error: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            msg: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        started_at: z.ZodString;
+        ended_at: z.ZodString;
+    }, z.core.$strip>>;
+    logs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action_name: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            level: z.ZodEnum<{
+                error: "error";
+                log: "log";
+                info: "info";
+                warn: "warn";
+                debug: "debug";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ActionExecutionInsert = z.infer<typeof actionExecutionInsertSchema>;

package/dist/types/types/ActionVersion.d.ts

@@ -0,0 +1,44 @@
+import { z } from "@hono/zod-openapi";
+export declare const actionVersionInsertSchema: z.ZodObject<{
+    action_id: z.ZodString;
+    code: z.ZodString;
+    runtime: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    supported_triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    deployed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ActionVersionInsert = z.infer<typeof actionVersionInsertSchema>;
+export declare const actionVersionSchema: z.ZodObject<{
+    action_id: z.ZodString;
+    code: z.ZodString;
+    runtime: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    supported_triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    deployed: z.ZodDefault<z.ZodBoolean>;
+    id: z.ZodString;
+    tenant_id: z.ZodString;
+    number: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type ActionVersion = z.infer<typeof actionVersionSchema>;

package/dist/types/types/Analytics.d.ts

@@ -0,0 +1,91 @@
+import { z } from "@hono/zod-openapi";
+export declare const analyticsResourceSchema: z.ZodEnum<{
+    sessions: "sessions";
+    logins: "logins";
+    signups: "signups";
+    "active-users": "active-users";
+    "refresh-tokens": "refresh-tokens";
+}>;
+export type AnalyticsResource = z.infer<typeof analyticsResourceSchema>;
+export declare const analyticsIntervalSchema: z.ZodEnum<{
+    hour: "hour";
+    day: "day";
+    week: "week";
+    month: "month";
+}>;
+export type AnalyticsInterval = z.infer<typeof analyticsIntervalSchema>;
+export declare const analyticsGroupBySchema: z.ZodEnum<{
+    client_id: "client_id";
+    connection: "connection";
+    time: "time";
+    user_type: "user_type";
+    event: "event";
+}>;
+export type AnalyticsGroupBy = z.infer<typeof analyticsGroupBySchema>;
+export declare const analyticsUserTypeSchema: z.ZodEnum<{
+    password: "password";
+    passwordless: "passwordless";
+    social: "social";
+    enterprise: "enterprise";
+}>;
+export type AnalyticsUserType = z.infer<typeof analyticsUserTypeSchema>;
+export interface AnalyticsFilters {
+    connection?: string[];
+    client_id?: string[];
+    user_type?: AnalyticsUserType[];
+    user_id?: string[];
+}
+export interface AnalyticsQueryParams {
+    /** Inclusive lower bound, ISO 8601 datetime in UTC */
+    from: string;
+    /** Exclusive upper bound, ISO 8601 datetime in UTC */
+    to: string;
+    interval: AnalyticsInterval;
+    /** IANA timezone for bucket boundaries */
+    tz: string;
+    filters: AnalyticsFilters;
+    group_by: AnalyticsGroupBy[];
+    limit: number;
+    offset: number;
+    /** Column name, prefix with `-` for descending */
+    order_by?: string;
+}
+export interface AnalyticsColumnMeta {
+    name: string;
+    /** ClickHouse-style type label (e.g. "Date", "String", "UInt64", "DateTime") */
+    type: string;
+}
+export interface AnalyticsQueryResponse {
+    meta: AnalyticsColumnMeta[];
+    data: Array<Record<string, unknown>>;
+    rows: number;
+    rows_before_limit_at_least?: number;
+    statistics?: {
+        elapsed: number;
+        rows_read?: number;
+        bytes_read?: number;
+    };
+}
+export declare const analyticsColumnMetaSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strip>;
+export declare const analyticsStatisticsSchema: z.ZodObject<{
+    elapsed: z.ZodNumber;
+    rows_read: z.ZodOptional<z.ZodNumber>;
+    bytes_read: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const analyticsQueryResponseSchema: z.ZodObject<{
+    meta: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    rows: z.ZodNumber;
+    rows_before_limit_at_least: z.ZodOptional<z.ZodNumber>;
+    statistics: z.ZodOptional<z.ZodObject<{
+        elapsed: z.ZodNumber;
+        rows_read: z.ZodOptional<z.ZodNumber>;
+        bytes_read: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/types/types/AttackProtection.d.ts

@@ -0,0 +1,79 @@
+import { z } from "@hono/zod-openapi";
+export declare const breachedPasswordDetectionSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    admin_notification_frequency: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    method: z.ZodOptional<z.ZodString>;
+    stage: z.ZodOptional<z.ZodObject<{
+        "pre-user-registration": z.ZodOptional<z.ZodObject<{
+            shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        "pre-change-password": z.ZodOptional<z.ZodObject<{
+            shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BreachedPasswordDetection = z.infer<typeof breachedPasswordDetectionSchema>;
+export declare const bruteForceProtectionSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodString>;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BruteForceProtection = z.infer<typeof bruteForceProtectionSchema>;
+export declare const suspiciousIpThrottlingSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    stage: z.ZodOptional<z.ZodObject<{
+        "pre-login": z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodOptional<z.ZodNumber>;
+            rate: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        "pre-user-registration": z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodOptional<z.ZodNumber>;
+            rate: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SuspiciousIpThrottling = z.infer<typeof suspiciousIpThrottlingSchema>;
+export declare const attackProtectionSchema: z.ZodObject<{
+    breached_password_detection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        admin_notification_frequency: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        method: z.ZodOptional<z.ZodString>;
+        stage: z.ZodOptional<z.ZodObject<{
+            "pre-user-registration": z.ZodOptional<z.ZodObject<{
+                shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            "pre-change-password": z.ZodOptional<z.ZodObject<{
+                shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    brute_force_protection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodString>;
+        max_attempts: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    suspicious_ip_throttling: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        shields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stage: z.ZodOptional<z.ZodObject<{
+            "pre-login": z.ZodOptional<z.ZodObject<{
+                max_attempts: z.ZodOptional<z.ZodNumber>;
+                rate: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            "pre-user-registration": z.ZodOptional<z.ZodObject<{
+                max_attempts: z.ZodOptional<z.ZodNumber>;
+                rate: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AttackProtection = z.infer<typeof attackProtectionSchema>;