@riffdb/better-auth 0.0.0-stage → 0.2.1

package/dist/generated/client.d.ts

@@ -0,0 +1,2166 @@
+export declare const QUERY_MODULE_HASH: "8dff3a38f6c0a915d7653e7571a2ef5795a89b452990d705f38fe0ac93b5ad9a";
+export declare const CONTRACT_LINEAGE: "RiffDBBetterAuthCore";
+export declare const CONTRACT_VERSION: 1;
+export declare const CONTRACT_BUNDLE_HASH: "74fd255eefcf04f0b054dbb6c4a0bed43a7312d82f7755687c9229ee3206ddfc";
+export interface ContractDriverIdentity {
+    readonly contractLineage: typeof CONTRACT_LINEAGE;
+    readonly contractVersion: bigint;
+    readonly contractBundleHash: typeof CONTRACT_BUNDLE_HASH;
+    readonly role: string;
+    readonly database?: string;
+    readonly applicationManifestHash?: string;
+    readonly operationCatalogHash?: string;
+    readonly roleDefinitionHash?: string;
+    readonly remoteIdentityHash?: string;
+}
+export declare const CONTRACT_DRIVER_IDENTITY: {
+    readonly contractLineage: "RiffDBBetterAuthCore";
+    readonly contractVersion: bigint;
+    readonly contractBundleHash: "74fd255eefcf04f0b054dbb6c4a0bed43a7312d82f7755687c9229ee3206ddfc";
+};
+export declare function driverIdentity(role: string, database?: string): ContractDriverIdentity;
+export declare const APPLICATION_ERROR_REGISTRY: {
+    readonly "RDB-APP-0001": readonly ["application request is structurally invalid", "input", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-INPUT-0101": readonly ["application input is invalid", "input", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-AUTH-0214": readonly ["application operation is not authorized", "authorization", "obtain_permission", readonly ["bind_application_role"]];
+    readonly "RDB-CONTRACT-0101": readonly ["application contract does not match", "contract", "refresh_contract", readonly ["refresh_contract"]];
+    readonly "RDB-QUERY-0101": readonly ["RiffQL query is invalid", "query", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-QUERY-0102": readonly ["RiffQL query is unavailable", "query", "refresh_contract", readonly ["pin_active_module"]];
+    readonly "RDB-MODULE-0101": readonly ["query module is unavailable", "module", "refresh_contract", readonly ["pin_active_module"]];
+    readonly "RDB-CURSOR-0101": readonly ["query cursor is invalid or stale", "cursor", "correct_request", readonly ["restart_from_first_page"]];
+    readonly "RDB-RESOURCE-0101": readonly ["application result exceeds the service limit", "resource", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-STORAGE-0101": readonly ["storage is temporarily unavailable", "storage", "retry", readonly ["retry_later"]];
+    readonly "RDB-UNCERTAIN-0101": readonly ["command outcome is not yet known", "uncertainty", "resolve_with_same_idempotency_key", readonly ["resolve_with_same_idempotency_key"]];
+    readonly "RDB-APP-0002": readonly ["application request was cancelled", "control", "none", readonly []];
+    readonly "RDB-APP-0003": readonly ["application request deadline elapsed", "control", "retry", readonly ["retry_later"]];
+    readonly "RDB-INTERNAL-0001": readonly ["an internal error occurred", "internal", "contact_operator", readonly ["contact_operator_with_incident"]];
+    readonly "RDB-COMMAND-0101": readonly ["idempotency key was reused with different application input", "command", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-COMMAND-0102": readonly ["command execution failed", "command", "contact_operator", readonly []];
+    readonly "RDB-AUTH-0215": readonly ["application capability is revoked", "authorization", "obtain_permission", readonly ["bind_application_role"]];
+    readonly "RDB-PROTOCOL-0101": readonly ["the RiffDB peer returned an invalid application response", "protocol", "contact_operator", readonly []];
+    readonly "RDB-HISTORY-0101": readonly ["observed history predates a database restore", "history", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-HISTORY-0102": readonly ["requested history has been pruned", "history", "correct_request", readonly ["correct_input"]];
+    readonly "RDB-CAPACITY-0101": readonly ["service is over capacity", "capacity", "retry", readonly ["retry_later"]];
+    readonly "RDB-PROJECTION-0101": readonly ["query projections cannot prove one common snapshot", "query", "retry", readonly ["retry_later"]];
+    readonly "RDB-PROJECTION-0102": readonly ["the requested query snapshot has been retired", "query", "correct_request", readonly ["restart_from_first_page"]];
+    readonly "RDB-PROJECTION-0103": readonly ["no query snapshot satisfies the requested freshness", "query", "retry", readonly ["retry_later"]];
+    readonly "RDB-PROJECTION-0104": readonly ["nearest query requires a compiler-owned projected source", "query", "refresh_contract", readonly ["pin_active_module"]];
+    readonly "RDB-REP-0101": readonly ["operation is unavailable in follower mode", "control", "correct_request", readonly []];
+    readonly "RDB-REP-0102": readonly ["primary is durably fenced", "control", "contact_operator", readonly []];
+};
+export type ApplicationErrorCode = keyof typeof APPLICATION_ERROR_REGISTRY;
+export type ApplicationOperation = "DescribeContract" | "CheckQuery" | "ExplainQuery" | "ExecuteQuery" | "DeployQueryModule" | "GetQueryModule" | "ExecuteCommand" | "BatchCommand" | "InspectVectorState";
+export type ApplicationErrorCategory = typeof APPLICATION_ERROR_REGISTRY[ApplicationErrorCode][1];
+export type ApplicationRecoveryAction = typeof APPLICATION_ERROR_REGISTRY[ApplicationErrorCode][2];
+export type ApplicationFixCode = typeof APPLICATION_ERROR_REGISTRY[ApplicationErrorCode][3][number];
+export interface ApplicationErrorDetails {
+    readonly type: "application";
+    readonly code: ApplicationErrorCode;
+    readonly message: string;
+    readonly category: ApplicationErrorCategory;
+    readonly recoveryAction: ApplicationRecoveryAction;
+    readonly operation: ApplicationOperation;
+    readonly contractLineage?: string;
+    readonly contractVersion?: number;
+    readonly operationSymbol?: string;
+    readonly symbolPath: ReadonlyArray<string>;
+    readonly sourceSpan?: {
+        readonly start: number;
+        readonly end: number;
+    };
+    readonly fixes: ReadonlyArray<ApplicationFixCode>;
+    readonly traceId?: string;
+    readonly incidentId?: string;
+}
+export declare class RiffDbApplicationError extends Error {
+    readonly details: ApplicationErrorDetails;
+    readonly name = "RiffDbApplicationError";
+    constructor(details: ApplicationErrorDetails);
+}
+export declare function decodeApplicationError(value: unknown): RiffDbApplicationError;
+export type ApplicationValueSchema = {
+    readonly kind: "bool" | "i64" | "u64" | "string" | "uuid" | "enum" | "bytes" | "date" | "timestamp" | "cursor";
+} | {
+    readonly kind: "limit";
+    readonly maximum?: number;
+} | {
+    readonly kind: "decimal";
+    readonly precision?: number;
+    readonly scale?: number;
+} | {
+    readonly kind: "money";
+    readonly precision?: number;
+    readonly scale?: number;
+    readonly currency?: string;
+} | {
+    readonly kind: "optional";
+    readonly value: ApplicationValueSchema;
+} | {
+    readonly kind: "list";
+    readonly value: ApplicationValueSchema;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly aggregateCanonicalElementBytes?: number;
+} | {
+    readonly kind: "record";
+    readonly fields: ReadonlyArray<{
+        readonly name: string;
+        readonly schema: ApplicationValueSchema;
+        readonly wireId?: number;
+    }>;
+};
+export interface DriverOperationIdentity {
+    readonly name: string;
+    readonly inputSchemaHash: string;
+}
+export interface CompactApplicationValue {
+    readonly type: string;
+    readonly value?: unknown;
+}
+export interface CompactNamedQueryResult {
+    readonly outcome: string;
+    readonly resultName: string;
+    readonly entity: string;
+    readonly fields: ReadonlyArray<string>;
+    readonly rows: ReadonlyArray<ReadonlyArray<CompactApplicationValue>>;
+}
+export interface NamedQueryRequest<P, R> {
+    readonly driverOperation: DriverOperationIdentity;
+    readonly contractLineage: typeof CONTRACT_LINEAGE;
+    readonly contractVersion: typeof CONTRACT_VERSION;
+    readonly contractBundleHash: typeof CONTRACT_BUNDLE_HASH;
+    readonly moduleHash: typeof QUERY_MODULE_HASH;
+    readonly queryName: string;
+    readonly planHash: string;
+    readonly parameters: P;
+    readonly parameterSchema: ApplicationValueSchema;
+    readonly resultSchemas: Readonly<Record<string, ApplicationValueSchema>>;
+    readonly compactDecoder?: (value: CompactNamedQueryResult) => R;
+    readonly decodeError: typeof decodeApplicationError;
+    readonly resultType?: R;
+}
+export interface QueryResponseIdentity {
+    readonly contractLineage: string;
+    readonly contractVersion: number;
+    readonly contractBundleHash: string;
+    readonly moduleHash: string;
+    readonly queryName: string;
+    readonly planHash: string;
+}
+export declare function acceptsIdentity<P, R>(request: NamedQueryRequest<P, R>, identity: QueryResponseIdentity): boolean;
+export interface CommandRequest<I, R> {
+    readonly driverOperation: DriverOperationIdentity;
+    readonly contractLineage: typeof CONTRACT_LINEAGE;
+    readonly contractVersion: typeof CONTRACT_VERSION;
+    readonly commandName: string;
+    readonly planHash: string;
+    readonly input: I;
+    readonly idempotencyKey: string;
+    readonly inputSchema: ApplicationValueSchema;
+    readonly outcomeSchemas: Readonly<Record<string, ApplicationValueSchema>>;
+    readonly decodeError: typeof decodeApplicationError;
+    readonly outcomeType?: R;
+}
+export interface TypedQueryResult<T> {
+    readonly identity: QueryResponseIdentity;
+    readonly value: T;
+    readonly applicationHead: bigint;
+    readonly nextCursor?: string;
+}
+export interface WorkflowSuccessorRevision {
+    readonly binding: string;
+    readonly revision: bigint;
+}
+export interface TypedCommandResult<T> {
+    readonly outcome: T;
+    readonly commitSequence?: bigint;
+    readonly contractVersion: number;
+    readonly planHash: string;
+    readonly replayed: boolean;
+    readonly outcomeUri?: string;
+    readonly workflowRevisions?: ReadonlyArray<WorkflowSuccessorRevision>;
+}
+export type QueryConsistency = "admissionHead";
+export interface QueryOptions {
+    readonly cursor?: string;
+    readonly readAfterCommit?: bigint;
+    readonly consistency?: QueryConsistency;
+}
+export interface CommandBatchProgress {
+    readonly completed: number;
+    readonly total: number;
+    readonly checkpoint: number;
+}
+export declare const MAX_COMMAND_BATCH_CONCURRENCY = 384;
+export declare const DEFAULT_COMMAND_ATTEMPT_BUDGET = 3;
+export interface CommandBatchOptions {
+    readonly concurrency: number;
+    readonly checkpoint?: number;
+    readonly onProgress?: (progress: CommandBatchProgress) => void;
+}
+export interface CommandBatchItem<T> {
+    readonly index: number;
+    readonly result?: TypedCommandResult<T>;
+    readonly error?: unknown;
+}
+export interface CommandBatchResult<T> {
+    readonly items: ReadonlyArray<CommandBatchItem<T>>;
+    readonly checkpoint: number;
+}
+export interface ApplicationTransport {
+    executeNamedQuery<P, R>(request: NamedQueryRequest<P, R>, options?: QueryOptions): Promise<TypedQueryResult<R>>;
+    executeCommand<I, R>(request: CommandRequest<I, R>, attemptBudget: number): Promise<TypedCommandResult<R>>;
+    executeCommandBatch?<I, R>(request: CommandRequest<I, R>, inputs: ReadonlyArray<I>, concurrency: number, checkpoint: number, attemptBudget: number): Promise<CommandBatchResult<R>>;
+    executeVectorInspection?<P, R>(request: VectorInspectionRequest<P, R>, options?: VectorInspectionOptions): Promise<TypedVectorInspectionResult<R>>;
+}
+export interface VectorInspectionRequest<P, R> {
+    readonly driverOperation: DriverOperationIdentity;
+    readonly contractLineage: typeof CONTRACT_LINEAGE;
+    readonly contractVersion: typeof CONTRACT_VERSION;
+    readonly contractBundleHash: typeof CONTRACT_BUNDLE_HASH;
+    readonly entity: string;
+    readonly field: string;
+    readonly inspectionKind: "staleness" | "model_versions";
+    readonly partition: P;
+    readonly partitionSchema: ApplicationValueSchema;
+    readonly limit: number;
+    readonly resultType?: R;
+}
+export interface VectorInspectionOptions {
+    readonly cursor?: string;
+}
+export interface TypedVectorInspectionResult<T> {
+    readonly value: T;
+    readonly applicationHead?: bigint;
+    readonly nextCursor?: string;
+}
+export interface VectorStalenessItem {
+    readonly entityKey: Uint8Array;
+    readonly newestSourceWrite: bigint;
+    readonly embeddingWrite: bigint | null;
+}
+export type VectorStalenessResult = {
+    readonly kind: "staleness_summary";
+    readonly totalEntities: bigint;
+    readonly staleCount: bigint;
+    readonly staleEntityCountThreshold: bigint;
+    readonly sloBreached: boolean;
+} | {
+    readonly kind: "stale_entities";
+    readonly items: ReadonlyArray<VectorStalenessItem>;
+    readonly observedFrontier: bigint | null;
+};
+export interface VectorModelVersionItem {
+    readonly entityKey: Uint8Array;
+    readonly model: string;
+    readonly modelVersion: string;
+    readonly embeddingWrite: bigint;
+}
+export type VectorModelVersionResult = {
+    readonly kind: "model_version_summary";
+    readonly currentCount: bigint;
+    readonly outdatedCount: bigint;
+} | {
+    readonly kind: "outdated_model_entities";
+    readonly items: ReadonlyArray<VectorModelVersionItem>;
+    readonly observedFrontier: bigint | null;
+};
+export declare const ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH: "056edbaabe43e1dc95f1f6af9838747f54d927a90d5bc9f2be045ae266d107d3";
+export interface AdminUsersAllEmailAscParams {
+    readonly organization_id: string;
+    readonly minimum_email: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersAllEmailAscFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersAllEmailAscResult = AdminUsersAllEmailAscFound;
+export declare function isAdminUsersAllEmailAscFound(value: AdminUsersAllEmailAscResult): value is AdminUsersAllEmailAscFound;
+export declare function unwrapAdminUsersAllEmailAscFound(value: AdminUsersAllEmailAscResult | TypedQueryResult<AdminUsersAllEmailAscResult>): AdminUsersAllEmailAscFound;
+export declare function adminUsersAllEmailAsc(parameters: AdminUsersAllEmailAscParams): NamedQueryRequest<AdminUsersAllEmailAscParams, AdminUsersAllEmailAscResult>;
+export declare const ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH: "b64d213477dd2275d98422a6c3460b0cae932dd96255fe9d565005e8afa37fc4";
+export interface AdminUsersContainsAscParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersContainsAscFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersContainsAscResult = AdminUsersContainsAscFound;
+export declare function isAdminUsersContainsAscFound(value: AdminUsersContainsAscResult): value is AdminUsersContainsAscFound;
+export declare function unwrapAdminUsersContainsAscFound(value: AdminUsersContainsAscResult | TypedQueryResult<AdminUsersContainsAscResult>): AdminUsersContainsAscFound;
+export declare function adminUsersContainsAsc(parameters: AdminUsersContainsAscParams): NamedQueryRequest<AdminUsersContainsAscParams, AdminUsersContainsAscResult>;
+export declare const ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH: "57aba8cf311c301e985adc324f97b4d963a38e6efa6058a82e248854d75f2f05";
+export interface AdminUsersContainsDescParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersContainsDescFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersContainsDescResult = AdminUsersContainsDescFound;
+export declare function isAdminUsersContainsDescFound(value: AdminUsersContainsDescResult): value is AdminUsersContainsDescFound;
+export declare function unwrapAdminUsersContainsDescFound(value: AdminUsersContainsDescResult | TypedQueryResult<AdminUsersContainsDescResult>): AdminUsersContainsDescFound;
+export declare function adminUsersContainsDesc(parameters: AdminUsersContainsDescParams): NamedQueryRequest<AdminUsersContainsDescParams, AdminUsersContainsDescResult>;
+export declare const ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH: "7aede9eda624f5b4eb4280ca7b8a1421466ce30091177c9abab4f125987eb4ff";
+export interface AdminUsersEmailContainsCreatedDescParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersEmailContainsCreatedDescFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersEmailContainsCreatedDescResult = AdminUsersEmailContainsCreatedDescFound;
+export declare function isAdminUsersEmailContainsCreatedDescFound(value: AdminUsersEmailContainsCreatedDescResult): value is AdminUsersEmailContainsCreatedDescFound;
+export declare function unwrapAdminUsersEmailContainsCreatedDescFound(value: AdminUsersEmailContainsCreatedDescResult | TypedQueryResult<AdminUsersEmailContainsCreatedDescResult>): AdminUsersEmailContainsCreatedDescFound;
+export declare function adminUsersEmailContainsCreatedDesc(parameters: AdminUsersEmailContainsCreatedDescParams): NamedQueryRequest<AdminUsersEmailContainsCreatedDescParams, AdminUsersEmailContainsCreatedDescResult>;
+export declare const ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH: "453cb6c81f506a1f0ac99bed3cc85da59176d2cb83597d5812d771683a60cb4c";
+export interface AdminUsersEmailContainsImageAscParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersEmailContainsImageAscFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersEmailContainsImageAscResult = AdminUsersEmailContainsImageAscFound;
+export declare function isAdminUsersEmailContainsImageAscFound(value: AdminUsersEmailContainsImageAscResult): value is AdminUsersEmailContainsImageAscFound;
+export declare function unwrapAdminUsersEmailContainsImageAscFound(value: AdminUsersEmailContainsImageAscResult | TypedQueryResult<AdminUsersEmailContainsImageAscResult>): AdminUsersEmailContainsImageAscFound;
+export declare function adminUsersEmailContainsImageAsc(parameters: AdminUsersEmailContainsImageAscParams): NamedQueryRequest<AdminUsersEmailContainsImageAscParams, AdminUsersEmailContainsImageAscResult>;
+export declare const ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH: "924c7acfdcf3f7970917ac611b6eafc9175ac69f735d9e1cc01414fcc6f0e696";
+export interface AdminUsersEndsWithAscParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersEndsWithAscFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersEndsWithAscResult = AdminUsersEndsWithAscFound;
+export declare function isAdminUsersEndsWithAscFound(value: AdminUsersEndsWithAscResult): value is AdminUsersEndsWithAscFound;
+export declare function unwrapAdminUsersEndsWithAscFound(value: AdminUsersEndsWithAscResult | TypedQueryResult<AdminUsersEndsWithAscResult>): AdminUsersEndsWithAscFound;
+export declare function adminUsersEndsWithAsc(parameters: AdminUsersEndsWithAscParams): NamedQueryRequest<AdminUsersEndsWithAscParams, AdminUsersEndsWithAscResult>;
+export declare const ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH: "cab8ad8456533e4ce97388948e4f703cac6f2eebb641b83a91c3b005ece7fffb";
+export interface AdminUsersEndsWithDescParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersEndsWithDescFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersEndsWithDescResult = AdminUsersEndsWithDescFound;
+export declare function isAdminUsersEndsWithDescFound(value: AdminUsersEndsWithDescResult): value is AdminUsersEndsWithDescFound;
+export declare function unwrapAdminUsersEndsWithDescFound(value: AdminUsersEndsWithDescResult | TypedQueryResult<AdminUsersEndsWithDescResult>): AdminUsersEndsWithDescFound;
+export declare function adminUsersEndsWithDesc(parameters: AdminUsersEndsWithDescParams): NamedQueryRequest<AdminUsersEndsWithDescParams, AdminUsersEndsWithDescResult>;
+export declare const ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH: "add0aed3dbd0caea0de2857133a857d49eb7bfc0e031d117270cc873137da5ec";
+export interface AdminUsersStartsWithAscParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersStartsWithAscFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersStartsWithAscResult = AdminUsersStartsWithAscFound;
+export declare function isAdminUsersStartsWithAscFound(value: AdminUsersStartsWithAscResult): value is AdminUsersStartsWithAscFound;
+export declare function unwrapAdminUsersStartsWithAscFound(value: AdminUsersStartsWithAscResult | TypedQueryResult<AdminUsersStartsWithAscResult>): AdminUsersStartsWithAscFound;
+export declare function adminUsersStartsWithAsc(parameters: AdminUsersStartsWithAscParams): NamedQueryRequest<AdminUsersStartsWithAscParams, AdminUsersStartsWithAscResult>;
+export declare const ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH: "23c1561fb3956217e79d1b358be468e55c4021b887e927a4fb3c0484c92be872";
+export interface AdminUsersStartsWithDescParams {
+    readonly organization_id: string;
+    readonly needle: string;
+    readonly user_id?: string | null;
+    readonly limit?: number;
+    readonly offset?: bigint;
+}
+export interface AdminUsersStartsWithDescFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+    readonly total: {
+        readonly value: bigint;
+    };
+}
+export type AdminUsersStartsWithDescResult = AdminUsersStartsWithDescFound;
+export declare function isAdminUsersStartsWithDescFound(value: AdminUsersStartsWithDescResult): value is AdminUsersStartsWithDescFound;
+export declare function unwrapAdminUsersStartsWithDescFound(value: AdminUsersStartsWithDescResult | TypedQueryResult<AdminUsersStartsWithDescResult>): AdminUsersStartsWithDescFound;
+export declare function adminUsersStartsWithDesc(parameters: AdminUsersStartsWithDescParams): NamedQueryRequest<AdminUsersStartsWithDescParams, AdminUsersStartsWithDescResult>;
+export declare const FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH: "14a08df3dd8a74ea0a5622804bf0c2424086ee73eb10ce57d7df336a7d25f5ba";
+export declare const FIND_ACCOUNT_BY_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindAccountById";
+    readonly entity: "Account";
+    readonly field: "access_token";
+}, {
+    readonly query: "FindAccountById";
+    readonly entity: "Account";
+    readonly field: "refresh_token";
+}, {
+    readonly query: "FindAccountById";
+    readonly entity: "Account";
+    readonly field: "id_token";
+}, {
+    readonly query: "FindAccountById";
+    readonly entity: "Account";
+    readonly field: "password";
+}];
+export interface FindAccountByIdParams {
+    readonly organization_id: string;
+    readonly id: string;
+}
+export interface FindAccountByIdFound {
+    readonly outcome: "Found";
+    readonly accounts: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly account_id: string;
+        readonly provider_id: string;
+        readonly access_token: string | null;
+        readonly refresh_token: string | null;
+        readonly access_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly refresh_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly scope: string | null;
+        readonly id_token: string | null;
+        readonly password: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindAccountByIdResult = FindAccountByIdFound;
+export declare function isFindAccountByIdFound(value: FindAccountByIdResult): value is FindAccountByIdFound;
+export declare function unwrapFindAccountByIdFound(value: FindAccountByIdResult | TypedQueryResult<FindAccountByIdResult>): FindAccountByIdFound;
+export declare function redactFindAccountByIdResult(value: FindAccountByIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_ACCOUNT_BY_ID_SECRET_OUTPUTS;
+};
+export declare function findAccountById(parameters: FindAccountByIdParams): NamedQueryRequest<FindAccountByIdParams, FindAccountByIdResult>;
+export declare const FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH: "e6c4517a46d725780e79725ca3fdaba2208ef4b282d49f484121eee76c043831";
+export declare const FIND_ACCOUNT_BY_PROVIDER_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindAccountByProvider";
+    readonly entity: "Account";
+    readonly field: "access_token";
+}, {
+    readonly query: "FindAccountByProvider";
+    readonly entity: "Account";
+    readonly field: "refresh_token";
+}, {
+    readonly query: "FindAccountByProvider";
+    readonly entity: "Account";
+    readonly field: "id_token";
+}, {
+    readonly query: "FindAccountByProvider";
+    readonly entity: "Account";
+    readonly field: "password";
+}];
+export interface FindAccountByProviderParams {
+    readonly organization_id: string;
+    readonly account_id: string;
+    readonly provider_id: string;
+}
+export interface FindAccountByProviderFound {
+    readonly outcome: "Found";
+    readonly accounts: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly account_id: string;
+        readonly provider_id: string;
+        readonly access_token: string | null;
+        readonly refresh_token: string | null;
+        readonly access_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly refresh_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly scope: string | null;
+        readonly id_token: string | null;
+        readonly password: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindAccountByProviderResult = FindAccountByProviderFound;
+export declare function isFindAccountByProviderFound(value: FindAccountByProviderResult): value is FindAccountByProviderFound;
+export declare function unwrapFindAccountByProviderFound(value: FindAccountByProviderResult | TypedQueryResult<FindAccountByProviderResult>): FindAccountByProviderFound;
+export declare function redactFindAccountByProviderResult(value: FindAccountByProviderResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_ACCOUNT_BY_PROVIDER_SECRET_OUTPUTS;
+};
+export declare function findAccountByProvider(parameters: FindAccountByProviderParams): NamedQueryRequest<FindAccountByProviderParams, FindAccountByProviderResult>;
+export declare const FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH: "ccdc524ca64ad667c209de25b4ce977f43b53ffdd8eb1b70fedf29fc99f27da6";
+export declare const FIND_ACCOUNTS_BY_USER_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindAccountsByUserId";
+    readonly entity: "Account";
+    readonly field: "access_token";
+}, {
+    readonly query: "FindAccountsByUserId";
+    readonly entity: "Account";
+    readonly field: "refresh_token";
+}, {
+    readonly query: "FindAccountsByUserId";
+    readonly entity: "Account";
+    readonly field: "id_token";
+}, {
+    readonly query: "FindAccountsByUserId";
+    readonly entity: "Account";
+    readonly field: "password";
+}];
+export interface FindAccountsByUserIdParams {
+    readonly organization_id: string;
+    readonly user_id: string;
+    readonly after?: string | null;
+}
+export interface FindAccountsByUserIdFound {
+    readonly outcome: "Found";
+    readonly accounts: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly account_id: string;
+        readonly provider_id: string;
+        readonly access_token: string | null;
+        readonly refresh_token: string | null;
+        readonly access_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly refresh_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly scope: string | null;
+        readonly id_token: string | null;
+        readonly password: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindAccountsByUserIdResult = FindAccountsByUserIdFound;
+export declare function isFindAccountsByUserIdFound(value: FindAccountsByUserIdResult): value is FindAccountsByUserIdFound;
+export declare function unwrapFindAccountsByUserIdFound(value: FindAccountsByUserIdResult | TypedQueryResult<FindAccountsByUserIdResult>): FindAccountsByUserIdFound;
+export declare function redactFindAccountsByUserIdResult(value: FindAccountsByUserIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_ACCOUNTS_BY_USER_ID_SECRET_OUTPUTS;
+};
+export declare function findAccountsByUserId(parameters: FindAccountsByUserIdParams): NamedQueryRequest<FindAccountsByUserIdParams, FindAccountsByUserIdResult>;
+export declare const FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH: "21d13b3c30b4a4059f3c436e290d11c20f0f1d1154e05fb48ae3dd0da882526d";
+export declare const FIND_ACCOUNTS_BY_USER_PROVIDER_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindAccountsByUserProvider";
+    readonly entity: "Account";
+    readonly field: "access_token";
+}, {
+    readonly query: "FindAccountsByUserProvider";
+    readonly entity: "Account";
+    readonly field: "refresh_token";
+}, {
+    readonly query: "FindAccountsByUserProvider";
+    readonly entity: "Account";
+    readonly field: "id_token";
+}, {
+    readonly query: "FindAccountsByUserProvider";
+    readonly entity: "Account";
+    readonly field: "password";
+}];
+export interface FindAccountsByUserProviderParams {
+    readonly organization_id: string;
+    readonly user_id: string;
+    readonly provider_id: string;
+    readonly after?: string | null;
+}
+export interface FindAccountsByUserProviderFound {
+    readonly outcome: "Found";
+    readonly accounts: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly account_id: string;
+        readonly provider_id: string;
+        readonly access_token: string | null;
+        readonly refresh_token: string | null;
+        readonly access_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly refresh_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly scope: string | null;
+        readonly id_token: string | null;
+        readonly password: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindAccountsByUserProviderResult = FindAccountsByUserProviderFound;
+export declare function isFindAccountsByUserProviderFound(value: FindAccountsByUserProviderResult): value is FindAccountsByUserProviderFound;
+export declare function unwrapFindAccountsByUserProviderFound(value: FindAccountsByUserProviderResult | TypedQueryResult<FindAccountsByUserProviderResult>): FindAccountsByUserProviderFound;
+export declare function redactFindAccountsByUserProviderResult(value: FindAccountsByUserProviderResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_ACCOUNTS_BY_USER_PROVIDER_SECRET_OUTPUTS;
+};
+export declare function findAccountsByUserProvider(parameters: FindAccountsByUserProviderParams): NamedQueryRequest<FindAccountsByUserProviderParams, FindAccountsByUserProviderResult>;
+export declare const FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: "de1e5232a64a32057699b5ac21f1b43e69d755a3c143595f906fe63e16147264";
+export declare const FIND_ACTIVE_SESSIONS_BY_USER_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindActiveSessionsByUserId";
+    readonly entity: "Session";
+    readonly field: "token";
+}];
+export interface FindActiveSessionsByUserIdParams {
+    readonly organization_id: string;
+    readonly user_id: string;
+    readonly expires_after: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly after?: string | null;
+}
+export interface FindActiveSessionsByUserIdFound {
+    readonly outcome: "Found";
+    readonly sessions: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly token: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly ip_address: string | null;
+        readonly user_agent: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindActiveSessionsByUserIdResult = FindActiveSessionsByUserIdFound;
+export declare function isFindActiveSessionsByUserIdFound(value: FindActiveSessionsByUserIdResult): value is FindActiveSessionsByUserIdFound;
+export declare function unwrapFindActiveSessionsByUserIdFound(value: FindActiveSessionsByUserIdResult | TypedQueryResult<FindActiveSessionsByUserIdResult>): FindActiveSessionsByUserIdFound;
+export declare function redactFindActiveSessionsByUserIdResult(value: FindActiveSessionsByUserIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_ACTIVE_SESSIONS_BY_USER_ID_SECRET_OUTPUTS;
+};
+export declare function findActiveSessionsByUserId(parameters: FindActiveSessionsByUserIdParams): NamedQueryRequest<FindActiveSessionsByUserIdParams, FindActiveSessionsByUserIdResult>;
+export declare const FIND_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH: "f968271d103a76cc6b2a5496f5cceffe4cff5aa39d2a370379b518d8e7d90771";
+export declare const FIND_CREDENTIAL_ACCOUNT_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindCredentialAccount";
+    readonly entity: "Account";
+    readonly field: "access_token";
+}, {
+    readonly query: "FindCredentialAccount";
+    readonly entity: "Account";
+    readonly field: "refresh_token";
+}, {
+    readonly query: "FindCredentialAccount";
+    readonly entity: "Account";
+    readonly field: "id_token";
+}, {
+    readonly query: "FindCredentialAccount";
+    readonly entity: "Account";
+    readonly field: "password";
+}];
+export interface FindCredentialAccountParams {
+    readonly organization_id: string;
+    readonly user_id: string;
+    readonly account_id: string;
+    readonly provider_id: string;
+}
+export interface FindCredentialAccountFound {
+    readonly outcome: "Found";
+    readonly accounts: ReadonlyArray<{
+        readonly organization_id: string;
+        readonly user_id: string;
+        readonly id: string;
+        readonly account_id: string;
+        readonly provider_id: string;
+        readonly access_token: string | null;
+        readonly refresh_token: string | null;
+        readonly id_token: string | null;
+        readonly password: string | null;
+        readonly access_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly refresh_token_expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        } | null;
+        readonly scope: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindCredentialAccountResult = FindCredentialAccountFound;
+export declare function isFindCredentialAccountFound(value: FindCredentialAccountResult): value is FindCredentialAccountFound;
+export declare function unwrapFindCredentialAccountFound(value: FindCredentialAccountResult | TypedQueryResult<FindCredentialAccountResult>): FindCredentialAccountFound;
+export declare function redactFindCredentialAccountResult(value: FindCredentialAccountResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_CREDENTIAL_ACCOUNT_SECRET_OUTPUTS;
+};
+export declare function findCredentialAccount(parameters: FindCredentialAccountParams): NamedQueryRequest<FindCredentialAccountParams, FindCredentialAccountResult>;
+export declare const FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH: "6c799850ba3b2eb3222aac85a76f40492c46de76870075b029f3b4ac897ed8b9";
+export interface FindExpiredVerificationIdsParams {
+    readonly organization_id: string;
+    readonly expires_before: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly after?: string | null;
+}
+export interface FindExpiredVerificationIdsFound {
+    readonly outcome: "Found";
+    readonly verifications: ReadonlyArray<{
+        readonly verification_id: string;
+    }>;
+}
+export type FindExpiredVerificationIdsResult = FindExpiredVerificationIdsFound;
+export declare function isFindExpiredVerificationIdsFound(value: FindExpiredVerificationIdsResult): value is FindExpiredVerificationIdsFound;
+export declare function unwrapFindExpiredVerificationIdsFound(value: FindExpiredVerificationIdsResult | TypedQueryResult<FindExpiredVerificationIdsResult>): FindExpiredVerificationIdsFound;
+export declare function findExpiredVerificationIds(parameters: FindExpiredVerificationIdsParams): NamedQueryRequest<FindExpiredVerificationIdsParams, FindExpiredVerificationIdsResult>;
+export declare const FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH: "b3832c0a8a316d3fcbc62b388fbe09ceb6624b55482195f7642553467cba6fcb";
+export declare const FIND_LATEST_VERIFICATION_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindLatestVerification";
+    readonly entity: "Verification";
+    readonly field: "value";
+}];
+export interface FindLatestVerificationParams {
+    readonly organization_id: string;
+    readonly identifier: string;
+}
+export interface FindLatestVerificationFound {
+    readonly outcome: "Found";
+    readonly verifications: ReadonlyArray<{
+        readonly verification_id: string;
+        readonly identifier: string;
+        readonly value: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindLatestVerificationResult = FindLatestVerificationFound;
+export declare function isFindLatestVerificationFound(value: FindLatestVerificationResult): value is FindLatestVerificationFound;
+export declare function unwrapFindLatestVerificationFound(value: FindLatestVerificationResult | TypedQueryResult<FindLatestVerificationResult>): FindLatestVerificationFound;
+export declare function redactFindLatestVerificationResult(value: FindLatestVerificationResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_LATEST_VERIFICATION_SECRET_OUTPUTS;
+};
+export declare function findLatestVerification(parameters: FindLatestVerificationParams): NamedQueryRequest<FindLatestVerificationParams, FindLatestVerificationResult>;
+export declare const FIND_SESSION_BY_ID_QUERY_PLAN_HASH: "c92eb2035c0e3ca7dedbaa42a4e2efe7bc4786a65213394da7f5d3beb579a2a1";
+export declare const FIND_SESSION_BY_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindSessionById";
+    readonly entity: "Session";
+    readonly field: "token";
+}];
+export interface FindSessionByIdParams {
+    readonly organization_id: string;
+    readonly id: string;
+}
+export interface FindSessionByIdFound {
+    readonly outcome: "Found";
+    readonly sessions: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly token: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly ip_address: string | null;
+        readonly user_agent: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindSessionByIdResult = FindSessionByIdFound;
+export declare function isFindSessionByIdFound(value: FindSessionByIdResult): value is FindSessionByIdFound;
+export declare function unwrapFindSessionByIdFound(value: FindSessionByIdResult | TypedQueryResult<FindSessionByIdResult>): FindSessionByIdFound;
+export declare function redactFindSessionByIdResult(value: FindSessionByIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_SESSION_BY_ID_SECRET_OUTPUTS;
+};
+export declare function findSessionById(parameters: FindSessionByIdParams): NamedQueryRequest<FindSessionByIdParams, FindSessionByIdResult>;
+export declare const FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH: "a8a12334a3d34c30d54be828bdcc9b9b77223303c3f9681e4a602c92341876ec";
+export declare const FIND_SESSION_BY_TOKEN_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindSessionByToken";
+    readonly entity: "Session";
+    readonly field: "token";
+}];
+export interface FindSessionByTokenParams {
+    readonly organization_id: string;
+    readonly token: string;
+}
+export interface FindSessionByTokenFound {
+    readonly outcome: "Found";
+    readonly sessions: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly token: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly ip_address: string | null;
+        readonly user_agent: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindSessionByTokenResult = FindSessionByTokenFound;
+export declare function isFindSessionByTokenFound(value: FindSessionByTokenResult): value is FindSessionByTokenFound;
+export declare function unwrapFindSessionByTokenFound(value: FindSessionByTokenResult | TypedQueryResult<FindSessionByTokenResult>): FindSessionByTokenFound;
+export declare function redactFindSessionByTokenResult(value: FindSessionByTokenResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_SESSION_BY_TOKEN_SECRET_OUTPUTS;
+};
+export declare function findSessionByToken(parameters: FindSessionByTokenParams): NamedQueryRequest<FindSessionByTokenParams, FindSessionByTokenResult>;
+export declare const FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH: "7e23187b537599c4c2361d34ea866b5b719f63feda0135587b5ec6afd5ce62f6";
+export declare const FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS: 32;
+export declare const FIND_SESSIONS_BY_TOKEN_SET_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindSessionsByTokenSet";
+    readonly entity: "Session";
+    readonly field: "token";
+}];
+export interface FindSessionsByTokenSetParams {
+    readonly organization_id: string;
+    readonly tokens: ReadonlyArray<string>;
+}
+export interface FindSessionsByTokenSetFound {
+    readonly outcome: "Found";
+    readonly sessions: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly token: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly ip_address: string | null;
+        readonly user_agent: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindSessionsByTokenSetResult = FindSessionsByTokenSetFound;
+export declare function isFindSessionsByTokenSetFound(value: FindSessionsByTokenSetResult): value is FindSessionsByTokenSetFound;
+export declare function unwrapFindSessionsByTokenSetFound(value: FindSessionsByTokenSetResult | TypedQueryResult<FindSessionsByTokenSetResult>): FindSessionsByTokenSetFound;
+export declare function redactFindSessionsByTokenSetResult(value: FindSessionsByTokenSetResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_SESSIONS_BY_TOKEN_SET_SECRET_OUTPUTS;
+};
+export declare function findSessionsByTokenSet(parameters: FindSessionsByTokenSetParams): NamedQueryRequest<FindSessionsByTokenSetParams, FindSessionsByTokenSetResult>;
+export declare const FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: "a3277546d8b0c0059b850c368ae4925000c255e69b7ff005f4b3d2ef61b504af";
+export declare const FIND_SESSIONS_BY_USER_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindSessionsByUserId";
+    readonly entity: "Session";
+    readonly field: "token";
+}];
+export interface FindSessionsByUserIdParams {
+    readonly organization_id: string;
+    readonly user_id: string;
+    readonly after?: string | null;
+}
+export interface FindSessionsByUserIdFound {
+    readonly outcome: "Found";
+    readonly sessions: ReadonlyArray<{
+        readonly id: string;
+        readonly user_id: string;
+        readonly token: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly ip_address: string | null;
+        readonly user_agent: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindSessionsByUserIdResult = FindSessionsByUserIdFound;
+export declare function isFindSessionsByUserIdFound(value: FindSessionsByUserIdResult): value is FindSessionsByUserIdFound;
+export declare function unwrapFindSessionsByUserIdFound(value: FindSessionsByUserIdResult | TypedQueryResult<FindSessionsByUserIdResult>): FindSessionsByUserIdFound;
+export declare function redactFindSessionsByUserIdResult(value: FindSessionsByUserIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_SESSIONS_BY_USER_ID_SECRET_OUTPUTS;
+};
+export declare function findSessionsByUserId(parameters: FindSessionsByUserIdParams): NamedQueryRequest<FindSessionsByUserIdParams, FindSessionsByUserIdResult>;
+export declare const FIND_USER_BY_EMAIL_QUERY_PLAN_HASH: "b167b8cb2fb5ce19685491b47da4e816665b840e0f0e463666f6302134472b9a";
+export interface FindUserByEmailParams {
+    readonly organization_id: string;
+    readonly email: string;
+}
+export interface FindUserByEmailFound {
+    readonly outcome: "Found";
+    readonly users: ReadonlyArray<{
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindUserByEmailResult = FindUserByEmailFound;
+export declare function isFindUserByEmailFound(value: FindUserByEmailResult): value is FindUserByEmailFound;
+export declare function unwrapFindUserByEmailFound(value: FindUserByEmailResult | TypedQueryResult<FindUserByEmailResult>): FindUserByEmailFound;
+export declare function findUserByEmail(parameters: FindUserByEmailParams): NamedQueryRequest<FindUserByEmailParams, FindUserByEmailResult>;
+export declare const FIND_USER_BY_ID_QUERY_PLAN_HASH: "25d4a0a77d5df64ab6187528f9fac6b205a03c33e01c9ea6b573e8316b78b924";
+export interface FindUserByIdParams {
+    readonly organization_id: string;
+    readonly id: string;
+}
+export interface FindUserByIdFound {
+    readonly outcome: "Found";
+    readonly user: {
+        readonly user_id: string;
+        readonly name: string;
+        readonly email: string;
+        readonly email_verified: boolean;
+        readonly image: string | null;
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    };
+}
+export interface FindUserByIdMissing {
+    readonly outcome: "Missing";
+}
+export type FindUserByIdResult = FindUserByIdFound | FindUserByIdMissing;
+export declare function isFindUserByIdFound(value: FindUserByIdResult): value is FindUserByIdFound;
+export declare function isFindUserByIdMissing(value: FindUserByIdResult): value is FindUserByIdMissing;
+export declare function unwrapFindUserByIdFound(value: FindUserByIdResult | TypedQueryResult<FindUserByIdResult>): FindUserByIdFound;
+export declare function findUserById(parameters: FindUserByIdParams): NamedQueryRequest<FindUserByIdParams, FindUserByIdResult>;
+export declare const FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH: "54f07c7eba7d51857dd6473e39304dc798bf7084ca946dfa7f0203633a5133ac";
+export declare const FIND_VERIFICATION_BY_ID_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindVerificationById";
+    readonly entity: "Verification";
+    readonly field: "value";
+}];
+export interface FindVerificationByIdParams {
+    readonly organization_id: string;
+    readonly id: string;
+}
+export interface FindVerificationByIdFound {
+    readonly outcome: "Found";
+    readonly verification: {
+        readonly verification_id: string;
+        readonly identifier: string;
+        readonly value: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    };
+}
+export interface FindVerificationByIdMissing {
+    readonly outcome: "Missing";
+}
+export type FindVerificationByIdResult = FindVerificationByIdFound | FindVerificationByIdMissing;
+export declare function isFindVerificationByIdFound(value: FindVerificationByIdResult): value is FindVerificationByIdFound;
+export declare function isFindVerificationByIdMissing(value: FindVerificationByIdResult): value is FindVerificationByIdMissing;
+export declare function unwrapFindVerificationByIdFound(value: FindVerificationByIdResult | TypedQueryResult<FindVerificationByIdResult>): FindVerificationByIdFound;
+export declare function redactFindVerificationByIdResult(value: FindVerificationByIdResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_VERIFICATION_BY_ID_SECRET_OUTPUTS;
+};
+export declare function findVerificationById(parameters: FindVerificationByIdParams): NamedQueryRequest<FindVerificationByIdParams, FindVerificationByIdResult>;
+export declare const FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH: "4c768ae1d966454e9b791cd57a6311476947b5c457020943a50bc3cfee90765b";
+export declare const FIND_VERIFICATIONS_BY_IDENTIFIER_SECRET_OUTPUTS: readonly [{
+    readonly query: "FindVerificationsByIdentifier";
+    readonly entity: "Verification";
+    readonly field: "value";
+}];
+export interface FindVerificationsByIdentifierParams {
+    readonly organization_id: string;
+    readonly identifier: string;
+    readonly after?: string | null;
+}
+export interface FindVerificationsByIdentifierFound {
+    readonly outcome: "Found";
+    readonly verifications: ReadonlyArray<{
+        readonly verification_id: string;
+        readonly identifier: string;
+        readonly value: string;
+        readonly expires_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly created_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly revision: bigint;
+    }>;
+}
+export type FindVerificationsByIdentifierResult = FindVerificationsByIdentifierFound;
+export declare function isFindVerificationsByIdentifierFound(value: FindVerificationsByIdentifierResult): value is FindVerificationsByIdentifierFound;
+export declare function unwrapFindVerificationsByIdentifierFound(value: FindVerificationsByIdentifierResult | TypedQueryResult<FindVerificationsByIdentifierResult>): FindVerificationsByIdentifierFound;
+export declare function redactFindVerificationsByIdentifierResult(value: FindVerificationsByIdentifierResult): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof FIND_VERIFICATIONS_BY_IDENTIFIER_SECRET_OUTPUTS;
+};
+export declare function findVerificationsByIdentifier(parameters: FindVerificationsByIdentifierParams): NamedQueryRequest<FindVerificationsByIdentifierParams, FindVerificationsByIdentifierResult>;
+export interface ConsumeVerificationInput {
+    readonly request_id: string;
+    readonly organization_id: string;
+    readonly verification_id: string;
+}
+export declare const CONSUME_VERIFICATION_SECRET_OUTPUTS: readonly [{
+    readonly outcome: "VerificationConsumed";
+    readonly field: "value";
+    readonly entity: "Verification";
+    readonly sourceField: "value";
+}];
+export type ConsumeVerificationOutcome = {
+    readonly outcome: "VerificationConsumed";
+    readonly value: string;
+    readonly revision: bigint;
+    readonly created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly identifier: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly verification_id: string;
+} | {
+    readonly outcome: "VerificationConsumeMissing";
+};
+export declare function isConsumeVerificationVerificationConsumed(value: ConsumeVerificationOutcome): value is Extract<ConsumeVerificationOutcome, {
+    readonly outcome: "VerificationConsumed";
+}>;
+export declare function isConsumeVerificationVerificationConsumeMissing(value: ConsumeVerificationOutcome): value is Extract<ConsumeVerificationOutcome, {
+    readonly outcome: "VerificationConsumeMissing";
+}>;
+export declare function redactConsumeVerificationOutcome(value: ConsumeVerificationOutcome): {
+    readonly outcome: string;
+    readonly redactedSecretOutputs: typeof CONSUME_VERIFICATION_SECRET_OUTPUTS;
+};
+export declare const CONSUME_VERIFICATION_PLAN_HASH: "22a3f3b01aeb537ae2b8b3f758aa19d8f8a6a58a0e284b3b347d1079972adef2";
+export declare function consumeVerification(input: ConsumeVerificationInput): CommandRequest<ConsumeVerificationInput, ConsumeVerificationOutcome>;
+export interface ConsumeVerificationSetInput {
+    readonly request_id: string;
+    readonly organization_id: string;
+    readonly verification_ids: ReadonlyArray<string>;
+}
+export type ConsumeVerificationSetOutcome = {
+    readonly outcome: "VerificationSetConsumed";
+} | {
+    readonly outcome: "VerificationConsumeMissing";
+};
+export declare function isConsumeVerificationSetVerificationSetConsumed(value: ConsumeVerificationSetOutcome): value is Extract<ConsumeVerificationSetOutcome, {
+    readonly outcome: "VerificationSetConsumed";
+}>;
+export declare function isConsumeVerificationSetVerificationConsumeMissing(value: ConsumeVerificationSetOutcome): value is Extract<ConsumeVerificationSetOutcome, {
+    readonly outcome: "VerificationConsumeMissing";
+}>;
+export declare const CONSUME_VERIFICATION_SET_PLAN_HASH: "cc5e0d69851c61f11bbbca45ad00bec80b32687a94272379e133fbf854d59780";
+export declare function consumeVerificationSet(input: ConsumeVerificationSetInput): CommandRequest<ConsumeVerificationSetInput, ConsumeVerificationSetOutcome>;
+export interface ConsumeVerificationSnapshotInput {
+    readonly request_id: string;
+    readonly organization_id: string;
+    readonly verification_id: string;
+    readonly expected_revision: bigint;
+}
+export type ConsumeVerificationSnapshotOutcome = {
+    readonly outcome: "VerificationConsumed";
+} | {
+    readonly outcome: "VerificationConsumeStale";
+} | {
+    readonly outcome: "VerificationConsumeMissing";
+};
+export declare function isConsumeVerificationSnapshotVerificationConsumed(value: ConsumeVerificationSnapshotOutcome): value is Extract<ConsumeVerificationSnapshotOutcome, {
+    readonly outcome: "VerificationConsumed";
+}>;
+export declare function isConsumeVerificationSnapshotVerificationConsumeStale(value: ConsumeVerificationSnapshotOutcome): value is Extract<ConsumeVerificationSnapshotOutcome, {
+    readonly outcome: "VerificationConsumeStale";
+}>;
+export declare function isConsumeVerificationSnapshotVerificationConsumeMissing(value: ConsumeVerificationSnapshotOutcome): value is Extract<ConsumeVerificationSnapshotOutcome, {
+    readonly outcome: "VerificationConsumeMissing";
+}>;
+export declare const CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH: "1a80a36f34b4699c972fc1e6f48cad3f85da54e202831a6986aea084db09788b";
+export declare function consumeVerificationSnapshot(input: ConsumeVerificationSnapshotInput): CommandRequest<ConsumeVerificationSnapshotInput, ConsumeVerificationSnapshotOutcome>;
+export interface CreateAccountInput {
+    readonly id: string;
+    readonly scope: string | null;
+    readonly user_id: string;
+    readonly id_token: string | null;
+    readonly password: string | null;
+    readonly account_id: string;
+    readonly created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly provider_id: string;
+    readonly access_token: string | null;
+    readonly refresh_token: string | null;
+    readonly organization_id: string;
+    readonly access_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+    readonly refresh_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+}
+export type CreateAccountOutcome = {
+    readonly outcome: "AccountCreated";
+} | {
+    readonly outcome: "AccountUserMissing";
+} | {
+    readonly outcome: "AccountAlreadyExists";
+};
+export declare function isCreateAccountAccountCreated(value: CreateAccountOutcome): value is Extract<CreateAccountOutcome, {
+    readonly outcome: "AccountCreated";
+}>;
+export declare function isCreateAccountAccountUserMissing(value: CreateAccountOutcome): value is Extract<CreateAccountOutcome, {
+    readonly outcome: "AccountUserMissing";
+}>;
+export declare function isCreateAccountAccountAlreadyExists(value: CreateAccountOutcome): value is Extract<CreateAccountOutcome, {
+    readonly outcome: "AccountAlreadyExists";
+}>;
+export declare const CREATE_ACCOUNT_PLAN_HASH: "53f2e7b330780eb514a299ceb673da4f1eeaea81beb45253267a52e41a7fd0b2";
+export declare function createAccount(input: CreateAccountInput): CommandRequest<CreateAccountInput, CreateAccountOutcome>;
+export interface CreateOAuthUserGraphInput {
+    readonly scope: string | null;
+    readonly user_id: string;
+    readonly id_token: string | null;
+    readonly password: string | null;
+    readonly user_name: string;
+    readonly account_id: string;
+    readonly request_id: string;
+    readonly user_email: string;
+    readonly user_image: string | null;
+    readonly provider_id: string;
+    readonly access_token: string | null;
+    readonly refresh_token: string | null;
+    readonly organization_id: string;
+    readonly user_created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly user_updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly account_created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly account_updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly external_account_id: string;
+    readonly user_email_verified: boolean;
+    readonly access_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+    readonly refresh_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+}
+export type CreateOAuthUserGraphOutcome = {
+    readonly outcome: "OAuthUserExists";
+} | {
+    readonly outcome: "OAuthAccountExists";
+} | {
+    readonly outcome: "OAuthUserGraphCreated";
+};
+export declare function isCreateOAuthUserGraphOAuthUserExists(value: CreateOAuthUserGraphOutcome): value is Extract<CreateOAuthUserGraphOutcome, {
+    readonly outcome: "OAuthUserExists";
+}>;
+export declare function isCreateOAuthUserGraphOAuthAccountExists(value: CreateOAuthUserGraphOutcome): value is Extract<CreateOAuthUserGraphOutcome, {
+    readonly outcome: "OAuthAccountExists";
+}>;
+export declare function isCreateOAuthUserGraphOAuthUserGraphCreated(value: CreateOAuthUserGraphOutcome): value is Extract<CreateOAuthUserGraphOutcome, {
+    readonly outcome: "OAuthUserGraphCreated";
+}>;
+export declare const CREATE_O_AUTH_USER_GRAPH_PLAN_HASH: "a30c6faca9666ff17536e1f4ec35f0306e970430a064e0d72a66adccefad7407";
+export declare function createOAuthUserGraph(input: CreateOAuthUserGraphInput): CommandRequest<CreateOAuthUserGraphInput, CreateOAuthUserGraphOutcome>;
+export interface CreateSessionInput {
+    readonly id: string;
+    readonly token: string;
+    readonly user_id: string;
+    readonly created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly ip_address: string | null;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly user_agent: string | null;
+    readonly organization_id: string;
+}
+export type CreateSessionOutcome = {
+    readonly outcome: "SessionCreated";
+} | {
+    readonly outcome: "SessionUserMissing";
+} | {
+    readonly outcome: "SessionAlreadyExists";
+};
+export declare function isCreateSessionSessionCreated(value: CreateSessionOutcome): value is Extract<CreateSessionOutcome, {
+    readonly outcome: "SessionCreated";
+}>;
+export declare function isCreateSessionSessionUserMissing(value: CreateSessionOutcome): value is Extract<CreateSessionOutcome, {
+    readonly outcome: "SessionUserMissing";
+}>;
+export declare function isCreateSessionSessionAlreadyExists(value: CreateSessionOutcome): value is Extract<CreateSessionOutcome, {
+    readonly outcome: "SessionAlreadyExists";
+}>;
+export declare const CREATE_SESSION_PLAN_HASH: "c5e41496adb0a45f87503008fa43da87c6c729674bb1f521625ff16183059050";
+export declare function createSession(input: CreateSessionInput): CommandRequest<CreateSessionInput, CreateSessionOutcome>;
+export interface CreateSignupGraphInput {
+    readonly user_id: string;
+    readonly user_name: string;
+    readonly account_id: string;
+    readonly request_id: string;
+    readonly session_id: string;
+    readonly user_email: string;
+    readonly user_image: string | null;
+    readonly provider_id: string;
+    readonly session_token: string;
+    readonly organization_id: string;
+    readonly user_created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly user_updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly account_password: string | null;
+    readonly account_created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly account_updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly session_created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly session_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly session_ip_address: string | null;
+    readonly session_updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly session_user_agent: string | null;
+    readonly external_account_id: string;
+    readonly user_email_verified: boolean;
+}
+export type CreateSignupGraphOutcome = {
+    readonly outcome: "SignupUserExists";
+} | {
+    readonly outcome: "SignupGraphCreated";
+} | {
+    readonly outcome: "SignupAccountExists";
+} | {
+    readonly outcome: "SignupSessionExists";
+};
+export declare function isCreateSignupGraphSignupUserExists(value: CreateSignupGraphOutcome): value is Extract<CreateSignupGraphOutcome, {
+    readonly outcome: "SignupUserExists";
+}>;
+export declare function isCreateSignupGraphSignupGraphCreated(value: CreateSignupGraphOutcome): value is Extract<CreateSignupGraphOutcome, {
+    readonly outcome: "SignupGraphCreated";
+}>;
+export declare function isCreateSignupGraphSignupAccountExists(value: CreateSignupGraphOutcome): value is Extract<CreateSignupGraphOutcome, {
+    readonly outcome: "SignupAccountExists";
+}>;
+export declare function isCreateSignupGraphSignupSessionExists(value: CreateSignupGraphOutcome): value is Extract<CreateSignupGraphOutcome, {
+    readonly outcome: "SignupSessionExists";
+}>;
+export declare const CREATE_SIGNUP_GRAPH_PLAN_HASH: "01e4e118b1cc5c3a16c19259284cd0845e8a2e405fc02f81ab9b1fcafc79d0b8";
+export declare function createSignupGraph(input: CreateSignupGraphInput): CommandRequest<CreateSignupGraphInput, CreateSignupGraphOutcome>;
+export interface CreateUserInput {
+    readonly id: string;
+    readonly name: string;
+    readonly email: string;
+    readonly image: string | null;
+    readonly created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly email_verified: boolean;
+    readonly organization_id: string;
+}
+export type CreateUserOutcome = {
+    readonly outcome: "UserCreated";
+} | {
+    readonly outcome: "UserAlreadyExists";
+};
+export declare function isCreateUserUserCreated(value: CreateUserOutcome): value is Extract<CreateUserOutcome, {
+    readonly outcome: "UserCreated";
+}>;
+export declare function isCreateUserUserAlreadyExists(value: CreateUserOutcome): value is Extract<CreateUserOutcome, {
+    readonly outcome: "UserAlreadyExists";
+}>;
+export declare const CREATE_USER_PLAN_HASH: "752d7d404aa418b5c1a08065ce9a8efbb28ab2b62f18969c98a13a06092fd8b3";
+export declare function createUser(input: CreateUserInput): CommandRequest<CreateUserInput, CreateUserOutcome>;
+export interface CreateVerificationInput {
+    readonly id: string;
+    readonly value: string;
+    readonly created_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly identifier: string;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly organization_id: string;
+}
+export type CreateVerificationOutcome = {
+    readonly outcome: "VerificationCreated";
+} | {
+    readonly outcome: "VerificationAlreadyExists";
+};
+export declare function isCreateVerificationVerificationCreated(value: CreateVerificationOutcome): value is Extract<CreateVerificationOutcome, {
+    readonly outcome: "VerificationCreated";
+}>;
+export declare function isCreateVerificationVerificationAlreadyExists(value: CreateVerificationOutcome): value is Extract<CreateVerificationOutcome, {
+    readonly outcome: "VerificationAlreadyExists";
+}>;
+export declare const CREATE_VERIFICATION_PLAN_HASH: "82bce005457b1fcf1d069a69304f7bf4e2eeb7d2718d5289dc9d25e197309e35";
+export declare function createVerification(input: CreateVerificationInput): CommandRequest<CreateVerificationInput, CreateVerificationOutcome>;
+export interface DeleteAccountInput {
+    readonly user_id: string;
+    readonly request_id: string;
+    readonly account_ids: ReadonlyArray<string>;
+    readonly organization_id: string;
+}
+export type DeleteAccountOutcome = {
+    readonly outcome: "AccountDeleted";
+} | {
+    readonly outcome: "AccountMissing";
+};
+export declare function isDeleteAccountAccountDeleted(value: DeleteAccountOutcome): value is Extract<DeleteAccountOutcome, {
+    readonly outcome: "AccountDeleted";
+}>;
+export declare function isDeleteAccountAccountMissing(value: DeleteAccountOutcome): value is Extract<DeleteAccountOutcome, {
+    readonly outcome: "AccountMissing";
+}>;
+export declare const DELETE_ACCOUNT_PLAN_HASH: "6429ebe6e70797c57c44a4738c8a511bbe5304e5bf58148dfc0c2721ffaff382";
+export declare function deleteAccount(input: DeleteAccountInput): CommandRequest<DeleteAccountInput, DeleteAccountOutcome>;
+export interface DeleteSessionInput {
+    readonly user_id: string;
+    readonly request_id: string;
+    readonly session_ids: ReadonlyArray<string>;
+    readonly organization_id: string;
+}
+export type DeleteSessionOutcome = {
+    readonly outcome: "SessionDeleted";
+} | {
+    readonly outcome: "SessionMissing";
+};
+export declare function isDeleteSessionSessionDeleted(value: DeleteSessionOutcome): value is Extract<DeleteSessionOutcome, {
+    readonly outcome: "SessionDeleted";
+}>;
+export declare function isDeleteSessionSessionMissing(value: DeleteSessionOutcome): value is Extract<DeleteSessionOutcome, {
+    readonly outcome: "SessionMissing";
+}>;
+export declare const DELETE_SESSION_PLAN_HASH: "a3901beb6c2d2754fd3d2c64252b6f5059cd1792c0a0560741c94da4668a0524";
+export declare function deleteSession(input: DeleteSessionInput): CommandRequest<DeleteSessionInput, DeleteSessionOutcome>;
+export interface DeleteUserInput {
+    readonly user_ids: ReadonlyArray<string>;
+    readonly request_id: string;
+    readonly organization_id: string;
+}
+export type DeleteUserOutcome = {
+    readonly outcome: "UserDeleted";
+} | {
+    readonly outcome: "DeleteUserMissing";
+} | {
+    readonly outcome: "DeleteUserCascadeLimitExceeded";
+};
+export declare function isDeleteUserUserDeleted(value: DeleteUserOutcome): value is Extract<DeleteUserOutcome, {
+    readonly outcome: "UserDeleted";
+}>;
+export declare function isDeleteUserDeleteUserMissing(value: DeleteUserOutcome): value is Extract<DeleteUserOutcome, {
+    readonly outcome: "DeleteUserMissing";
+}>;
+export declare function isDeleteUserDeleteUserCascadeLimitExceeded(value: DeleteUserOutcome): value is Extract<DeleteUserOutcome, {
+    readonly outcome: "DeleteUserCascadeLimitExceeded";
+}>;
+export declare const DELETE_USER_PLAN_HASH: "f7195857c4f50a68b37ee0f8516c27dd03b08d5cd5ba45f53d9f9345d2f90985";
+export declare function deleteUser(input: DeleteUserInput): CommandRequest<DeleteUserInput, DeleteUserOutcome>;
+export interface DeleteVerificationInput {
+    readonly request_id: string;
+    readonly organization_id: string;
+    readonly verification_ids: ReadonlyArray<string>;
+}
+export type DeleteVerificationOutcome = {
+    readonly outcome: "VerificationDeleted";
+} | {
+    readonly outcome: "VerificationMissing";
+};
+export declare function isDeleteVerificationVerificationDeleted(value: DeleteVerificationOutcome): value is Extract<DeleteVerificationOutcome, {
+    readonly outcome: "VerificationDeleted";
+}>;
+export declare function isDeleteVerificationVerificationMissing(value: DeleteVerificationOutcome): value is Extract<DeleteVerificationOutcome, {
+    readonly outcome: "VerificationMissing";
+}>;
+export declare const DELETE_VERIFICATION_PLAN_HASH: "bffc0c5ef5ad2b602954492d043e833785ec3f9d6f0520fbc0f933422544ae6a";
+export declare function deleteVerification(input: DeleteVerificationInput): CommandRequest<DeleteVerificationInput, DeleteVerificationOutcome>;
+export interface ResetCredentialPasswordInput {
+    readonly user_id: string;
+    readonly password: string;
+    readonly account_id: string;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly organization_id: string;
+    readonly account_revision: bigint;
+    readonly verification_ids: ReadonlyArray<string>;
+    readonly external_account_id: string;
+    readonly verification_revision: bigint;
+}
+export type ResetCredentialPasswordOutcome = {
+    readonly outcome: "PasswordAccountStale";
+} | {
+    readonly outcome: "PasswordAccountMissing";
+} | {
+    readonly outcome: "CredentialPasswordReset";
+} | {
+    readonly outcome: "PasswordProviderMismatch";
+} | {
+    readonly outcome: "VerificationConsumeStale";
+} | {
+    readonly outcome: "VerificationConsumeMissing";
+};
+export declare function isResetCredentialPasswordPasswordAccountStale(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "PasswordAccountStale";
+}>;
+export declare function isResetCredentialPasswordPasswordAccountMissing(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "PasswordAccountMissing";
+}>;
+export declare function isResetCredentialPasswordCredentialPasswordReset(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "CredentialPasswordReset";
+}>;
+export declare function isResetCredentialPasswordPasswordProviderMismatch(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "PasswordProviderMismatch";
+}>;
+export declare function isResetCredentialPasswordVerificationConsumeStale(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "VerificationConsumeStale";
+}>;
+export declare function isResetCredentialPasswordVerificationConsumeMissing(value: ResetCredentialPasswordOutcome): value is Extract<ResetCredentialPasswordOutcome, {
+    readonly outcome: "VerificationConsumeMissing";
+}>;
+export declare const RESET_CREDENTIAL_PASSWORD_PLAN_HASH: "ed87f267831fb0823b0e9bbf51d7b302a715a95c0cea69faf7922c0e4e7f375e";
+export declare function resetCredentialPassword(input: ResetCredentialPasswordInput): CommandRequest<ResetCredentialPasswordInput, ResetCredentialPasswordOutcome>;
+export interface UpdateAccountInput {
+    readonly scope: string | null;
+    readonly user_id: string;
+    readonly id_token: string | null;
+    readonly password: string | null;
+    readonly account_id: string;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly provider_id: string;
+    readonly access_token: string | null;
+    readonly refresh_token: string | null;
+    readonly organization_id: string;
+    readonly expected_revision: bigint;
+    readonly external_account_id: string;
+    readonly access_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+    readonly refresh_token_expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    } | null;
+}
+export type UpdateAccountOutcome = {
+    readonly outcome: "AccountUpdated";
+} | {
+    readonly outcome: "AccountUpdateStale";
+} | {
+    readonly outcome: "AccountUpdateMissing";
+};
+export declare function isUpdateAccountAccountUpdated(value: UpdateAccountOutcome): value is Extract<UpdateAccountOutcome, {
+    readonly outcome: "AccountUpdated";
+}>;
+export declare function isUpdateAccountAccountUpdateStale(value: UpdateAccountOutcome): value is Extract<UpdateAccountOutcome, {
+    readonly outcome: "AccountUpdateStale";
+}>;
+export declare function isUpdateAccountAccountUpdateMissing(value: UpdateAccountOutcome): value is Extract<UpdateAccountOutcome, {
+    readonly outcome: "AccountUpdateMissing";
+}>;
+export declare const UPDATE_ACCOUNT_PLAN_HASH: "1556cd92effd135225904f0313f1cdf146ebe82f72621ebeccb2686c5442b849";
+export declare function updateAccount(input: UpdateAccountInput): CommandRequest<UpdateAccountInput, UpdateAccountOutcome>;
+export interface UpdateAccountPasswordsInput {
+    readonly updates: ReadonlyArray<{
+        readonly user_id: string;
+        readonly password: string | null;
+        readonly account_id: string;
+        readonly updated_at: {
+            readonly seconds: bigint;
+            readonly nanos: number;
+        };
+        readonly provider_id: string;
+        readonly organization_id: string;
+        readonly expected_revision: bigint;
+    }>;
+    readonly user_id: string;
+    readonly request_id: string;
+    readonly organization_id: string;
+}
+export type UpdateAccountPasswordsOutcome = {
+    readonly outcome: "PasswordAccountStale";
+} | {
+    readonly outcome: "PasswordAccountMissing";
+} | {
+    readonly outcome: "AccountPasswordsUpdated";
+} | {
+    readonly outcome: "PasswordProviderMismatch";
+};
+export declare function isUpdateAccountPasswordsPasswordAccountStale(value: UpdateAccountPasswordsOutcome): value is Extract<UpdateAccountPasswordsOutcome, {
+    readonly outcome: "PasswordAccountStale";
+}>;
+export declare function isUpdateAccountPasswordsPasswordAccountMissing(value: UpdateAccountPasswordsOutcome): value is Extract<UpdateAccountPasswordsOutcome, {
+    readonly outcome: "PasswordAccountMissing";
+}>;
+export declare function isUpdateAccountPasswordsAccountPasswordsUpdated(value: UpdateAccountPasswordsOutcome): value is Extract<UpdateAccountPasswordsOutcome, {
+    readonly outcome: "AccountPasswordsUpdated";
+}>;
+export declare function isUpdateAccountPasswordsPasswordProviderMismatch(value: UpdateAccountPasswordsOutcome): value is Extract<UpdateAccountPasswordsOutcome, {
+    readonly outcome: "PasswordProviderMismatch";
+}>;
+export declare const UPDATE_ACCOUNT_PASSWORDS_PLAN_HASH: "5f18c741b5e9c09203c67b5985af9d034fad670462ecdda32a0a1f031ef288f6";
+export declare function updateAccountPasswords(input: UpdateAccountPasswordsInput): CommandRequest<UpdateAccountPasswordsInput, UpdateAccountPasswordsOutcome>;
+export interface UpdateCredentialPasswordInput {
+    readonly user_id: string;
+    readonly password: string;
+    readonly account_id: string;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly organization_id: string;
+    readonly expected_revision: bigint;
+    readonly external_account_id: string;
+}
+export type UpdateCredentialPasswordOutcome = {
+    readonly outcome: "PasswordAccountStale";
+} | {
+    readonly outcome: "PasswordAccountMissing";
+} | {
+    readonly outcome: "PasswordProviderMismatch";
+} | {
+    readonly outcome: "CredentialPasswordUpdated";
+};
+export declare function isUpdateCredentialPasswordPasswordAccountStale(value: UpdateCredentialPasswordOutcome): value is Extract<UpdateCredentialPasswordOutcome, {
+    readonly outcome: "PasswordAccountStale";
+}>;
+export declare function isUpdateCredentialPasswordPasswordAccountMissing(value: UpdateCredentialPasswordOutcome): value is Extract<UpdateCredentialPasswordOutcome, {
+    readonly outcome: "PasswordAccountMissing";
+}>;
+export declare function isUpdateCredentialPasswordPasswordProviderMismatch(value: UpdateCredentialPasswordOutcome): value is Extract<UpdateCredentialPasswordOutcome, {
+    readonly outcome: "PasswordProviderMismatch";
+}>;
+export declare function isUpdateCredentialPasswordCredentialPasswordUpdated(value: UpdateCredentialPasswordOutcome): value is Extract<UpdateCredentialPasswordOutcome, {
+    readonly outcome: "CredentialPasswordUpdated";
+}>;
+export declare const UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH: "08781a68739c705ab6ffe51a0de547605e1a7dd2fd2b8075445d40db923d1f15";
+export declare function updateCredentialPassword(input: UpdateCredentialPasswordInput): CommandRequest<UpdateCredentialPasswordInput, UpdateCredentialPasswordOutcome>;
+export interface UpdateSessionInput {
+    readonly user_id: string;
+    readonly expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly ip_address: string | null;
+    readonly request_id: string;
+    readonly session_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly user_agent: string | null;
+    readonly organization_id: string;
+    readonly expected_revision: bigint;
+}
+export type UpdateSessionOutcome = {
+    readonly outcome: "SessionUpdated";
+} | {
+    readonly outcome: "SessionUpdateStale";
+} | {
+    readonly outcome: "SessionUpdateMissing";
+};
+export declare function isUpdateSessionSessionUpdated(value: UpdateSessionOutcome): value is Extract<UpdateSessionOutcome, {
+    readonly outcome: "SessionUpdated";
+}>;
+export declare function isUpdateSessionSessionUpdateStale(value: UpdateSessionOutcome): value is Extract<UpdateSessionOutcome, {
+    readonly outcome: "SessionUpdateStale";
+}>;
+export declare function isUpdateSessionSessionUpdateMissing(value: UpdateSessionOutcome): value is Extract<UpdateSessionOutcome, {
+    readonly outcome: "SessionUpdateMissing";
+}>;
+export declare const UPDATE_SESSION_PLAN_HASH: "4c1184c5c0a1f8b8935a8b96204ad839afe84e1752f2ba24cdf63feef4f7ce3a";
+export declare function updateSession(input: UpdateSessionInput): CommandRequest<UpdateSessionInput, UpdateSessionOutcome>;
+export interface UpdateUserInput {
+    readonly name: string;
+    readonly email: string;
+    readonly image: string | null;
+    readonly user_id: string;
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly email_verified: boolean;
+    readonly organization_id: string;
+    readonly expected_revision: bigint;
+}
+export type UpdateUserOutcome = {
+    readonly outcome: "UserUpdated";
+} | {
+    readonly outcome: "UserUpdateStale";
+} | {
+    readonly outcome: "UserUpdateMissing";
+};
+export declare function isUpdateUserUserUpdated(value: UpdateUserOutcome): value is Extract<UpdateUserOutcome, {
+    readonly outcome: "UserUpdated";
+}>;
+export declare function isUpdateUserUserUpdateStale(value: UpdateUserOutcome): value is Extract<UpdateUserOutcome, {
+    readonly outcome: "UserUpdateStale";
+}>;
+export declare function isUpdateUserUserUpdateMissing(value: UpdateUserOutcome): value is Extract<UpdateUserOutcome, {
+    readonly outcome: "UserUpdateMissing";
+}>;
+export declare const UPDATE_USER_PLAN_HASH: "cd0d3c8108976d4b2413f41fd68791b3e9276a763787f40b82bef17219091194";
+export declare function updateUser(input: UpdateUserInput): CommandRequest<UpdateUserInput, UpdateUserOutcome>;
+export interface UpdateVerificationInput {
+    readonly value: string;
+    readonly expires_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly request_id: string;
+    readonly updated_at: {
+        readonly seconds: bigint;
+        readonly nanos: number;
+    };
+    readonly organization_id: string;
+    readonly verification_id: string;
+    readonly expected_revision: bigint;
+}
+export type UpdateVerificationOutcome = {
+    readonly outcome: "VerificationUpdated";
+} | {
+    readonly outcome: "VerificationUpdateStale";
+} | {
+    readonly outcome: "VerificationUpdateMissing";
+};
+export declare function isUpdateVerificationVerificationUpdated(value: UpdateVerificationOutcome): value is Extract<UpdateVerificationOutcome, {
+    readonly outcome: "VerificationUpdated";
+}>;
+export declare function isUpdateVerificationVerificationUpdateStale(value: UpdateVerificationOutcome): value is Extract<UpdateVerificationOutcome, {
+    readonly outcome: "VerificationUpdateStale";
+}>;
+export declare function isUpdateVerificationVerificationUpdateMissing(value: UpdateVerificationOutcome): value is Extract<UpdateVerificationOutcome, {
+    readonly outcome: "VerificationUpdateMissing";
+}>;
+export declare const UPDATE_VERIFICATION_PLAN_HASH: "b9ea963db584e7fd9dbce1069d982dc0f53ebb06b72b41b060578b284596018f";
+export declare function updateVerification(input: UpdateVerificationInput): CommandRequest<UpdateVerificationInput, UpdateVerificationOutcome>;
+export declare class RiffDBBetterAuthCoreClient {
+    private readonly transport;
+    private readonly commandAttemptBudget;
+    private readonly trackCausalWrites;
+    private lastCommitSeq;
+    constructor(transport: ApplicationTransport, commandAttemptBudget?: number, defaultReadAfterCommit?: bigint, trackCausalWrites?: boolean);
+    static fromTransport(transport: ApplicationTransport, commandAttemptBudget?: number): RiffDBBetterAuthCoreClient;
+    static driverIdentity(role: string, database?: string): ContractDriverIdentity;
+    static connect(driver: {
+        connect(config: {
+            readonly socketPath: string;
+            readonly identity: ContractDriverIdentity;
+        }): Promise<ApplicationTransport>;
+    } | ((config: {
+        readonly socketPath: string;
+        readonly identity: ContractDriverIdentity;
+    }) => Promise<ApplicationTransport>), options: {
+        readonly socketPath: string;
+        readonly role: string;
+        readonly database?: string;
+        readonly commandAttemptBudget?: number;
+    }): Promise<RiffDBBetterAuthCoreClient>;
+    static connectFromEnv(driver: {
+        connectFromEnv(options: {
+            readonly socketPath?: string;
+            readonly role?: string;
+            readonly database?: string;
+            readonly tenant?: string;
+            readonly prefix?: string;
+            readonly envPrefix?: string;
+            readonly identity: typeof CONTRACT_DRIVER_IDENTITY;
+        }): Promise<ApplicationTransport>;
+    } | ((options: {
+        readonly socketPath?: string;
+        readonly role?: string;
+        readonly database?: string;
+        readonly tenant?: string;
+        readonly prefix?: string;
+        readonly envPrefix?: string;
+        readonly identity: typeof CONTRACT_DRIVER_IDENTITY;
+    }) => Promise<ApplicationTransport>), options?: {
+        readonly socketPath?: string;
+        readonly role?: string;
+        readonly database?: string;
+        readonly tenant?: string;
+        readonly prefix?: string;
+        readonly envPrefix?: string;
+        readonly commandAttemptBudget?: number;
+    }): Promise<RiffDBBetterAuthCoreClient>;
+    withReadAfterCommit(commitSequence: bigint | undefined): RiffDBBetterAuthCoreClient;
+    causalSession(initialCommitSequence?: bigint): RiffDBBetterAuthCoreClient;
+    get lastCommitSequence(): bigint | undefined;
+    adminUsersAllEmailAsc(parameters: AdminUsersAllEmailAscParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersAllEmailAscResult>>;
+    adminUsersAllEmailAscAfterCommit(parameters: AdminUsersAllEmailAscParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersAllEmailAscResult>>;
+    adminUsersContainsAsc(parameters: AdminUsersContainsAscParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersContainsAscResult>>;
+    adminUsersContainsAscAfterCommit(parameters: AdminUsersContainsAscParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersContainsAscResult>>;
+    adminUsersContainsDesc(parameters: AdminUsersContainsDescParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersContainsDescResult>>;
+    adminUsersContainsDescAfterCommit(parameters: AdminUsersContainsDescParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersContainsDescResult>>;
+    adminUsersEmailContainsCreatedDesc(parameters: AdminUsersEmailContainsCreatedDescParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEmailContainsCreatedDescResult>>;
+    adminUsersEmailContainsCreatedDescAfterCommit(parameters: AdminUsersEmailContainsCreatedDescParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEmailContainsCreatedDescResult>>;
+    adminUsersEmailContainsImageAsc(parameters: AdminUsersEmailContainsImageAscParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEmailContainsImageAscResult>>;
+    adminUsersEmailContainsImageAscAfterCommit(parameters: AdminUsersEmailContainsImageAscParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEmailContainsImageAscResult>>;
+    adminUsersEndsWithAsc(parameters: AdminUsersEndsWithAscParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEndsWithAscResult>>;
+    adminUsersEndsWithAscAfterCommit(parameters: AdminUsersEndsWithAscParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEndsWithAscResult>>;
+    adminUsersEndsWithDesc(parameters: AdminUsersEndsWithDescParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEndsWithDescResult>>;
+    adminUsersEndsWithDescAfterCommit(parameters: AdminUsersEndsWithDescParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersEndsWithDescResult>>;
+    adminUsersStartsWithAsc(parameters: AdminUsersStartsWithAscParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersStartsWithAscResult>>;
+    adminUsersStartsWithAscAfterCommit(parameters: AdminUsersStartsWithAscParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersStartsWithAscResult>>;
+    adminUsersStartsWithDesc(parameters: AdminUsersStartsWithDescParams, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersStartsWithDescResult>>;
+    adminUsersStartsWithDescAfterCommit(parameters: AdminUsersStartsWithDescParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<AdminUsersStartsWithDescResult>>;
+    findAccountById(parameters: FindAccountByIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindAccountByIdResult>>;
+    findAccountByIdAfterCommit(parameters: FindAccountByIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindAccountByIdResult>>;
+    findAccountByProvider(parameters: FindAccountByProviderParams, options?: QueryOptions): Promise<TypedQueryResult<FindAccountByProviderResult>>;
+    findAccountByProviderAfterCommit(parameters: FindAccountByProviderParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindAccountByProviderResult>>;
+    findAccountsByUserId(parameters: FindAccountsByUserIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindAccountsByUserIdResult>>;
+    findAccountsByUserIdAfterCommit(parameters: FindAccountsByUserIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindAccountsByUserIdResult>>;
+    findAccountsByUserIdPages(parameters: FindAccountsByUserIdParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindAccountsByUserIdResult>, void, undefined>;
+    findAccountsByUserProvider(parameters: FindAccountsByUserProviderParams, options?: QueryOptions): Promise<TypedQueryResult<FindAccountsByUserProviderResult>>;
+    findAccountsByUserProviderAfterCommit(parameters: FindAccountsByUserProviderParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindAccountsByUserProviderResult>>;
+    findAccountsByUserProviderPages(parameters: FindAccountsByUserProviderParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindAccountsByUserProviderResult>, void, undefined>;
+    findActiveSessionsByUserId(parameters: FindActiveSessionsByUserIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindActiveSessionsByUserIdResult>>;
+    findActiveSessionsByUserIdAfterCommit(parameters: FindActiveSessionsByUserIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindActiveSessionsByUserIdResult>>;
+    findActiveSessionsByUserIdPages(parameters: FindActiveSessionsByUserIdParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindActiveSessionsByUserIdResult>, void, undefined>;
+    findCredentialAccount(parameters: FindCredentialAccountParams, options?: QueryOptions): Promise<TypedQueryResult<FindCredentialAccountResult>>;
+    findCredentialAccountAfterCommit(parameters: FindCredentialAccountParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindCredentialAccountResult>>;
+    findExpiredVerificationIds(parameters: FindExpiredVerificationIdsParams, options?: QueryOptions): Promise<TypedQueryResult<FindExpiredVerificationIdsResult>>;
+    findExpiredVerificationIdsAfterCommit(parameters: FindExpiredVerificationIdsParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindExpiredVerificationIdsResult>>;
+    findExpiredVerificationIdsPages(parameters: FindExpiredVerificationIdsParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindExpiredVerificationIdsResult>, void, undefined>;
+    findLatestVerification(parameters: FindLatestVerificationParams, options?: QueryOptions): Promise<TypedQueryResult<FindLatestVerificationResult>>;
+    findLatestVerificationAfterCommit(parameters: FindLatestVerificationParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindLatestVerificationResult>>;
+    findSessionById(parameters: FindSessionByIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindSessionByIdResult>>;
+    findSessionByIdAfterCommit(parameters: FindSessionByIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindSessionByIdResult>>;
+    findSessionByToken(parameters: FindSessionByTokenParams, options?: QueryOptions): Promise<TypedQueryResult<FindSessionByTokenResult>>;
+    findSessionByTokenAfterCommit(parameters: FindSessionByTokenParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindSessionByTokenResult>>;
+    findSessionsByTokenSet(parameters: FindSessionsByTokenSetParams, options?: QueryOptions): Promise<TypedQueryResult<FindSessionsByTokenSetResult>>;
+    findSessionsByTokenSetAfterCommit(parameters: FindSessionsByTokenSetParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindSessionsByTokenSetResult>>;
+    findSessionsByTokenSetAll(parameters: FindSessionsByTokenSetParams, maxPages?: number, options?: QueryOptions): Promise<TypedQueryResult<FindSessionsByTokenSetFound>>;
+    findSessionsByUserId(parameters: FindSessionsByUserIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindSessionsByUserIdResult>>;
+    findSessionsByUserIdAfterCommit(parameters: FindSessionsByUserIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindSessionsByUserIdResult>>;
+    findSessionsByUserIdPages(parameters: FindSessionsByUserIdParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindSessionsByUserIdResult>, void, undefined>;
+    findUserByEmail(parameters: FindUserByEmailParams, options?: QueryOptions): Promise<TypedQueryResult<FindUserByEmailResult>>;
+    findUserByEmailAfterCommit(parameters: FindUserByEmailParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindUserByEmailResult>>;
+    findUserById(parameters: FindUserByIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindUserByIdResult>>;
+    findUserByIdAfterCommit(parameters: FindUserByIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindUserByIdResult>>;
+    findVerificationById(parameters: FindVerificationByIdParams, options?: QueryOptions): Promise<TypedQueryResult<FindVerificationByIdResult>>;
+    findVerificationByIdAfterCommit(parameters: FindVerificationByIdParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindVerificationByIdResult>>;
+    findVerificationsByIdentifier(parameters: FindVerificationsByIdentifierParams, options?: QueryOptions): Promise<TypedQueryResult<FindVerificationsByIdentifierResult>>;
+    findVerificationsByIdentifierAfterCommit(parameters: FindVerificationsByIdentifierParams, commitSequence: bigint, options?: QueryOptions): Promise<TypedQueryResult<FindVerificationsByIdentifierResult>>;
+    findVerificationsByIdentifierPages(parameters: FindVerificationsByIdentifierParams, maxPages?: number, options?: QueryOptions): AsyncGenerator<TypedQueryResult<FindVerificationsByIdentifierResult>, void, undefined>;
+    consumeVerification(input: ConsumeVerificationInput): Promise<TypedCommandResult<ConsumeVerificationOutcome>>;
+    consumeVerificationBatch(inputs: ReadonlyArray<ConsumeVerificationInput>, options: CommandBatchOptions): Promise<CommandBatchResult<ConsumeVerificationOutcome>>;
+    consumeVerificationSet(input: ConsumeVerificationSetInput): Promise<TypedCommandResult<ConsumeVerificationSetOutcome>>;
+    consumeVerificationSetBatch(inputs: ReadonlyArray<ConsumeVerificationSetInput>, options: CommandBatchOptions): Promise<CommandBatchResult<ConsumeVerificationSetOutcome>>;
+    consumeVerificationSnapshot(input: ConsumeVerificationSnapshotInput): Promise<TypedCommandResult<ConsumeVerificationSnapshotOutcome>>;
+    consumeVerificationSnapshotBatch(inputs: ReadonlyArray<ConsumeVerificationSnapshotInput>, options: CommandBatchOptions): Promise<CommandBatchResult<ConsumeVerificationSnapshotOutcome>>;
+    createAccount(input: CreateAccountInput): Promise<TypedCommandResult<CreateAccountOutcome>>;
+    createAccountBatch(inputs: ReadonlyArray<CreateAccountInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateAccountOutcome>>;
+    createOAuthUserGraph(input: CreateOAuthUserGraphInput): Promise<TypedCommandResult<CreateOAuthUserGraphOutcome>>;
+    createOAuthUserGraphBatch(inputs: ReadonlyArray<CreateOAuthUserGraphInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateOAuthUserGraphOutcome>>;
+    createSession(input: CreateSessionInput): Promise<TypedCommandResult<CreateSessionOutcome>>;
+    createSessionBatch(inputs: ReadonlyArray<CreateSessionInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateSessionOutcome>>;
+    createSignupGraph(input: CreateSignupGraphInput): Promise<TypedCommandResult<CreateSignupGraphOutcome>>;
+    createSignupGraphBatch(inputs: ReadonlyArray<CreateSignupGraphInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateSignupGraphOutcome>>;
+    createUser(input: CreateUserInput): Promise<TypedCommandResult<CreateUserOutcome>>;
+    createUserBatch(inputs: ReadonlyArray<CreateUserInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateUserOutcome>>;
+    createVerification(input: CreateVerificationInput): Promise<TypedCommandResult<CreateVerificationOutcome>>;
+    createVerificationBatch(inputs: ReadonlyArray<CreateVerificationInput>, options: CommandBatchOptions): Promise<CommandBatchResult<CreateVerificationOutcome>>;
+    deleteAccount(input: DeleteAccountInput): Promise<TypedCommandResult<DeleteAccountOutcome>>;
+    deleteAccountBatch(inputs: ReadonlyArray<DeleteAccountInput>, options: CommandBatchOptions): Promise<CommandBatchResult<DeleteAccountOutcome>>;
+    deleteSession(input: DeleteSessionInput): Promise<TypedCommandResult<DeleteSessionOutcome>>;
+    deleteSessionBatch(inputs: ReadonlyArray<DeleteSessionInput>, options: CommandBatchOptions): Promise<CommandBatchResult<DeleteSessionOutcome>>;
+    deleteUser(input: DeleteUserInput): Promise<TypedCommandResult<DeleteUserOutcome>>;
+    deleteUserBatch(inputs: ReadonlyArray<DeleteUserInput>, options: CommandBatchOptions): Promise<CommandBatchResult<DeleteUserOutcome>>;
+    deleteVerification(input: DeleteVerificationInput): Promise<TypedCommandResult<DeleteVerificationOutcome>>;
+    deleteVerificationBatch(inputs: ReadonlyArray<DeleteVerificationInput>, options: CommandBatchOptions): Promise<CommandBatchResult<DeleteVerificationOutcome>>;
+    resetCredentialPassword(input: ResetCredentialPasswordInput): Promise<TypedCommandResult<ResetCredentialPasswordOutcome>>;
+    resetCredentialPasswordBatch(inputs: ReadonlyArray<ResetCredentialPasswordInput>, options: CommandBatchOptions): Promise<CommandBatchResult<ResetCredentialPasswordOutcome>>;
+    updateAccount(input: UpdateAccountInput): Promise<TypedCommandResult<UpdateAccountOutcome>>;
+    updateAccountBatch(inputs: ReadonlyArray<UpdateAccountInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateAccountOutcome>>;
+    updateAccountPasswords(input: UpdateAccountPasswordsInput): Promise<TypedCommandResult<UpdateAccountPasswordsOutcome>>;
+    updateAccountPasswordsBatch(inputs: ReadonlyArray<UpdateAccountPasswordsInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateAccountPasswordsOutcome>>;
+    updateCredentialPassword(input: UpdateCredentialPasswordInput): Promise<TypedCommandResult<UpdateCredentialPasswordOutcome>>;
+    updateCredentialPasswordBatch(inputs: ReadonlyArray<UpdateCredentialPasswordInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateCredentialPasswordOutcome>>;
+    updateSession(input: UpdateSessionInput): Promise<TypedCommandResult<UpdateSessionOutcome>>;
+    updateSessionBatch(inputs: ReadonlyArray<UpdateSessionInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateSessionOutcome>>;
+    updateUser(input: UpdateUserInput): Promise<TypedCommandResult<UpdateUserOutcome>>;
+    updateUserBatch(inputs: ReadonlyArray<UpdateUserInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateUserOutcome>>;
+    updateVerification(input: UpdateVerificationInput): Promise<TypedCommandResult<UpdateVerificationOutcome>>;
+    updateVerificationBatch(inputs: ReadonlyArray<UpdateVerificationInput>, options: CommandBatchOptions): Promise<CommandBatchResult<UpdateVerificationOutcome>>;
+}
+//# sourceMappingURL=client.d.ts.map