@authhero/adapter-interfaces 2.6.0 → 2.7.0

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

@@ -0,0 +1,22 @@
+import { CustomText, PromptScreen } from "../types";
+export interface CustomTextAdapter {
+    /**
+     * Get custom text for a specific prompt screen and language
+     */
+    get: (tenant_id: string, prompt: PromptScreen, language: string) => Promise<CustomText | null>;
+    /**
+     * Set custom text for a specific prompt screen and language
+     */
+    set: (tenant_id: string, prompt: PromptScreen, language: string, customText: CustomText) => Promise<void>;
+    /**
+     * Delete custom text for a specific prompt screen and language
+     */
+    delete: (tenant_id: string, prompt: PromptScreen, language: string) => Promise<void>;
+    /**
+     * List all custom text entries for a tenant
+     */
+    list: (tenant_id: string) => Promise<Array<{
+        prompt: PromptScreen;
+        language: string;
+    }>>;
+}

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

@@ -0,0 +1,7 @@
+import { EmailProvider } from "../types";
+export interface EmailProvidersAdapter {
+    update: (tenant_id: string, emailProvider: Partial<EmailProvider>) => Promise<void>;
+    create: (tenant_id: string, emailProvider: EmailProvider) => Promise<void>;
+    get: (tenant_id: string) => Promise<EmailProvider | null>;
+    remove: (tenant_id: string) => Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { EmailProvider } from "../types";
+export interface CreateServiceTokenParams {
+    clientId: string;
+    scope: string;
+    audience?: string;
+    expiresInSeconds?: number;
+    customClaims?: Record<string, unknown>;
+}
+export type CreateServiceTokenFn = (params: CreateServiceTokenParams) => Promise<string>;
+export interface EmailServiceSendParams {
+    emailProvider: EmailProvider;
+    to: string;
+    from: string;
+    subject: string;
+    html?: string;
+    text?: string;
+    template: string;
+    data: Record<string, string>;
+    createServiceToken?: CreateServiceTokenFn;
+}
+export interface EmailServiceAdapter {
+    send(params: EmailServiceSendParams): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import { EmailTemplate, EmailTemplateName } from "../types";
+export interface EmailTemplatesAdapter {
+    get: (tenant_id: string, templateName: EmailTemplateName) => Promise<EmailTemplate | null>;
+    list: (tenant_id: string) => Promise<EmailTemplate[]>;
+    create: (tenant_id: string, template: EmailTemplate) => Promise<EmailTemplate>;
+    update: (tenant_id: string, templateName: EmailTemplateName, template: Partial<EmailTemplate>) => Promise<boolean>;
+    remove: (tenant_id: string, templateName: EmailTemplateName) => Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import { Flow, FlowInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListFlowsResponse extends Totals {
+    flows: Flow[];
+}
+export interface FlowsAdapter {
+    create(tenant_id: string, params: FlowInsert): Promise<Flow>;
+    get(tenant_id: string, flow_id: string): Promise<Flow | null>;
+    remove(tenant_id: string, flow_id: string): Promise<boolean>;
+    update(tenant_id: string, flow_id: string, flow: Partial<FlowInsert>): Promise<Flow | null>;
+    list(tenant_id: string, params?: ListParams): Promise<ListFlowsResponse>;
+}

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

@@ -0,0 +1,12 @@
+import { Form, FormInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListFormsResponse extends Totals {
+    forms: Form[];
+}
+export interface FormsAdapter {
+    create(tenant_id: string, params: FormInsert): Promise<Form>;
+    get(tenant_id: string, form_id: string): Promise<Form | null>;
+    remove(tenant_id: string, form_id: string): Promise<boolean>;
+    update(tenant_id: string, form_id: string, form: Partial<FormInsert>): Promise<boolean>;
+    list(tenant_id: string, params?: ListParams): Promise<ListFormsResponse>;
+}

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

@@ -0,0 +1,16 @@
+export interface GeoInfo {
+    country_code: string;
+    city_name: string;
+    latitude: string;
+    longitude: string;
+    time_zone: string;
+    continent_code: string;
+}
+export interface GeoAdapter {
+    /**
+     * Get geo information from request headers
+     * @param headers - Record of HTTP headers (lowercase keys)
+     * @returns Geo information or null if not available
+     */
+    getGeoInfo(headers: Record<string, string>): Promise<GeoInfo | null>;
+}

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

@@ -0,0 +1,7 @@
+import { HookCode, HookCodeInsert } from "../types";
+export interface HookCodeAdapter {
+    create: (tenant_id: string, hookCode: HookCodeInsert) => Promise<HookCode>;
+    get: (tenant_id: string, id: string) => Promise<HookCode | null>;
+    update: (tenant_id: string, id: string, hookCode: Partial<HookCodeInsert>) => Promise<boolean>;
+    remove: (tenant_id: string, id: string) => Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import { Hook, HookInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListHooksResponse extends Totals {
+    hooks: Hook[];
+}
+export interface HooksAdapter {
+    create: (tenant_id: string, hook: HookInsert) => Promise<Hook>;
+    remove: (tenant_id: string, hook_id: string) => Promise<boolean>;
+    get: (tenant_id: string, hook_id: string) => Promise<Hook | null>;
+    update: (tenant_id: string, hook_id: string, hook: Partial<HookInsert>) => Promise<boolean>;
+    list: (tenant_id: string, params?: ListParams) => Promise<ListHooksResponse>;
+}

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

@@ -0,0 +1,12 @@
+import { Invite, InviteInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListInvitesResponse extends Totals {
+    invites: Invite[];
+}
+export interface InvitesAdapter {
+    create(tenant_id: string, params: InviteInsert): Promise<Invite>;
+    get(tenant_id: string, id: string): Promise<Invite | null>;
+    remove(tenant_id: string, id: string): Promise<boolean>;
+    list(tenant_id: string, params?: ListParams): Promise<ListInvitesResponse>;
+    update(tenant_id: string, id: string, params: Partial<InviteInsert>): Promise<boolean>;
+}

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

@@ -0,0 +1,10 @@
+import { SigningKey, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListKeysResponse extends Totals {
+    signingKeys: SigningKey[];
+}
+export interface KeysAdapter {
+    create: (key: SigningKey) => Promise<void>;
+    list: (params?: ListParams) => Promise<ListKeysResponse>;
+    update: (kid: string, key: Partial<Omit<SigningKey, "kid">>) => Promise<boolean>;
+}

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

@@ -0,0 +1,8 @@
+import { LogStream, LogStreamInsert } from "../types/LogStream";
+export interface LogStreamsAdapter {
+    create(tenant_id: string, params: LogStreamInsert): Promise<LogStream>;
+    get(tenant_id: string, id: string): Promise<LogStream | null>;
+    list(tenant_id: string): Promise<LogStream[]>;
+    update(tenant_id: string, id: string, params: Partial<LogStream>): Promise<boolean>;
+    remove(tenant_id: string, id: string): Promise<boolean>;
+}

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

@@ -0,0 +1,7 @@
+import { LoginSession, LoginSessionInsert } from "../types";
+export interface LoginSessionsAdapter {
+    create: (tenant_id: string, session: LoginSessionInsert) => Promise<LoginSession>;
+    update: (tenant_id: string, id: string, session: Partial<LoginSession>) => Promise<boolean>;
+    get: (tenant_id: string, id: string) => Promise<LoginSession | null>;
+    remove: (tenant_id: string, id: string) => Promise<boolean>;
+}

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

@@ -0,0 +1,11 @@
+import { Log, LogInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+interface ListLogsResponse extends Totals {
+    logs: Log[];
+}
+export interface LogsDataAdapter {
+    create(tenantId: string, params: LogInsert): Promise<Log>;
+    list(tenantId: string, params?: ListParams): Promise<ListLogsResponse>;
+    get(tenantId: string, logId: string): Promise<Log | null>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { MigrationSource, MigrationSourceInsert } from "../types/MigrationSource";
+export interface MigrationSourcesAdapter {
+    create: (tenant_id: string, migration_source: MigrationSourceInsert) => Promise<MigrationSource>;
+    get: (tenant_id: string, id: string) => Promise<MigrationSource | null>;
+    list: (tenant_id: string) => Promise<MigrationSource[]>;
+    remove: (tenant_id: string, id: string) => Promise<boolean>;
+    update: (tenant_id: string, id: string, migration_source: Partial<MigrationSourceInsert>) => Promise<boolean>;
+}

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

@@ -0,0 +1,8 @@
+import { OrganizationConnection, OrganizationConnectionInsert } from "../types";
+export interface OrganizationConnectionsAdapter {
+    create(tenant_id: string, organization_id: string, params: OrganizationConnectionInsert): Promise<OrganizationConnection>;
+    list(tenant_id: string, organization_id: string): Promise<OrganizationConnection[]>;
+    get(tenant_id: string, organization_id: string, connection_id: string): Promise<OrganizationConnection | null>;
+    update(tenant_id: string, organization_id: string, connection_id: string, params: Partial<Omit<OrganizationConnectionInsert, "connection_id">>): Promise<OrganizationConnection | null>;
+    remove(tenant_id: string, organization_id: string, connection_id: string): Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import { Organization, OrganizationInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListOrganizationsResponse extends Totals {
+    organizations: Organization[];
+}
+export interface OrganizationsAdapter {
+    create(tenant_id: string, params: OrganizationInsert): Promise<Organization>;
+    get(tenant_id: string, id: string): Promise<Organization | null>;
+    remove(tenant_id: string, id: string): Promise<boolean>;
+    list(tenant_id: string, params?: ListParams): Promise<ListOrganizationsResponse>;
+    update(tenant_id: string, id: string, params: Partial<OrganizationInsert>): Promise<boolean>;
+}

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

@@ -0,0 +1,59 @@
+import { AuditEvent, AuditEventInsert } from "../types/AuditEvent";
+import { ListParams } from "../types/ListParams";
+export interface OutboxEvent extends AuditEvent {
+    /** When the event was persisted to the outbox */
+    created_at: string;
+    /** When the event was successfully processed (null if pending) */
+    processed_at: string | null;
+    /** Number of delivery attempts */
+    retry_count: number;
+    /** When to attempt the next retry (null if not in retry state) */
+    next_retry_at: string | null;
+    /** Last error message from a failed delivery attempt */
+    error: string | null;
+    /** When the event was moved to dead-letter state (null if still active) */
+    dead_lettered_at?: string | null;
+    /** Final error captured when the event was dead-lettered */
+    final_error?: string | null;
+}
+export interface ListFailedEventsResponse {
+    events: OutboxEvent[];
+    start: number;
+    limit: number;
+    length: number;
+}
+export interface OutboxAdapter {
+    /** Write an audit event to the outbox. Returns the event ID. */
+    create(tenantId: string, event: AuditEventInsert): Promise<string>;
+    /** Fetch events by their IDs */
+    getByIds(ids: string[]): Promise<OutboxEvent[]>;
+    /** Fetch unprocessed events ready for delivery */
+    getUnprocessed(limit: number): Promise<OutboxEvent[]>;
+    /** Atomically claim events for exclusive processing. Returns IDs that were successfully claimed. */
+    claimEvents(ids: string[], workerId: string, leaseMs: number): Promise<string[]>;
+    /** Mark events as successfully processed */
+    markProcessed(ids: string[]): Promise<void>;
+    /** Mark an event for retry with a backoff delay */
+    markRetry(id: string, error: string, nextRetryAt: string): Promise<void>;
+    /**
+     * Move an event to dead-letter state. The event is marked processed so the
+     * relay stops retrying it, and the final error is preserved for admin review
+     * via `listFailed`.
+     */
+    deadLetter(id: string, finalError: string): Promise<void>;
+    /**
+     * List dead-lettered events for a tenant, newest first. Used by the
+     * management API's failed-events endpoints.
+     */
+    listFailed(tenantId: string, params?: ListParams): Promise<ListFailedEventsResponse>;
+    /**
+     * Reset a dead-lettered event so the relay retries it. Clears
+     * `dead_lettered_at`, `final_error`, `processed_at`, `retry_count`, and
+     * `next_retry_at`. Scoped to `tenantId` so operators cannot replay events
+     * from other tenants — returns false when no row matches both the id and
+     * the tenant.
+     */
+    replay(id: string, tenantId: string): Promise<boolean>;
+    /** Delete processed events older than the given ISO date. Returns count deleted. */
+    cleanup(olderThan: string): Promise<number>;
+}

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

@@ -0,0 +1,7 @@
+import { Password, PasswordInsert } from "../types";
+export interface PasswordsAdapter {
+    create: (tenant_id: string, params: PasswordInsert) => Promise<Password>;
+    update: (tenant_id: string, params: PasswordInsert) => Promise<boolean>;
+    get: (tenant_id: string, user_id: string) => Promise<Password | null>;
+    list: (tenant_id: string, user_id: string, limit?: number) => Promise<Password[]>;
+}

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

@@ -0,0 +1,5 @@
+import { PromptSetting } from "../types";
+export interface PromptSettingsAdapter {
+    set: (tenant_id: string, promptSetting: Partial<PromptSetting>) => Promise<void>;
+    get: (tenant_id: string) => Promise<PromptSetting>;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Logical buckets that consumers can rate-limit against. Backends decide
+ * how each scope is enforced (e.g. mapping to a separate Cloudflare Workers
+ * Rate Limiter binding with its own deploy-time limit/period).
+ */
+export type RateLimitScope = "pre-login" | "pre-user-registration" | "brute-force";
+export interface RateLimitDecision {
+    /** True if the request is allowed; false if the limit was exceeded. */
+    allowed: boolean;
+    /** Optional retry-after hint in seconds (omitted if the backend can't tell). */
+    retryAfterSeconds?: number;
+}
+export interface RateLimitAdapter {
+    /**
+     * Consume one unit of quota for the given scope and key.
+     *
+     * The numeric threshold and window are backend-specific; the
+     * Cloudflare Workers Rate Limiter binding bakes them in at deploy
+     * time and cannot honor a per-tenant override. Callers that need
+     * per-tenant `max_attempts` should layer their own counter on top.
+     *
+     * Returns `{ allowed: true }` if the scope is not configured, so
+     * callers can opt in by configuring backends without changing call
+     * sites.
+     */
+    consume(scope: RateLimitScope, key: string): Promise<RateLimitDecision>;
+}

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

@@ -0,0 +1,36 @@
+import { RefreshToken, RefreshTokenInsert, Totals, ListParams } from "../types";
+export interface ListRefreshTokenResponse extends Totals {
+    refresh_tokens: RefreshToken[];
+}
+export interface UpdateRefreshTokenOptions {
+    /**
+     * When provided, the adapter also extends the parent login_session's
+     * `expires_at` to `expires_at` (only if the current value is smaller).
+     * The caller is expected to compute the new expiry so the adapter can
+     * avoid a read-before-write and parallelise the two UPDATEs.
+     */
+    loginSessionBump?: {
+        login_id: string;
+        expires_at: string;
+    };
+}
+export interface RefreshTokensAdapter {
+    create: (tenant_id: string, refresh_token: RefreshTokenInsert) => Promise<RefreshToken>;
+    get: (tenant_id: string, id: string) => Promise<RefreshToken | null>;
+    /**
+     * Look up a refresh token by its plaintext `token_lookup` slice (extracted
+     * from the wire format `rt_<lookup>.<secret>`). Returns null if no row
+     * matches. Callers must verify the secret hash before trusting the row.
+     */
+    getByLookup: (tenant_id: string, token_lookup: string) => Promise<RefreshToken | null>;
+    list(tenant_id: string, params?: ListParams): Promise<ListRefreshTokenResponse>;
+    update: (tenant_id: string, id: string, refresh_token: Partial<RefreshToken>, options?: UpdateRefreshTokenOptions) => Promise<boolean>;
+    remove: (tenant_id: string, id: string) => Promise<boolean>;
+    revokeByLoginSession: (tenant_id: string, login_session_id: string, revoked_at: string) => Promise<number>;
+    /**
+     * Soft-revoke every refresh token that shares `family_id` and isn't already
+     * revoked. Used for reuse detection (entire rotation chain torched) and for
+     * admin revocations that should propagate to descendants.
+     */
+    revokeFamily: (tenant_id: string, family_id: string, revoked_at: string) => Promise<number>;
+}

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

@@ -0,0 +1,12 @@
+import { ListParams } from "../types/ListParams";
+import { ResourceServer, ResourceServerInsert, Totals } from "../types";
+export interface ListResourceServersResponse extends Totals {
+    resource_servers: ResourceServer[];
+}
+export interface ResourceServersAdapter {
+    create(tenant_id: string, params: ResourceServerInsert): Promise<ResourceServer>;
+    get(tenant_id: string, id: string): Promise<ResourceServer | null>;
+    list(tenant_id: string, params?: ListParams): Promise<ListResourceServersResponse>;
+    update(tenant_id: string, id: string, resourceServer: Partial<ResourceServerInsert>): Promise<boolean>;
+    remove(tenant_id: string, id: string): Promise<boolean>;
+}

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

@@ -0,0 +1,7 @@
+import { ListParams } from "../types/ListParams";
+import { RolePermissionInsert, RolePermissionList } from "../types/RolePermission";
+export interface RolePermissionsAdapter {
+    assign(tenant_id: string, role_id: string, permissions: RolePermissionInsert[]): Promise<boolean>;
+    remove(tenant_id: string, role_id: string, permissions: Pick<RolePermissionInsert, "resource_server_identifier" | "permission_name">[]): Promise<boolean>;
+    list(tenant_id: string, role_id: string, params?: ListParams): Promise<RolePermissionList>;
+}

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

@@ -0,0 +1,13 @@
+import { Role, RoleInsert } from "../types";
+import { ListParams } from "../types/ListParams";
+import { Totals } from "../types";
+export interface ListRolesResponse extends Totals {
+    roles: Role[];
+}
+export interface RolesAdapter {
+    create(tenantId: string, role: RoleInsert): Promise<Role>;
+    get(tenantId: string, roleId: string): Promise<Role | null>;
+    list(tenantId: string, params?: ListParams): Promise<ListRolesResponse>;
+    update(tenantId: string, roleId: string, updates: Partial<Role>): Promise<boolean>;
+    remove(tenantId: string, roleId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import { Session, SessionInsert, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListSesssionsResponse extends Totals {
+    sessions: Session[];
+}
+export interface SessionsAdapter {
+    create: (tenant_id: string, session: SessionInsert) => Promise<Session>;
+    get: (tenant_id: string, id: string) => Promise<Session | null>;
+    list(tenantId: string, params?: ListParams): Promise<ListSesssionsResponse>;
+    update: (tenant_id: string, id: string, session: Partial<Session>) => Promise<boolean>;
+    remove: (tenant_id: string, id: string) => Promise<boolean>;
+}

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

@@ -0,0 +1,13 @@
+import type { CreateServiceTokenFn } from "./EmailService";
+export interface SmsServiceSendParams {
+    to: string;
+    from?: string;
+    text: string;
+    template: string;
+    options: Record<string, unknown>;
+    data: Record<string, string>;
+    createServiceToken?: CreateServiceTokenFn;
+}
+export interface SmsServiceAdapter {
+    send(params: SmsServiceSendParams): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+import { DailyStats } from "../types";
+export interface StatsListParams {
+    from?: string;
+    to?: string;
+}
+export interface StatsAdapter {
+    /**
+     * Get daily statistics (logins, signups, etc.) for a date range
+     */
+    getDaily(tenantId: string, params?: StatsListParams): Promise<DailyStats[]>;
+    /**
+     * Get the number of active users in the last 30 days
+     */
+    getActiveUsers(tenantId: string): Promise<number>;
+}

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

@@ -0,0 +1,5 @@
+import { TenantSettings } from "../types";
+export interface TenantSettingsAdapter {
+    set: (tenant_id: string, settings: TenantSettings) => Promise<void>;
+    get: (tenant_id: string) => Promise<TenantSettings | null>;
+}

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

@@ -0,0 +1,21 @@
+import { Tenant, Totals } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface CreateTenantParams {
+    friendly_name: string;
+    audience: string;
+    sender_name: string;
+    sender_email: string;
+    id?: string;
+    session_lifetime?: number;
+    idle_session_lifetime?: number;
+}
+export interface TenantsDataAdapter {
+    create(params: CreateTenantParams): Promise<Tenant>;
+    get(id: string): Promise<Tenant | null>;
+    list(params?: ListParams): Promise<{
+        tenants: Tenant[];
+        totals?: Totals;
+    }>;
+    update(id: string, tenant: Partial<Tenant>): Promise<void>;
+    remove(tenantId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,7 @@
+import { ThemeInsert, Theme } from "../types/Theme";
+export interface ThemesAdapter {
+    create: (tenant_id: string, theme: ThemeInsert, themeId?: string) => Promise<Theme>;
+    remove: (tenant_id: string, themeId: string) => Promise<boolean>;
+    get: (tenant_id: string, themeId: string) => Promise<Theme | null>;
+    update: (tenant_id: string, themeId: any, theme: Partial<ThemeInsert>) => Promise<boolean>;
+}

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

@@ -0,0 +1,8 @@
+export interface UniversalLoginTemplate {
+    body: string;
+}
+export interface UniversalLoginTemplatesAdapter {
+    get: (tenant_id: string) => Promise<UniversalLoginTemplate | null>;
+    set: (tenant_id: string, template: UniversalLoginTemplate) => Promise<void>;
+    delete: (tenant_id: string) => Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { Totals } from "../types";
+import { UserOrganization, UserOrganizationInsert } from "../types/UserOrganization";
+import { Organization } from "../types/Organization";
+import { ListParams } from "../types/ListParams";
+export interface UserOrganizationsAdapter {
+    create(tenantId: string, params: UserOrganizationInsert): Promise<UserOrganization>;
+    get(tenantId: string, id: string): Promise<UserOrganization | null>;
+    remove(tenantId: string, id: string): Promise<boolean>;
+    /**
+     * List user-organization relationships
+     * @param tenantId - The tenant ID
+     * @param params - List parameters including query options:
+     *   - q: "user_id:{userId}" to get organizations for a specific user
+     *   - q: "organization_id:{organizationId}" to get members of a specific organization
+     */
+    list(tenantId: string, params?: ListParams): Promise<{
+        userOrganizations: UserOrganization[];
+    } & Totals>;
+    /**
+     * List organizations for a specific user (Auth0 compatible API)
+     * Returns full organization objects instead of user-organization relationships
+     */
+    listUserOrganizations(tenantId: string, userId: string, params?: ListParams): Promise<{
+        organizations: Organization[];
+    } & Totals>;
+    update(tenantId: string, id: string, params: Partial<UserOrganizationInsert>): Promise<boolean>;
+}

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

@@ -0,0 +1,7 @@
+import { ListParams } from "../types/ListParams";
+import { UserPermissionInsert, UserPermissionWithDetailsList } from "../types";
+export interface UserPermissionsAdapter {
+    create(tenant_id: string, user_id: string, permission: UserPermissionInsert, organization_id?: string): Promise<boolean>;
+    remove(tenant_id: string, user_id: string, permission: Pick<UserPermissionInsert, "resource_server_identifier" | "permission_name">, organization_id?: string): Promise<boolean>;
+    list(tenant_id: string, user_id: string, params?: ListParams, organization_id?: string): Promise<UserPermissionWithDetailsList>;
+}

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

@@ -0,0 +1,13 @@
+import { Role } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListUserRolesResponse {
+    roles: Role[];
+    start: number;
+    limit: number;
+    length: number;
+}
+export interface UserRolesAdapter {
+    list(tenantId: string, userId: string, params?: ListParams, organizationId?: string): Promise<Role[]>;
+    create(tenantId: string, userId: string, roleId: string, organizationId?: string): Promise<boolean>;
+    remove(tenantId: string, userId: string, roleId: string, organizationId?: string): Promise<boolean>;
+}

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

@@ -0,0 +1,20 @@
+import { User, Totals, UserInsert } from "../types";
+import { ListParams } from "../types/ListParams";
+export interface ListUsersResponse extends Totals {
+    users: User[];
+}
+export interface UserDataAdapter {
+    get(tenant_id: string, id: string): Promise<User | null>;
+    create(tenantId: string, user: UserInsert): Promise<User>;
+    /**
+     * Create a user without invoking any decorator-level hooks (pre/post
+     * registration hooks, linking, webhooks, etc.). Intended to be called from
+     * inside a registration pipeline that owns hook orchestration and transaction
+     * boundaries itself. The DB-level behavior is identical to `create`.
+     */
+    rawCreate(tenantId: string, user: UserInsert): Promise<User>;
+    remove(tenantId: string, id: string): Promise<boolean>;
+    list(tenantId: string, params?: ListParams): Promise<ListUsersResponse>;
+    update(tenantId: string, id: string, user: Partial<User>): Promise<boolean>;
+    unlink(tenantId: string, id: string, provider: string, linked_user_id: string): Promise<boolean>;
+}