@riffdb/better-auth 0.0.0-stage → 0.2.0

package/generated/python/client.py

@@ -0,0 +1,3877 @@
+# @generated by riffdb-query-module; do not edit.
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from decimal import Decimal
+from enum import StrEnum
+from typing import Annotated, Final, Literal, TypeAlias
+from uuid import UUID
+
+from riffdb_application import (
+AsyncApplicationTransport, AttemptBudget, CommandBatchOptions,
+CommandBatchProgress, CommandBatchResult, Money, QueryOptions, RiffDate,
+SyncApplicationTransport, Timestamp, TypedCommandResult, TypedQueryResult, WorkflowSuccessorRevision,
+)
+from riffdb_application._binding import decode_variant, encode_record
+
+def _compact_tag(value: object, tag: str, keys: frozenset[str]) -> dict[str, object]:
+    if not isinstance(value, dict) or value.get("$riffdb") != tag or frozenset(value) != keys:
+        raise ValueError("invalid RiffDB compact value")
+    return value
+
+CONTRACT_LINEAGE: Final[str] = "RiffDBBetterAuthCore"
+CONTRACT_VERSION: Final[int] = 1
+CONTRACT_BUNDLE_HASH: Final[str] = "11c5a37724f40b92bf10b195e6a66ef30037f73f3df79a98e4c4ed1076883d2e"
+QUERY_MODULE_HASH: Final[str] = "18cfd99921406e15722f3ac45867d3fbe0cebd4f2ecdd86c0ba099547c58cd91"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class User:
+    name: str
+    email: str
+    image: str | None
+    user_id: UUID
+    revision: Annotated[int, "u64"]
+    created_at: Timestamp
+    updated_at: Timestamp
+    email_verified: bool
+    organization_id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Account:
+    id: UUID
+    scope: str | None
+    user_id: UUID
+    id_token: str | None
+    password: str | None
+    revision: Annotated[int, "u64"]
+    account_id: str
+    created_at: Timestamp
+    updated_at: Timestamp
+    provider_id: str
+    access_token: str | None
+    refresh_token: str | None
+    organization_id: UUID
+    access_token_expires_at: Timestamp | None
+    refresh_token_expires_at: Timestamp | None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Session:
+    id: UUID
+    token: str
+    user_id: UUID
+    revision: Annotated[int, "u64"]
+    created_at: Timestamp
+    expires_at: Timestamp
+    ip_address: str | None
+    updated_at: Timestamp
+    user_agent: str | None
+    organization_id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Verification:
+    value: str
+    revision: Annotated[int, "u64"]
+    created_at: Timestamp
+    expires_at: Timestamp
+    identifier: str
+    updated_at: Timestamp
+    organization_id: UUID
+    verification_id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AccountPasswordUpdate:
+    user_id: UUID
+    password: str | None
+    account_id: UUID
+    updated_at: Timestamp
+    provider_id: str
+    organization_id: UUID
+    expected_revision: Annotated[int, "u64"]
+
+ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH: Final[str] = "ea5056df116418329d03bc536a195247148360378e11444c10e7ca37df54c547"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersAllEmailAscParams:
+    organization_id: UUID
+    minimum_email: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersAllEmailAscFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersAllEmailAscFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersAllEmailAscFound:
+    users: tuple[AdminUsersAllEmailAscFoundUsers, ...]
+    total: AdminUsersAllEmailAscFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersAllEmailAscFound:
+        return self
+
+AdminUsersAllEmailAscResult: TypeAlias = AdminUsersAllEmailAscFound
+
+ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH: Final[str] = "56132d4a48f43731e36b69e0fe922d67491bc0ad611375fbc3d372a840b739df"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsAscParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsAscFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsAscFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsAscFound:
+    users: tuple[AdminUsersContainsAscFoundUsers, ...]
+    total: AdminUsersContainsAscFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersContainsAscFound:
+        return self
+
+AdminUsersContainsAscResult: TypeAlias = AdminUsersContainsAscFound
+
+ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH: Final[str] = "470b720e68aa2261d902378ebc7fb1ce5be51582761672da7ecb87bece977f0f"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsDescParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsDescFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsDescFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersContainsDescFound:
+    users: tuple[AdminUsersContainsDescFoundUsers, ...]
+    total: AdminUsersContainsDescFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersContainsDescFound:
+        return self
+
+AdminUsersContainsDescResult: TypeAlias = AdminUsersContainsDescFound
+
+ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH: Final[str] = "51def4488ff2a35fee0c5d7f267daaca11e60a03521be0fdaf8923c5486c5485"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsCreatedDescParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsCreatedDescFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsCreatedDescFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsCreatedDescFound:
+    users: tuple[AdminUsersEmailContainsCreatedDescFoundUsers, ...]
+    total: AdminUsersEmailContainsCreatedDescFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersEmailContainsCreatedDescFound:
+        return self
+
+AdminUsersEmailContainsCreatedDescResult: TypeAlias = AdminUsersEmailContainsCreatedDescFound
+
+ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH: Final[str] = "fd5dc86099567113dcce8ef61c280b22f35a2c3b9e6fc592f0bcfaded4008f80"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsImageAscParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsImageAscFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsImageAscFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEmailContainsImageAscFound:
+    users: tuple[AdminUsersEmailContainsImageAscFoundUsers, ...]
+    total: AdminUsersEmailContainsImageAscFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersEmailContainsImageAscFound:
+        return self
+
+AdminUsersEmailContainsImageAscResult: TypeAlias = AdminUsersEmailContainsImageAscFound
+
+ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH: Final[str] = "a83229249df961abbc113e7b808af6beca7ca915835ddcd06cd5c28bb7d3c920"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithAscParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithAscFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithAscFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithAscFound:
+    users: tuple[AdminUsersEndsWithAscFoundUsers, ...]
+    total: AdminUsersEndsWithAscFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersEndsWithAscFound:
+        return self
+
+AdminUsersEndsWithAscResult: TypeAlias = AdminUsersEndsWithAscFound
+
+ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH: Final[str] = "ac6fdfacb6f36e2a68e36429171b5d8d502b2fd43f781d72541ece961f1da93c"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithDescParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithDescFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithDescFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersEndsWithDescFound:
+    users: tuple[AdminUsersEndsWithDescFoundUsers, ...]
+    total: AdminUsersEndsWithDescFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersEndsWithDescFound:
+        return self
+
+AdminUsersEndsWithDescResult: TypeAlias = AdminUsersEndsWithDescFound
+
+ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH: Final[str] = "e9594b9b9631b78e8cbd9a89c4a2f1b43cb40b62ef55bb18b704f790044b2332"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithAscParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithAscFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithAscFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithAscFound:
+    users: tuple[AdminUsersStartsWithAscFoundUsers, ...]
+    total: AdminUsersStartsWithAscFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersStartsWithAscFound:
+        return self
+
+AdminUsersStartsWithAscResult: TypeAlias = AdminUsersStartsWithAscFound
+
+ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH: Final[str] = "1f52bcc4f1f3e778f33e3e47299009ce70d3f4c541d1bed35e6f953d0e79ffea"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithDescParams:
+    organization_id: UUID
+    needle: str
+    user_id: UUID | None = None
+    limit: Annotated[int, "u64"] | None = None
+    offset: Annotated[int, "u64"] | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithDescFoundUsers:
+    organization_id: UUID
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithDescFoundTotal:
+    value: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AdminUsersStartsWithDescFound:
+    users: tuple[AdminUsersStartsWithDescFoundUsers, ...]
+    total: AdminUsersStartsWithDescFoundTotal
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> AdminUsersStartsWithDescFound:
+        return self
+
+AdminUsersStartsWithDescResult: TypeAlias = AdminUsersStartsWithDescFound
+
+FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH: Final[str] = "51ece0c8e7396f3f9efea7595a4224f856ae7984ff9bf15bcf9049427ad1f110"
+FIND_ACCOUNT_BY_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindAccountById", "Account", "access_token"),
+    ("FindAccountById", "Account", "refresh_token"),
+    ("FindAccountById", "Account", "id_token"),
+    ("FindAccountById", "Account", "password"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByIdParams:
+    organization_id: UUID
+    id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByIdFoundAccounts:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    account_id: str = field(repr=False)
+    provider_id: str = field(repr=False)
+    access_token: str | None = field(repr=False)
+    refresh_token: str | None = field(repr=False)
+    access_token_expires_at: Timestamp | None = field(repr=False)
+    refresh_token_expires_at: Timestamp | None = field(repr=False)
+    scope: str | None = field(repr=False)
+    id_token: str | None = field(repr=False)
+    password: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByIdFound:
+    accounts: tuple[FindAccountByIdFoundAccounts, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindAccountByIdFound:
+        return self
+
+FindAccountByIdResult: TypeAlias = FindAccountByIdFound
+
+FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH: Final[str] = "b104b38050396d747e59735cea4b562c305dccb7614a973f5177501825c91089"
+FIND_ACCOUNT_BY_PROVIDER_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindAccountByProvider", "Account", "access_token"),
+    ("FindAccountByProvider", "Account", "refresh_token"),
+    ("FindAccountByProvider", "Account", "id_token"),
+    ("FindAccountByProvider", "Account", "password"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByProviderParams:
+    organization_id: UUID
+    account_id: str
+    provider_id: str
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByProviderFoundAccounts:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    account_id: str = field(repr=False)
+    provider_id: str = field(repr=False)
+    access_token: str | None = field(repr=False)
+    refresh_token: str | None = field(repr=False)
+    access_token_expires_at: Timestamp | None = field(repr=False)
+    refresh_token_expires_at: Timestamp | None = field(repr=False)
+    scope: str | None = field(repr=False)
+    id_token: str | None = field(repr=False)
+    password: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountByProviderFound:
+    accounts: tuple[FindAccountByProviderFoundAccounts, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindAccountByProviderFound:
+        return self
+
+FindAccountByProviderResult: TypeAlias = FindAccountByProviderFound
+
+FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH: Final[str] = "0e517c2b2a10d95c12812d6374107379c80ce4638b962fad6f9092cc6b8b6c2e"
+FIND_ACCOUNTS_BY_USER_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindAccountsByUserId", "Account", "access_token"),
+    ("FindAccountsByUserId", "Account", "refresh_token"),
+    ("FindAccountsByUserId", "Account", "id_token"),
+    ("FindAccountsByUserId", "Account", "password"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserIdParams:
+    organization_id: UUID
+    user_id: UUID
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserIdFoundAccounts:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    account_id: str = field(repr=False)
+    provider_id: str = field(repr=False)
+    access_token: str | None = field(repr=False)
+    refresh_token: str | None = field(repr=False)
+    access_token_expires_at: Timestamp | None = field(repr=False)
+    refresh_token_expires_at: Timestamp | None = field(repr=False)
+    scope: str | None = field(repr=False)
+    id_token: str | None = field(repr=False)
+    password: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserIdFound:
+    accounts: tuple[FindAccountsByUserIdFoundAccounts, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindAccountsByUserIdFound:
+        return self
+
+FindAccountsByUserIdResult: TypeAlias = FindAccountsByUserIdFound
+
+FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH: Final[str] = "44124fb19b8f7fe35bb15824b87a0ed593c86b5821e81ad7fae1ab8636725183"
+FIND_ACCOUNTS_BY_USER_PROVIDER_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindAccountsByUserProvider", "Account", "access_token"),
+    ("FindAccountsByUserProvider", "Account", "refresh_token"),
+    ("FindAccountsByUserProvider", "Account", "id_token"),
+    ("FindAccountsByUserProvider", "Account", "password"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserProviderParams:
+    organization_id: UUID
+    user_id: UUID
+    provider_id: str
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserProviderFoundAccounts:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    account_id: str = field(repr=False)
+    provider_id: str = field(repr=False)
+    access_token: str | None = field(repr=False)
+    refresh_token: str | None = field(repr=False)
+    access_token_expires_at: Timestamp | None = field(repr=False)
+    refresh_token_expires_at: Timestamp | None = field(repr=False)
+    scope: str | None = field(repr=False)
+    id_token: str | None = field(repr=False)
+    password: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindAccountsByUserProviderFound:
+    accounts: tuple[FindAccountsByUserProviderFoundAccounts, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindAccountsByUserProviderFound:
+        return self
+
+FindAccountsByUserProviderResult: TypeAlias = FindAccountsByUserProviderFound
+
+FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: Final[str] = "218dbdff73dce68ba48b7f8a179791e6b46139ee84da3edbd96438045f60f8dc"
+FIND_ACTIVE_SESSIONS_BY_USER_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindActiveSessionsByUserId", "Session", "token"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindActiveSessionsByUserIdParams:
+    organization_id: UUID
+    user_id: UUID
+    expires_after: Timestamp
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindActiveSessionsByUserIdFoundSessions:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    token: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    ip_address: str | None = field(repr=False)
+    user_agent: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindActiveSessionsByUserIdFound:
+    sessions: tuple[FindActiveSessionsByUserIdFoundSessions, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindActiveSessionsByUserIdFound:
+        return self
+
+FindActiveSessionsByUserIdResult: TypeAlias = FindActiveSessionsByUserIdFound
+
+FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH: Final[str] = "e24fe82a3a724a9d45044dc668d450e61b1177f5866423c07bd33100d49428c1"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindExpiredVerificationIdsParams:
+    organization_id: UUID
+    expires_before: Timestamp
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindExpiredVerificationIdsFoundVerifications:
+    verification_id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindExpiredVerificationIdsFound:
+    verifications: tuple[FindExpiredVerificationIdsFoundVerifications, ...]
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindExpiredVerificationIdsFound:
+        return self
+
+FindExpiredVerificationIdsResult: TypeAlias = FindExpiredVerificationIdsFound
+
+FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH: Final[str] = "54336205fa315da75d390d062055723e36d07ef6596e19f756d319a8bc875023"
+FIND_LATEST_VERIFICATION_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindLatestVerification", "Verification", "value"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindLatestVerificationParams:
+    organization_id: UUID
+    identifier: str
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindLatestVerificationFoundVerifications:
+    verification_id: UUID = field(repr=False)
+    identifier: str = field(repr=False)
+    value: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindLatestVerificationFound:
+    verifications: tuple[FindLatestVerificationFoundVerifications, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindLatestVerificationFound:
+        return self
+
+FindLatestVerificationResult: TypeAlias = FindLatestVerificationFound
+
+FIND_SESSION_BY_ID_QUERY_PLAN_HASH: Final[str] = "653cfab6a75b5e2624620b0b5504b19d36f778c8775606fa0f3bb0c1d51e6bc0"
+FIND_SESSION_BY_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindSessionById", "Session", "token"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByIdParams:
+    organization_id: UUID
+    id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByIdFoundSessions:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    token: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    ip_address: str | None = field(repr=False)
+    user_agent: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByIdFound:
+    sessions: tuple[FindSessionByIdFoundSessions, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindSessionByIdFound:
+        return self
+
+FindSessionByIdResult: TypeAlias = FindSessionByIdFound
+
+FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH: Final[str] = "b5e701701b0ac99b4328200089b2507f31c0be55df78a275d83f7be99f8b7061"
+FIND_SESSION_BY_TOKEN_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindSessionByToken", "Session", "token"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByTokenParams:
+    organization_id: UUID
+    token: str
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByTokenFoundSessions:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    token: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    ip_address: str | None = field(repr=False)
+    user_agent: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionByTokenFound:
+    sessions: tuple[FindSessionByTokenFoundSessions, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindSessionByTokenFound:
+        return self
+
+FindSessionByTokenResult: TypeAlias = FindSessionByTokenFound
+
+FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH: Final[str] = "56c683d1815bf0c3e14c0585f314de378b43f9f4e401312c645efc70bd42969b"
+FIND_SESSIONS_BY_TOKEN_SET_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindSessionsByTokenSet", "Session", "token"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByTokenSetParams:
+    organization_id: UUID
+    tokens: tuple[str, ...]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByTokenSetFoundSessions:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    token: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    ip_address: str | None = field(repr=False)
+    user_agent: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByTokenSetFound:
+    sessions: tuple[FindSessionsByTokenSetFoundSessions, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindSessionsByTokenSetFound:
+        return self
+
+FindSessionsByTokenSetResult: TypeAlias = FindSessionsByTokenSetFound
+
+FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH: Final[str] = "84de4cd840d30dc9cd575e1f1daea8de94f0efa63187b646e273ba633a5d693f"
+FIND_SESSIONS_BY_USER_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindSessionsByUserId", "Session", "token"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByUserIdParams:
+    organization_id: UUID
+    user_id: UUID
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByUserIdFoundSessions:
+    id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    token: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    ip_address: str | None = field(repr=False)
+    user_agent: str | None = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindSessionsByUserIdFound:
+    sessions: tuple[FindSessionsByUserIdFoundSessions, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindSessionsByUserIdFound:
+        return self
+
+FindSessionsByUserIdResult: TypeAlias = FindSessionsByUserIdFound
+
+FIND_USER_BY_EMAIL_QUERY_PLAN_HASH: Final[str] = "ef647a48d55b825dbe566c29b03dd3fb97444df49f991bd0441d60cbb4115078"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByEmailParams:
+    organization_id: UUID
+    email: str
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByEmailFoundUsers:
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByEmailFound:
+    users: tuple[FindUserByEmailFoundUsers, ...]
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindUserByEmailFound:
+        return self
+
+FindUserByEmailResult: TypeAlias = FindUserByEmailFound
+
+def _decode_find_user_by_email_compact(value: object) -> FindUserByEmailResult:
+    if not isinstance(value, dict) or frozenset(value) != frozenset(("$riffdb_compact",)):
+        raise ValueError("invalid RiffDB compact result")
+    compact = value["$riffdb_compact"]
+    if not isinstance(compact, dict) or frozenset(compact) != frozenset(("outcome", "result_name", "entity", "fields", "rows")) or compact["outcome"] != "Found" or compact["result_name"] != "users" or compact["entity"] != "User" or compact["fields"] != ["created_at", "email", "email_verified", "image", "name", "revision", "updated_at", "user_id"] or not isinstance(compact["rows"], list) or len(compact["rows"]) > 1:
+        raise ValueError("invalid RiffDB compact result")
+    decoded: list[FindUserByEmailFoundUsers] = []
+    for row in compact["rows"]:
+        if not isinstance(row, list) or len(row) != 8:
+            raise ValueError("invalid RiffDB compact result")
+        decoded.append(FindUserByEmailFoundUsers(
+
+            created_at=Timestamp(seconds=int(_compact_tag(row[0], "timestamp", frozenset(("$riffdb", "seconds", "nanos")))["seconds"]), nanos=int(_compact_tag(row[0], "timestamp", frozenset(("$riffdb", "seconds", "nanos")))["nanos"])),
+            email=(row[1] if isinstance(row[1], str) and len(row[1].encode("utf-8")) <= 320 else (_ for _ in ()).throw(ValueError("invalid RiffDB compact string"))),
+            email_verified=(row[2] if type(row[2]) is bool else (_ for _ in ()).throw(ValueError("invalid RiffDB compact bool"))),
+            image=None if row[3] is None else (row[3] if isinstance(row[3], str) and len(row[3].encode("utf-8")) <= 2048 else (_ for _ in ()).throw(ValueError("invalid RiffDB compact string"))),
+            name=(row[4] if isinstance(row[4], str) and len(row[4].encode("utf-8")) <= 256 else (_ for _ in ()).throw(ValueError("invalid RiffDB compact string"))),
+            revision=(row[5] if type(row[5]) is int and 0 <= row[5] < 2**64 else (_ for _ in ()).throw(ValueError("invalid RiffDB compact u64"))),
+            updated_at=Timestamp(seconds=int(_compact_tag(row[6], "timestamp", frozenset(("$riffdb", "seconds", "nanos")))["seconds"]), nanos=int(_compact_tag(row[6], "timestamp", frozenset(("$riffdb", "seconds", "nanos")))["nanos"])),
+            user_id=UUID(str(_compact_tag(row[7], "uuid", frozenset(("$riffdb", "value")))["value"])),
+        ))
+    return FindUserByEmailFound(users=tuple(decoded))
+
+FIND_USER_BY_ID_QUERY_PLAN_HASH: Final[str] = "45fe0e1bda91ecd52e3a5c64c656c168c1200b1869b0f68665fd9e578439b9fd"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByIdParams:
+    organization_id: UUID
+    id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByIdFoundUser:
+    user_id: UUID
+    name: str
+    email: str
+    email_verified: bool
+    image: str | None
+    created_at: Timestamp
+    updated_at: Timestamp
+    revision: Annotated[int, "u64"]
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByIdFound:
+    user: FindUserByIdFoundUser
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def is_missing(self) -> bool:
+        return False
+
+    def unwrap_found(self) -> FindUserByIdFound:
+        return self
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindUserByIdMissing:
+    outcome: Literal["Missing"] = field(default="Missing", init=False)
+
+    def is_found(self) -> bool:
+        return False
+
+    def is_missing(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindUserByIdFound:
+        raise ValueError("expected FindUserById outcome found")
+
+FindUserByIdResult: TypeAlias = FindUserByIdFound | FindUserByIdMissing
+
+FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH: Final[str] = "3755eceb567801c6795c13a9e8868955cfe1bf185d204196f4c614d29f78c6aa"
+FIND_VERIFICATION_BY_ID_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindVerificationById", "Verification", "value"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationByIdParams:
+    organization_id: UUID
+    id: UUID
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationByIdFoundVerification:
+    verification_id: UUID = field(repr=False)
+    identifier: str = field(repr=False)
+    value: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationByIdFound:
+    verification: FindVerificationByIdFoundVerification = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def is_missing(self) -> bool:
+        return False
+
+    def unwrap_found(self) -> FindVerificationByIdFound:
+        return self
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationByIdMissing:
+    outcome: Literal["Missing"] = field(default="Missing", init=False)
+
+    def is_found(self) -> bool:
+        return False
+
+    def is_missing(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindVerificationByIdFound:
+        raise ValueError("expected FindVerificationById outcome found")
+
+FindVerificationByIdResult: TypeAlias = FindVerificationByIdFound | FindVerificationByIdMissing
+
+FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH: Final[str] = "d98f43e146032b3cd1d0dfb2eacd432795f1545fcfa00e0e45b0fbd891d8b3ed"
+FIND_VERIFICATIONS_BY_IDENTIFIER_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindVerificationsByIdentifier", "Verification", "value"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationsByIdentifierParams:
+    organization_id: UUID
+    identifier: str
+    after: str | None = None
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationsByIdentifierFoundVerifications:
+    verification_id: UUID = field(repr=False)
+    identifier: str = field(repr=False)
+    value: str = field(repr=False)
+    expires_at: Timestamp = field(repr=False)
+    created_at: Timestamp = field(repr=False)
+    updated_at: Timestamp = field(repr=False)
+    revision: Annotated[int, "u64"] = field(repr=False)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindVerificationsByIdentifierFound:
+    verifications: tuple[FindVerificationsByIdentifierFoundVerifications, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindVerificationsByIdentifierFound:
+        return self
+
+FindVerificationsByIdentifierResult: TypeAlias = FindVerificationsByIdentifierFound
+
+CONSUME_VERIFICATION_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str, str], ...]] = (
+    ("VerificationConsumed", "value", "Verification", "value"),
+)
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationInput:
+    request_id: UUID
+    organization_id: UUID
+    verification_id: UUID
+
+CONSUME_VERIFICATION_PLAN_HASH: Final[str] = "22a3f3b01aeb537ae2b8b3f758aa19d8f8a6a58a0e284b3b347d1079972adef2"
+@dataclass(frozen=True, slots=True, kw_only=True, repr=False)
+class ConsumeVerificationVerificationConsumed:
+    value: str
+    revision: Annotated[int, "u64"]
+    created_at: Timestamp
+    expires_at: Timestamp
+    identifier: str
+    updated_at: Timestamp
+    verification_id: UUID
+    outcome: Literal["VerificationConsumed"] = field(default="VerificationConsumed", init=False)
+
+    def is_verification_consumed(self) -> bool:
+        return True
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+    def __repr__(self) -> str:
+        return "ConsumeVerificationVerificationConsumed(<secret outputs redacted>)"
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationVerificationConsumeMissing:
+    outcome: Literal["VerificationConsumeMissing"] = field(default="VerificationConsumeMissing", init=False)
+
+    def is_verification_consumed(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return True
+
+ConsumeVerificationOutcome: TypeAlias = ConsumeVerificationVerificationConsumed | ConsumeVerificationVerificationConsumeMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSetInput:
+    request_id: UUID
+    organization_id: UUID
+    verification_ids: tuple[UUID, ...]
+
+CONSUME_VERIFICATION_SET_PLAN_HASH: Final[str] = "cc5e0d69851c61f11bbbca45ad00bec80b32687a94272379e133fbf854d59780"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSetVerificationSetConsumed:
+    outcome: Literal["VerificationSetConsumed"] = field(default="VerificationSetConsumed", init=False)
+
+    def is_verification_set_consumed(self) -> bool:
+        return True
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSetVerificationConsumeMissing:
+    outcome: Literal["VerificationConsumeMissing"] = field(default="VerificationConsumeMissing", init=False)
+
+    def is_verification_set_consumed(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return True
+
+ConsumeVerificationSetOutcome: TypeAlias = ConsumeVerificationSetVerificationSetConsumed | ConsumeVerificationSetVerificationConsumeMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateAccountInput:
+    id: UUID
+    scope: str | None
+    user_id: UUID
+    id_token: str | None
+    password: str | None
+    account_id: str
+    created_at: Timestamp
+    request_id: UUID
+    updated_at: Timestamp
+    provider_id: str
+    access_token: str | None
+    refresh_token: str | None
+    organization_id: UUID
+    access_token_expires_at: Timestamp | None
+    refresh_token_expires_at: Timestamp | None
+
+CREATE_ACCOUNT_PLAN_HASH: Final[str] = "53f2e7b330780eb514a299ceb673da4f1eeaea81beb45253267a52e41a7fd0b2"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateAccountAccountCreated:
+    outcome: Literal["AccountCreated"] = field(default="AccountCreated", init=False)
+
+    def is_account_created(self) -> bool:
+        return True
+
+    def is_account_user_missing(self) -> bool:
+        return False
+
+    def is_account_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateAccountAccountUserMissing:
+    outcome: Literal["AccountUserMissing"] = field(default="AccountUserMissing", init=False)
+
+    def is_account_created(self) -> bool:
+        return False
+
+    def is_account_user_missing(self) -> bool:
+        return True
+
+    def is_account_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateAccountAccountAlreadyExists:
+    outcome: Literal["AccountAlreadyExists"] = field(default="AccountAlreadyExists", init=False)
+
+    def is_account_created(self) -> bool:
+        return False
+
+    def is_account_user_missing(self) -> bool:
+        return False
+
+    def is_account_already_exists(self) -> bool:
+        return True
+
+CreateAccountOutcome: TypeAlias = CreateAccountAccountCreated | CreateAccountAccountUserMissing | CreateAccountAccountAlreadyExists
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateOAuthUserGraphInput:
+    scope: str | None
+    user_id: UUID
+    id_token: str | None
+    password: str | None
+    user_name: str
+    account_id: UUID
+    request_id: UUID
+    user_email: str
+    user_image: str | None
+    provider_id: str
+    access_token: str | None
+    refresh_token: str | None
+    organization_id: UUID
+    user_created_at: Timestamp
+    user_updated_at: Timestamp
+    account_created_at: Timestamp
+    account_updated_at: Timestamp
+    external_account_id: str
+    user_email_verified: bool
+    access_token_expires_at: Timestamp | None
+    refresh_token_expires_at: Timestamp | None
+
+CREATE_OAUTH_USER_GRAPH_PLAN_HASH: Final[str] = "a30c6faca9666ff17536e1f4ec35f0306e970430a064e0d72a66adccefad7407"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateOAuthUserGraphOAuthUserExists:
+    outcome: Literal["OAuthUserExists"] = field(default="OAuthUserExists", init=False)
+
+    def is_oauth_user_exists(self) -> bool:
+        return True
+
+    def is_oauth_account_exists(self) -> bool:
+        return False
+
+    def is_oauth_user_graph_created(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateOAuthUserGraphOAuthAccountExists:
+    outcome: Literal["OAuthAccountExists"] = field(default="OAuthAccountExists", init=False)
+
+    def is_oauth_user_exists(self) -> bool:
+        return False
+
+    def is_oauth_account_exists(self) -> bool:
+        return True
+
+    def is_oauth_user_graph_created(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateOAuthUserGraphOAuthUserGraphCreated:
+    outcome: Literal["OAuthUserGraphCreated"] = field(default="OAuthUserGraphCreated", init=False)
+
+    def is_oauth_user_exists(self) -> bool:
+        return False
+
+    def is_oauth_account_exists(self) -> bool:
+        return False
+
+    def is_oauth_user_graph_created(self) -> bool:
+        return True
+
+CreateOAuthUserGraphOutcome: TypeAlias = CreateOAuthUserGraphOAuthUserExists | CreateOAuthUserGraphOAuthAccountExists | CreateOAuthUserGraphOAuthUserGraphCreated
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSessionInput:
+    id: UUID
+    token: str
+    user_id: UUID
+    created_at: Timestamp
+    expires_at: Timestamp
+    ip_address: str | None
+    request_id: UUID
+    updated_at: Timestamp
+    user_agent: str | None
+    organization_id: UUID
+
+CREATE_SESSION_PLAN_HASH: Final[str] = "c5e41496adb0a45f87503008fa43da87c6c729674bb1f521625ff16183059050"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSessionSessionCreated:
+    outcome: Literal["SessionCreated"] = field(default="SessionCreated", init=False)
+
+    def is_session_created(self) -> bool:
+        return True
+
+    def is_session_user_missing(self) -> bool:
+        return False
+
+    def is_session_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSessionSessionUserMissing:
+    outcome: Literal["SessionUserMissing"] = field(default="SessionUserMissing", init=False)
+
+    def is_session_created(self) -> bool:
+        return False
+
+    def is_session_user_missing(self) -> bool:
+        return True
+
+    def is_session_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSessionSessionAlreadyExists:
+    outcome: Literal["SessionAlreadyExists"] = field(default="SessionAlreadyExists", init=False)
+
+    def is_session_created(self) -> bool:
+        return False
+
+    def is_session_user_missing(self) -> bool:
+        return False
+
+    def is_session_already_exists(self) -> bool:
+        return True
+
+CreateSessionOutcome: TypeAlias = CreateSessionSessionCreated | CreateSessionSessionUserMissing | CreateSessionSessionAlreadyExists
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSignupGraphInput:
+    user_id: UUID
+    user_name: str
+    account_id: UUID
+    request_id: UUID
+    session_id: UUID
+    user_email: str
+    user_image: str | None
+    provider_id: str
+    session_token: str
+    organization_id: UUID
+    user_created_at: Timestamp
+    user_updated_at: Timestamp
+    account_password: str | None
+    account_created_at: Timestamp
+    account_updated_at: Timestamp
+    session_created_at: Timestamp
+    session_expires_at: Timestamp
+    session_ip_address: str | None
+    session_updated_at: Timestamp
+    session_user_agent: str | None
+    external_account_id: str
+    user_email_verified: bool
+
+CREATE_SIGNUP_GRAPH_PLAN_HASH: Final[str] = "01e4e118b1cc5c3a16c19259284cd0845e8a2e405fc02f81ab9b1fcafc79d0b8"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSignupGraphSignupUserExists:
+    outcome: Literal["SignupUserExists"] = field(default="SignupUserExists", init=False)
+
+    def is_signup_user_exists(self) -> bool:
+        return True
+
+    def is_signup_graph_created(self) -> bool:
+        return False
+
+    def is_signup_account_exists(self) -> bool:
+        return False
+
+    def is_signup_session_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSignupGraphSignupGraphCreated:
+    outcome: Literal["SignupGraphCreated"] = field(default="SignupGraphCreated", init=False)
+
+    def is_signup_user_exists(self) -> bool:
+        return False
+
+    def is_signup_graph_created(self) -> bool:
+        return True
+
+    def is_signup_account_exists(self) -> bool:
+        return False
+
+    def is_signup_session_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSignupGraphSignupAccountExists:
+    outcome: Literal["SignupAccountExists"] = field(default="SignupAccountExists", init=False)
+
+    def is_signup_user_exists(self) -> bool:
+        return False
+
+    def is_signup_graph_created(self) -> bool:
+        return False
+
+    def is_signup_account_exists(self) -> bool:
+        return True
+
+    def is_signup_session_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateSignupGraphSignupSessionExists:
+    outcome: Literal["SignupSessionExists"] = field(default="SignupSessionExists", init=False)
+
+    def is_signup_user_exists(self) -> bool:
+        return False
+
+    def is_signup_graph_created(self) -> bool:
+        return False
+
+    def is_signup_account_exists(self) -> bool:
+        return False
+
+    def is_signup_session_exists(self) -> bool:
+        return True
+
+CreateSignupGraphOutcome: TypeAlias = CreateSignupGraphSignupUserExists | CreateSignupGraphSignupGraphCreated | CreateSignupGraphSignupAccountExists | CreateSignupGraphSignupSessionExists
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateUserInput:
+    id: UUID
+    name: str
+    email: str
+    image: str | None
+    created_at: Timestamp
+    request_id: UUID
+    updated_at: Timestamp
+    email_verified: bool
+    organization_id: UUID
+
+CREATE_USER_PLAN_HASH: Final[str] = "752d7d404aa418b5c1a08065ce9a8efbb28ab2b62f18969c98a13a06092fd8b3"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateUserUserCreated:
+    outcome: Literal["UserCreated"] = field(default="UserCreated", init=False)
+
+    def is_user_created(self) -> bool:
+        return True
+
+    def is_user_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateUserUserAlreadyExists:
+    outcome: Literal["UserAlreadyExists"] = field(default="UserAlreadyExists", init=False)
+
+    def is_user_created(self) -> bool:
+        return False
+
+    def is_user_already_exists(self) -> bool:
+        return True
+
+CreateUserOutcome: TypeAlias = CreateUserUserCreated | CreateUserUserAlreadyExists
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateVerificationInput:
+    id: UUID
+    value: str
+    created_at: Timestamp
+    expires_at: Timestamp
+    identifier: str
+    request_id: UUID
+    updated_at: Timestamp
+    organization_id: UUID
+
+CREATE_VERIFICATION_PLAN_HASH: Final[str] = "82bce005457b1fcf1d069a69304f7bf4e2eeb7d2718d5289dc9d25e197309e35"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateVerificationVerificationCreated:
+    outcome: Literal["VerificationCreated"] = field(default="VerificationCreated", init=False)
+
+    def is_verification_created(self) -> bool:
+        return True
+
+    def is_verification_already_exists(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class CreateVerificationVerificationAlreadyExists:
+    outcome: Literal["VerificationAlreadyExists"] = field(default="VerificationAlreadyExists", init=False)
+
+    def is_verification_created(self) -> bool:
+        return False
+
+    def is_verification_already_exists(self) -> bool:
+        return True
+
+CreateVerificationOutcome: TypeAlias = CreateVerificationVerificationCreated | CreateVerificationVerificationAlreadyExists
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteAccountInput:
+    user_id: UUID
+    request_id: UUID
+    account_ids: tuple[UUID, ...]
+    organization_id: UUID
+
+DELETE_ACCOUNT_PLAN_HASH: Final[str] = "6429ebe6e70797c57c44a4738c8a511bbe5304e5bf58148dfc0c2721ffaff382"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteAccountAccountDeleted:
+    outcome: Literal["AccountDeleted"] = field(default="AccountDeleted", init=False)
+
+    def is_account_deleted(self) -> bool:
+        return True
+
+    def is_account_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteAccountAccountMissing:
+    outcome: Literal["AccountMissing"] = field(default="AccountMissing", init=False)
+
+    def is_account_deleted(self) -> bool:
+        return False
+
+    def is_account_missing(self) -> bool:
+        return True
+
+DeleteAccountOutcome: TypeAlias = DeleteAccountAccountDeleted | DeleteAccountAccountMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteSessionInput:
+    user_id: UUID
+    request_id: UUID
+    session_ids: tuple[UUID, ...]
+    organization_id: UUID
+
+DELETE_SESSION_PLAN_HASH: Final[str] = "a3901beb6c2d2754fd3d2c64252b6f5059cd1792c0a0560741c94da4668a0524"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteSessionSessionDeleted:
+    outcome: Literal["SessionDeleted"] = field(default="SessionDeleted", init=False)
+
+    def is_session_deleted(self) -> bool:
+        return True
+
+    def is_session_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteSessionSessionMissing:
+    outcome: Literal["SessionMissing"] = field(default="SessionMissing", init=False)
+
+    def is_session_deleted(self) -> bool:
+        return False
+
+    def is_session_missing(self) -> bool:
+        return True
+
+DeleteSessionOutcome: TypeAlias = DeleteSessionSessionDeleted | DeleteSessionSessionMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteUserInput:
+    user_ids: tuple[UUID, ...]
+    request_id: UUID
+    organization_id: UUID
+
+DELETE_USER_PLAN_HASH: Final[str] = "f7195857c4f50a68b37ee0f8516c27dd03b08d5cd5ba45f53d9f9345d2f90985"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteUserUserDeleted:
+    outcome: Literal["UserDeleted"] = field(default="UserDeleted", init=False)
+
+    def is_user_deleted(self) -> bool:
+        return True
+
+    def is_delete_user_missing(self) -> bool:
+        return False
+
+    def is_delete_user_cascade_limit_exceeded(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteUserDeleteUserMissing:
+    outcome: Literal["DeleteUserMissing"] = field(default="DeleteUserMissing", init=False)
+
+    def is_user_deleted(self) -> bool:
+        return False
+
+    def is_delete_user_missing(self) -> bool:
+        return True
+
+    def is_delete_user_cascade_limit_exceeded(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteUserDeleteUserCascadeLimitExceeded:
+    outcome: Literal["DeleteUserCascadeLimitExceeded"] = field(default="DeleteUserCascadeLimitExceeded", init=False)
+
+    def is_user_deleted(self) -> bool:
+        return False
+
+    def is_delete_user_missing(self) -> bool:
+        return False
+
+    def is_delete_user_cascade_limit_exceeded(self) -> bool:
+        return True
+
+DeleteUserOutcome: TypeAlias = DeleteUserUserDeleted | DeleteUserDeleteUserMissing | DeleteUserDeleteUserCascadeLimitExceeded
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteVerificationInput:
+    request_id: UUID
+    organization_id: UUID
+    verification_ids: tuple[UUID, ...]
+
+DELETE_VERIFICATION_PLAN_HASH: Final[str] = "bffc0c5ef5ad2b602954492d043e833785ec3f9d6f0520fbc0f933422544ae6a"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteVerificationVerificationDeleted:
+    outcome: Literal["VerificationDeleted"] = field(default="VerificationDeleted", init=False)
+
+    def is_verification_deleted(self) -> bool:
+        return True
+
+    def is_verification_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class DeleteVerificationVerificationMissing:
+    outcome: Literal["VerificationMissing"] = field(default="VerificationMissing", init=False)
+
+    def is_verification_deleted(self) -> bool:
+        return False
+
+    def is_verification_missing(self) -> bool:
+        return True
+
+DeleteVerificationOutcome: TypeAlias = DeleteVerificationVerificationDeleted | DeleteVerificationVerificationMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountInput:
+    scope: str | None
+    user_id: UUID
+    id_token: str | None
+    password: str | None
+    account_id: UUID
+    request_id: UUID
+    updated_at: Timestamp
+    provider_id: str
+    access_token: str | None
+    refresh_token: str | None
+    organization_id: UUID
+    expected_revision: Annotated[int, "u64"]
+    external_account_id: str
+    access_token_expires_at: Timestamp | None
+    refresh_token_expires_at: Timestamp | None
+
+UPDATE_ACCOUNT_PLAN_HASH: Final[str] = "1556cd92effd135225904f0313f1cdf146ebe82f72621ebeccb2686c5442b849"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountAccountUpdated:
+    outcome: Literal["AccountUpdated"] = field(default="AccountUpdated", init=False)
+
+    def is_account_updated(self) -> bool:
+        return True
+
+    def is_account_update_stale(self) -> bool:
+        return False
+
+    def is_account_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountAccountUpdateStale:
+    outcome: Literal["AccountUpdateStale"] = field(default="AccountUpdateStale", init=False)
+
+    def is_account_updated(self) -> bool:
+        return False
+
+    def is_account_update_stale(self) -> bool:
+        return True
+
+    def is_account_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountAccountUpdateMissing:
+    outcome: Literal["AccountUpdateMissing"] = field(default="AccountUpdateMissing", init=False)
+
+    def is_account_updated(self) -> bool:
+        return False
+
+    def is_account_update_stale(self) -> bool:
+        return False
+
+    def is_account_update_missing(self) -> bool:
+        return True
+
+UpdateAccountOutcome: TypeAlias = UpdateAccountAccountUpdated | UpdateAccountAccountUpdateStale | UpdateAccountAccountUpdateMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountPasswordsInput:
+    updates: tuple[AccountPasswordUpdate, ...]
+    user_id: UUID
+    request_id: UUID
+    organization_id: UUID
+
+UPDATE_ACCOUNT_PASSWORDS_PLAN_HASH: Final[str] = "5f18c741b5e9c09203c67b5985af9d034fad670462ecdda32a0a1f031ef288f6"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountPasswordsPasswordAccountStale:
+    outcome: Literal["PasswordAccountStale"] = field(default="PasswordAccountStale", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return True
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_account_passwords_updated(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountPasswordsPasswordAccountMissing:
+    outcome: Literal["PasswordAccountMissing"] = field(default="PasswordAccountMissing", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return True
+
+    def is_account_passwords_updated(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountPasswordsAccountPasswordsUpdated:
+    outcome: Literal["AccountPasswordsUpdated"] = field(default="AccountPasswordsUpdated", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_account_passwords_updated(self) -> bool:
+        return True
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateAccountPasswordsPasswordProviderMismatch:
+    outcome: Literal["PasswordProviderMismatch"] = field(default="PasswordProviderMismatch", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_account_passwords_updated(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return True
+
+UpdateAccountPasswordsOutcome: TypeAlias = UpdateAccountPasswordsPasswordAccountStale | UpdateAccountPasswordsPasswordAccountMissing | UpdateAccountPasswordsAccountPasswordsUpdated | UpdateAccountPasswordsPasswordProviderMismatch
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateSessionInput:
+    user_id: UUID
+    expires_at: Timestamp
+    ip_address: str | None
+    request_id: UUID
+    session_id: UUID
+    updated_at: Timestamp
+    user_agent: str | None
+    organization_id: UUID
+    expected_revision: Annotated[int, "u64"]
+
+UPDATE_SESSION_PLAN_HASH: Final[str] = "4c1184c5c0a1f8b8935a8b96204ad839afe84e1752f2ba24cdf63feef4f7ce3a"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateSessionSessionUpdated:
+    outcome: Literal["SessionUpdated"] = field(default="SessionUpdated", init=False)
+
+    def is_session_updated(self) -> bool:
+        return True
+
+    def is_session_update_stale(self) -> bool:
+        return False
+
+    def is_session_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateSessionSessionUpdateStale:
+    outcome: Literal["SessionUpdateStale"] = field(default="SessionUpdateStale", init=False)
+
+    def is_session_updated(self) -> bool:
+        return False
+
+    def is_session_update_stale(self) -> bool:
+        return True
+
+    def is_session_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateSessionSessionUpdateMissing:
+    outcome: Literal["SessionUpdateMissing"] = field(default="SessionUpdateMissing", init=False)
+
+    def is_session_updated(self) -> bool:
+        return False
+
+    def is_session_update_stale(self) -> bool:
+        return False
+
+    def is_session_update_missing(self) -> bool:
+        return True
+
+UpdateSessionOutcome: TypeAlias = UpdateSessionSessionUpdated | UpdateSessionSessionUpdateStale | UpdateSessionSessionUpdateMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateUserInput:
+    name: str
+    email: str
+    image: str | None
+    user_id: UUID
+    request_id: UUID
+    updated_at: Timestamp
+    email_verified: bool
+    organization_id: UUID
+    expected_revision: Annotated[int, "u64"]
+
+UPDATE_USER_PLAN_HASH: Final[str] = "cd0d3c8108976d4b2413f41fd68791b3e9276a763787f40b82bef17219091194"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateUserUserUpdated:
+    outcome: Literal["UserUpdated"] = field(default="UserUpdated", init=False)
+
+    def is_user_updated(self) -> bool:
+        return True
+
+    def is_user_update_stale(self) -> bool:
+        return False
+
+    def is_user_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateUserUserUpdateStale:
+    outcome: Literal["UserUpdateStale"] = field(default="UserUpdateStale", init=False)
+
+    def is_user_updated(self) -> bool:
+        return False
+
+    def is_user_update_stale(self) -> bool:
+        return True
+
+    def is_user_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateUserUserUpdateMissing:
+    outcome: Literal["UserUpdateMissing"] = field(default="UserUpdateMissing", init=False)
+
+    def is_user_updated(self) -> bool:
+        return False
+
+    def is_user_update_stale(self) -> bool:
+        return False
+
+    def is_user_update_missing(self) -> bool:
+        return True
+
+UpdateUserOutcome: TypeAlias = UpdateUserUserUpdated | UpdateUserUserUpdateStale | UpdateUserUserUpdateMissing
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateVerificationInput:
+    value: str
+    expires_at: Timestamp
+    request_id: UUID
+    updated_at: Timestamp
+    organization_id: UUID
+    verification_id: UUID
+    expected_revision: Annotated[int, "u64"]
+
+UPDATE_VERIFICATION_PLAN_HASH: Final[str] = "b9ea963db584e7fd9dbce1069d982dc0f53ebb06b72b41b060578b284596018f"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateVerificationVerificationUpdated:
+    outcome: Literal["VerificationUpdated"] = field(default="VerificationUpdated", init=False)
+
+    def is_verification_updated(self) -> bool:
+        return True
+
+    def is_verification_update_stale(self) -> bool:
+        return False
+
+    def is_verification_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateVerificationVerificationUpdateStale:
+    outcome: Literal["VerificationUpdateStale"] = field(default="VerificationUpdateStale", init=False)
+
+    def is_verification_updated(self) -> bool:
+        return False
+
+    def is_verification_update_stale(self) -> bool:
+        return True
+
+    def is_verification_update_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateVerificationVerificationUpdateMissing:
+    outcome: Literal["VerificationUpdateMissing"] = field(default="VerificationUpdateMissing", init=False)
+
+    def is_verification_updated(self) -> bool:
+        return False
+
+    def is_verification_update_stale(self) -> bool:
+        return False
+
+    def is_verification_update_missing(self) -> bool:
+        return True
+
+UpdateVerificationOutcome: TypeAlias = UpdateVerificationVerificationUpdated | UpdateVerificationVerificationUpdateStale | UpdateVerificationVerificationUpdateMissing
+
+class RiffDBBetterAuthCoreClient:
+    def __init__(self, transport: SyncApplicationTransport, command_attempts: AttemptBudget = AttemptBudget(3), *, read_after_commit: int | None = None, track_causal_writes: bool = True) -> None:
+        self._transport = transport
+        self._command_attempts = command_attempts
+        self._read_after_commit = read_after_commit
+        self._track_causal_writes = track_causal_writes
+
+    @classmethod
+    def from_transport(cls, transport: SyncApplicationTransport, command_attempts: AttemptBudget = AttemptBudget(3)) -> RiffDBBetterAuthCoreClient:
+        return cls(transport, command_attempts)
+
+    def with_read_after_commit(self, commit_sequence: int | None) -> RiffDBBetterAuthCoreClient:
+        return RiffDBBetterAuthCoreClient(self._transport, self._command_attempts, read_after_commit=commit_sequence, track_causal_writes=self._track_causal_writes)
+
+    def causal_session(self, initial_commit_sequence: int | None = None) -> RiffDBBetterAuthCoreClient:
+        return RiffDBBetterAuthCoreClient(self._transport, self._command_attempts, read_after_commit=initial_commit_sequence if initial_commit_sequence is not None else self._read_after_commit, track_causal_writes=True)
+
+    @property
+    def last_commit_sequence(self) -> int | None:
+        return self._read_after_commit
+
+    def admin_users_all_email_asc(self, parameters: AdminUsersAllEmailAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersAllEmailAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersAllEmailAsc", plan_hash=ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersAllEmailAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_all_email_asc_after_commit(self, parameters: AdminUsersAllEmailAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersAllEmailAscResult]:
+        return self.admin_users_all_email_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_contains_asc(self, parameters: AdminUsersContainsAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersContainsAsc", plan_hash=ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersContainsAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_contains_asc_after_commit(self, parameters: AdminUsersContainsAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsAscResult]:
+        return self.admin_users_contains_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_contains_desc(self, parameters: AdminUsersContainsDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersContainsDesc", plan_hash=ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersContainsDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_contains_desc_after_commit(self, parameters: AdminUsersContainsDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsDescResult]:
+        return self.admin_users_contains_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_email_contains_created_desc(self, parameters: AdminUsersEmailContainsCreatedDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsCreatedDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEmailContainsCreatedDesc", plan_hash=ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEmailContainsCreatedDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_email_contains_created_desc_after_commit(self, parameters: AdminUsersEmailContainsCreatedDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsCreatedDescResult]:
+        return self.admin_users_email_contains_created_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_email_contains_image_asc(self, parameters: AdminUsersEmailContainsImageAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsImageAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEmailContainsImageAsc", plan_hash=ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEmailContainsImageAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_email_contains_image_asc_after_commit(self, parameters: AdminUsersEmailContainsImageAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsImageAscResult]:
+        return self.admin_users_email_contains_image_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_ends_with_asc(self, parameters: AdminUsersEndsWithAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEndsWithAsc", plan_hash=ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEndsWithAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_ends_with_asc_after_commit(self, parameters: AdminUsersEndsWithAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithAscResult]:
+        return self.admin_users_ends_with_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_ends_with_desc(self, parameters: AdminUsersEndsWithDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEndsWithDesc", plan_hash=ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEndsWithDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_ends_with_desc_after_commit(self, parameters: AdminUsersEndsWithDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithDescResult]:
+        return self.admin_users_ends_with_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_starts_with_asc(self, parameters: AdminUsersStartsWithAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersStartsWithAsc", plan_hash=ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersStartsWithAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_starts_with_asc_after_commit(self, parameters: AdminUsersStartsWithAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithAscResult]:
+        return self.admin_users_starts_with_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def admin_users_starts_with_desc(self, parameters: AdminUsersStartsWithDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersStartsWithDesc", plan_hash=ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersStartsWithDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def admin_users_starts_with_desc_after_commit(self, parameters: AdminUsersStartsWithDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithDescResult]:
+        return self.admin_users_starts_with_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_account_by_id(self, parameters: FindAccountByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountById", plan_hash=FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindAccountByIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_account_by_id_after_commit(self, parameters: FindAccountByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByIdResult]:
+        return self.find_account_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_account_by_provider(self, parameters: FindAccountByProviderParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByProviderResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountByProvider", plan_hash=FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindAccountByProviderFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_account_by_provider_after_commit(self, parameters: FindAccountByProviderParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByProviderResult]:
+        return self.find_account_by_provider(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_accounts_by_user_id(self, parameters: FindAccountsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountsByUserId", plan_hash=FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindAccountsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_accounts_by_user_id_after_commit(self, parameters: FindAccountsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserIdResult]:
+        return self.find_accounts_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_accounts_by_user_id_pages(self, parameters: FindAccountsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindAccountsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindAccountsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindAccountsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, after=None)
+            page = self.find_accounts_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def find_accounts_by_user_provider(self, parameters: FindAccountsByUserProviderParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserProviderResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountsByUserProvider", plan_hash=FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindAccountsByUserProviderFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_accounts_by_user_provider_after_commit(self, parameters: FindAccountsByUserProviderParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserProviderResult]:
+        return self.find_accounts_by_user_provider(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_accounts_by_user_provider_pages(self, parameters: FindAccountsByUserProviderParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindAccountsByUserProviderResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindAccountsByUserProviderResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindAccountsByUserProviderParams(organization_id=parameters.organization_id, user_id=parameters.user_id, provider_id=parameters.provider_id, after=None)
+            page = self.find_accounts_by_user_provider(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def find_active_sessions_by_user_id(self, parameters: FindActiveSessionsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindActiveSessionsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindActiveSessionsByUserId", plan_hash=FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindActiveSessionsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_active_sessions_by_user_id_after_commit(self, parameters: FindActiveSessionsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindActiveSessionsByUserIdResult]:
+        return self.find_active_sessions_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_active_sessions_by_user_id_pages(self, parameters: FindActiveSessionsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindActiveSessionsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindActiveSessionsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindActiveSessionsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, expires_after=parameters.expires_after, after=None)
+            page = self.find_active_sessions_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def find_expired_verification_ids(self, parameters: FindExpiredVerificationIdsParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindExpiredVerificationIdsResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindExpiredVerificationIds", plan_hash=FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindExpiredVerificationIdsFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_expired_verification_ids_after_commit(self, parameters: FindExpiredVerificationIdsParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindExpiredVerificationIdsResult]:
+        return self.find_expired_verification_ids(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_expired_verification_ids_pages(self, parameters: FindExpiredVerificationIdsParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindExpiredVerificationIdsResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindExpiredVerificationIdsResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindExpiredVerificationIdsParams(organization_id=parameters.organization_id, expires_before=parameters.expires_before, after=None)
+            page = self.find_expired_verification_ids(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def find_latest_verification(self, parameters: FindLatestVerificationParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindLatestVerificationResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindLatestVerification", plan_hash=FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindLatestVerificationFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_latest_verification_after_commit(self, parameters: FindLatestVerificationParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindLatestVerificationResult]:
+        return self.find_latest_verification(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_session_by_id(self, parameters: FindSessionByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionById", plan_hash=FIND_SESSION_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionByIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_session_by_id_after_commit(self, parameters: FindSessionByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByIdResult]:
+        return self.find_session_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_session_by_token(self, parameters: FindSessionByTokenParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByTokenResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionByToken", plan_hash=FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionByTokenFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_session_by_token_after_commit(self, parameters: FindSessionByTokenParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByTokenResult]:
+        return self.find_session_by_token(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_sessions_by_token_set(self, parameters: FindSessionsByTokenSetParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionsByTokenSet", plan_hash=FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionsByTokenSetFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_sessions_by_token_set_after_commit(self, parameters: FindSessionsByTokenSetParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetResult]:
+        return self.find_sessions_by_token_set(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_sessions_by_user_id(self, parameters: FindSessionsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionsByUserId", plan_hash=FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindSessionsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_sessions_by_user_id_after_commit(self, parameters: FindSessionsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByUserIdResult]:
+        return self.find_sessions_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_sessions_by_user_id_pages(self, parameters: FindSessionsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindSessionsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindSessionsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindSessionsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, after=None)
+            page = self.find_sessions_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def find_user_by_email(self, parameters: FindUserByEmailParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByEmailResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindUserByEmail", plan_hash=FIND_USER_BY_EMAIL_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+            accept_compact_result=True,
+        )
+        outcomes = {
+            "Found": FindUserByEmailFound,
+        }
+        return raw._map_value(lambda value: _decode_find_user_by_email_compact(value) if isinstance(value, dict) and "$riffdb_compact" in value else decode_variant(outcomes, value))
+
+    def find_user_by_email_after_commit(self, parameters: FindUserByEmailParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByEmailResult]:
+        return self.find_user_by_email(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_user_by_id(self, parameters: FindUserByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindUserById", plan_hash=FIND_USER_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindUserByIdFound,
+            "Missing": FindUserByIdMissing,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_user_by_id_after_commit(self, parameters: FindUserByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByIdResult]:
+        return self.find_user_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_verification_by_id(self, parameters: FindVerificationByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindVerificationById", plan_hash=FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindVerificationByIdFound,
+            "Missing": FindVerificationByIdMissing,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_verification_by_id_after_commit(self, parameters: FindVerificationByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationByIdResult]:
+        return self.find_verification_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_verifications_by_identifier(self, parameters: FindVerificationsByIdentifierParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationsByIdentifierResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindVerificationsByIdentifier", plan_hash=FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindVerificationsByIdentifierFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_verifications_by_identifier_after_commit(self, parameters: FindVerificationsByIdentifierParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationsByIdentifierResult]:
+        return self.find_verifications_by_identifier(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    def find_verifications_by_identifier_pages(self, parameters: FindVerificationsByIdentifierParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindVerificationsByIdentifierResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindVerificationsByIdentifierResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindVerificationsByIdentifierParams(organization_id=parameters.organization_id, identifier=parameters.identifier, after=None)
+            page = self.find_verifications_by_identifier(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    def consume_verification(self, input: ConsumeVerificationInput) -> TypedCommandResult[ConsumeVerificationOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerification", plan_hash=CONSUME_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationConsumed": ConsumeVerificationVerificationConsumed,
+            "VerificationConsumeMissing": ConsumeVerificationVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def consume_verification_batch(
+        self, inputs: Sequence[ConsumeVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationOutcome]:
+        return self._transport._command_batch(inputs, options, self.consume_verification, progress)
+
+    def consume_verification_set(self, input: ConsumeVerificationSetInput) -> TypedCommandResult[ConsumeVerificationSetOutcome]:
+        if not 1 <= len(input.verification_ids) <= 32:
+            raise ValueError("invalid bounded collection length for ConsumeVerificationSet.verification_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerificationSet", plan_hash=CONSUME_VERIFICATION_SET_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationSetConsumed": ConsumeVerificationSetVerificationSetConsumed,
+            "VerificationConsumeMissing": ConsumeVerificationSetVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationSetOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def consume_verification_set_batch(
+        self, inputs: Sequence[ConsumeVerificationSetInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationSetOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 32:
+                raise ValueError("invalid bounded collection length for ConsumeVerificationSet.verification_ids")
+        return self._transport._command_batch(inputs, options, self.consume_verification_set, progress)
+
+    def create_account(self, input: CreateAccountInput) -> TypedCommandResult[CreateAccountOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateAccount", plan_hash=CREATE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountCreated": CreateAccountAccountCreated,
+            "AccountUserMissing": CreateAccountAccountUserMissing,
+            "AccountAlreadyExists": CreateAccountAccountAlreadyExists,
+        }
+        result: TypedCommandResult[CreateAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_account_batch(
+        self, inputs: Sequence[CreateAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateAccountOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_account, progress)
+
+    def create_oauth_user_graph(self, input: CreateOAuthUserGraphInput) -> TypedCommandResult[CreateOAuthUserGraphOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateOAuthUserGraph", plan_hash=CREATE_OAUTH_USER_GRAPH_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "OAuthUserExists": CreateOAuthUserGraphOAuthUserExists,
+            "OAuthAccountExists": CreateOAuthUserGraphOAuthAccountExists,
+            "OAuthUserGraphCreated": CreateOAuthUserGraphOAuthUserGraphCreated,
+        }
+        result: TypedCommandResult[CreateOAuthUserGraphOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_oauth_user_graph_batch(
+        self, inputs: Sequence[CreateOAuthUserGraphInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateOAuthUserGraphOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_oauth_user_graph, progress)
+
+    def create_session(self, input: CreateSessionInput) -> TypedCommandResult[CreateSessionOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateSession", plan_hash=CREATE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionCreated": CreateSessionSessionCreated,
+            "SessionUserMissing": CreateSessionSessionUserMissing,
+            "SessionAlreadyExists": CreateSessionSessionAlreadyExists,
+        }
+        result: TypedCommandResult[CreateSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_session_batch(
+        self, inputs: Sequence[CreateSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateSessionOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_session, progress)
+
+    def create_signup_graph(self, input: CreateSignupGraphInput) -> TypedCommandResult[CreateSignupGraphOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateSignupGraph", plan_hash=CREATE_SIGNUP_GRAPH_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SignupUserExists": CreateSignupGraphSignupUserExists,
+            "SignupGraphCreated": CreateSignupGraphSignupGraphCreated,
+            "SignupAccountExists": CreateSignupGraphSignupAccountExists,
+            "SignupSessionExists": CreateSignupGraphSignupSessionExists,
+        }
+        result: TypedCommandResult[CreateSignupGraphOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_signup_graph_batch(
+        self, inputs: Sequence[CreateSignupGraphInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateSignupGraphOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_signup_graph, progress)
+
+    def create_user(self, input: CreateUserInput) -> TypedCommandResult[CreateUserOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateUser", plan_hash=CREATE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserCreated": CreateUserUserCreated,
+            "UserAlreadyExists": CreateUserUserAlreadyExists,
+        }
+        result: TypedCommandResult[CreateUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_user_batch(
+        self, inputs: Sequence[CreateUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateUserOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_user, progress)
+
+    def create_verification(self, input: CreateVerificationInput) -> TypedCommandResult[CreateVerificationOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateVerification", plan_hash=CREATE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationCreated": CreateVerificationVerificationCreated,
+            "VerificationAlreadyExists": CreateVerificationVerificationAlreadyExists,
+        }
+        result: TypedCommandResult[CreateVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def create_verification_batch(
+        self, inputs: Sequence[CreateVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateVerificationOutcome]:
+        return self._transport._command_batch(inputs, options, self.create_verification, progress)
+
+    def delete_account(self, input: DeleteAccountInput) -> TypedCommandResult[DeleteAccountOutcome]:
+        if not 1 <= len(input.account_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteAccount.account_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteAccount", plan_hash=DELETE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountDeleted": DeleteAccountAccountDeleted,
+            "AccountMissing": DeleteAccountAccountMissing,
+        }
+        result: TypedCommandResult[DeleteAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def delete_account_batch(
+        self, inputs: Sequence[DeleteAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteAccountOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.account_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteAccount.account_ids")
+        return self._transport._command_batch(inputs, options, self.delete_account, progress)
+
+    def delete_session(self, input: DeleteSessionInput) -> TypedCommandResult[DeleteSessionOutcome]:
+        if not 1 <= len(input.session_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteSession.session_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteSession", plan_hash=DELETE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionDeleted": DeleteSessionSessionDeleted,
+            "SessionMissing": DeleteSessionSessionMissing,
+        }
+        result: TypedCommandResult[DeleteSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def delete_session_batch(
+        self, inputs: Sequence[DeleteSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteSessionOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.session_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteSession.session_ids")
+        return self._transport._command_batch(inputs, options, self.delete_session, progress)
+
+    def delete_user(self, input: DeleteUserInput) -> TypedCommandResult[DeleteUserOutcome]:
+        if not 1 <= len(input.user_ids) <= 1:
+            raise ValueError("invalid bounded collection length for DeleteUser.user_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteUser", plan_hash=DELETE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserDeleted": DeleteUserUserDeleted,
+            "DeleteUserMissing": DeleteUserDeleteUserMissing,
+            "DeleteUserCascadeLimitExceeded": DeleteUserDeleteUserCascadeLimitExceeded,
+        }
+        result: TypedCommandResult[DeleteUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def delete_user_batch(
+        self, inputs: Sequence[DeleteUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteUserOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.user_ids) <= 1:
+                raise ValueError("invalid bounded collection length for DeleteUser.user_ids")
+        return self._transport._command_batch(inputs, options, self.delete_user, progress)
+
+    def delete_verification(self, input: DeleteVerificationInput) -> TypedCommandResult[DeleteVerificationOutcome]:
+        if not 1 <= len(input.verification_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteVerification.verification_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteVerification", plan_hash=DELETE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationDeleted": DeleteVerificationVerificationDeleted,
+            "VerificationMissing": DeleteVerificationVerificationMissing,
+        }
+        result: TypedCommandResult[DeleteVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def delete_verification_batch(
+        self, inputs: Sequence[DeleteVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteVerificationOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteVerification.verification_ids")
+        return self._transport._command_batch(inputs, options, self.delete_verification, progress)
+
+    def update_account(self, input: UpdateAccountInput) -> TypedCommandResult[UpdateAccountOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateAccount", plan_hash=UPDATE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountUpdated": UpdateAccountAccountUpdated,
+            "AccountUpdateStale": UpdateAccountAccountUpdateStale,
+            "AccountUpdateMissing": UpdateAccountAccountUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def update_account_batch(
+        self, inputs: Sequence[UpdateAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateAccountOutcome]:
+        return self._transport._command_batch(inputs, options, self.update_account, progress)
+
+    def update_account_passwords(self, input: UpdateAccountPasswordsInput) -> TypedCommandResult[UpdateAccountPasswordsOutcome]:
+        if not 1 <= len(input.updates) <= 8:
+            raise ValueError("invalid bounded collection length for UpdateAccountPasswords.updates")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateAccountPasswords", plan_hash=UPDATE_ACCOUNT_PASSWORDS_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": UpdateAccountPasswordsPasswordAccountStale,
+            "PasswordAccountMissing": UpdateAccountPasswordsPasswordAccountMissing,
+            "AccountPasswordsUpdated": UpdateAccountPasswordsAccountPasswordsUpdated,
+            "PasswordProviderMismatch": UpdateAccountPasswordsPasswordProviderMismatch,
+        }
+        result: TypedCommandResult[UpdateAccountPasswordsOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def update_account_passwords_batch(
+        self, inputs: Sequence[UpdateAccountPasswordsInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateAccountPasswordsOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.updates) <= 8:
+                raise ValueError("invalid bounded collection length for UpdateAccountPasswords.updates")
+        return self._transport._command_batch(inputs, options, self.update_account_passwords, progress)
+
+    def update_session(self, input: UpdateSessionInput) -> TypedCommandResult[UpdateSessionOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateSession", plan_hash=UPDATE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionUpdated": UpdateSessionSessionUpdated,
+            "SessionUpdateStale": UpdateSessionSessionUpdateStale,
+            "SessionUpdateMissing": UpdateSessionSessionUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def update_session_batch(
+        self, inputs: Sequence[UpdateSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateSessionOutcome]:
+        return self._transport._command_batch(inputs, options, self.update_session, progress)
+
+    def update_user(self, input: UpdateUserInput) -> TypedCommandResult[UpdateUserOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateUser", plan_hash=UPDATE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserUpdated": UpdateUserUserUpdated,
+            "UserUpdateStale": UpdateUserUserUpdateStale,
+            "UserUpdateMissing": UpdateUserUserUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def update_user_batch(
+        self, inputs: Sequence[UpdateUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateUserOutcome]:
+        return self._transport._command_batch(inputs, options, self.update_user, progress)
+
+    def update_verification(self, input: UpdateVerificationInput) -> TypedCommandResult[UpdateVerificationOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateVerification", plan_hash=UPDATE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationUpdated": UpdateVerificationVerificationUpdated,
+            "VerificationUpdateStale": UpdateVerificationVerificationUpdateStale,
+            "VerificationUpdateMissing": UpdateVerificationVerificationUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    def update_verification_batch(
+        self, inputs: Sequence[UpdateVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateVerificationOutcome]:
+        return self._transport._command_batch(inputs, options, self.update_verification, progress)
+
+class AsyncRiffDBBetterAuthCoreClient:
+    def __init__(self, transport: AsyncApplicationTransport, command_attempts: AttemptBudget = AttemptBudget(3), *, read_after_commit: int | None = None, track_causal_writes: bool = True) -> None:
+        self._transport = transport
+        self._command_attempts = command_attempts
+        self._read_after_commit = read_after_commit
+        self._track_causal_writes = track_causal_writes
+
+    @classmethod
+    def from_transport(cls, transport: AsyncApplicationTransport, command_attempts: AttemptBudget = AttemptBudget(3)) -> AsyncRiffDBBetterAuthCoreClient:
+        return cls(transport, command_attempts)
+
+    def with_read_after_commit(self, commit_sequence: int | None) -> AsyncRiffDBBetterAuthCoreClient:
+        return AsyncRiffDBBetterAuthCoreClient(self._transport, self._command_attempts, read_after_commit=commit_sequence, track_causal_writes=self._track_causal_writes)
+
+    def causal_session(self, initial_commit_sequence: int | None = None) -> AsyncRiffDBBetterAuthCoreClient:
+        return AsyncRiffDBBetterAuthCoreClient(self._transport, self._command_attempts, read_after_commit=initial_commit_sequence if initial_commit_sequence is not None else self._read_after_commit, track_causal_writes=True)
+
+    @property
+    def last_commit_sequence(self) -> int | None:
+        return self._read_after_commit
+
+    async def admin_users_all_email_asc(self, parameters: AdminUsersAllEmailAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersAllEmailAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersAllEmailAsc", plan_hash=ADMIN_USERS_ALL_EMAIL_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersAllEmailAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_all_email_asc_after_commit(self, parameters: AdminUsersAllEmailAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersAllEmailAscResult]:
+        return await self.admin_users_all_email_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_contains_asc(self, parameters: AdminUsersContainsAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersContainsAsc", plan_hash=ADMIN_USERS_CONTAINS_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersContainsAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_contains_asc_after_commit(self, parameters: AdminUsersContainsAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsAscResult]:
+        return await self.admin_users_contains_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_contains_desc(self, parameters: AdminUsersContainsDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersContainsDesc", plan_hash=ADMIN_USERS_CONTAINS_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersContainsDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_contains_desc_after_commit(self, parameters: AdminUsersContainsDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersContainsDescResult]:
+        return await self.admin_users_contains_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_email_contains_created_desc(self, parameters: AdminUsersEmailContainsCreatedDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsCreatedDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEmailContainsCreatedDesc", plan_hash=ADMIN_USERS_EMAIL_CONTAINS_CREATED_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEmailContainsCreatedDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_email_contains_created_desc_after_commit(self, parameters: AdminUsersEmailContainsCreatedDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsCreatedDescResult]:
+        return await self.admin_users_email_contains_created_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_email_contains_image_asc(self, parameters: AdminUsersEmailContainsImageAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsImageAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEmailContainsImageAsc", plan_hash=ADMIN_USERS_EMAIL_CONTAINS_IMAGE_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEmailContainsImageAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_email_contains_image_asc_after_commit(self, parameters: AdminUsersEmailContainsImageAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEmailContainsImageAscResult]:
+        return await self.admin_users_email_contains_image_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_ends_with_asc(self, parameters: AdminUsersEndsWithAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEndsWithAsc", plan_hash=ADMIN_USERS_ENDS_WITH_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEndsWithAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_ends_with_asc_after_commit(self, parameters: AdminUsersEndsWithAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithAscResult]:
+        return await self.admin_users_ends_with_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_ends_with_desc(self, parameters: AdminUsersEndsWithDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersEndsWithDesc", plan_hash=ADMIN_USERS_ENDS_WITH_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersEndsWithDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_ends_with_desc_after_commit(self, parameters: AdminUsersEndsWithDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersEndsWithDescResult]:
+        return await self.admin_users_ends_with_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_starts_with_asc(self, parameters: AdminUsersStartsWithAscParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithAscResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersStartsWithAsc", plan_hash=ADMIN_USERS_STARTS_WITH_ASC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersStartsWithAscFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_starts_with_asc_after_commit(self, parameters: AdminUsersStartsWithAscParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithAscResult]:
+        return await self.admin_users_starts_with_asc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def admin_users_starts_with_desc(self, parameters: AdminUsersStartsWithDescParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithDescResult]:
+        if parameters.limit is not None and (isinstance(parameters.limit, bool) or not isinstance(parameters.limit, int) or parameters.limit < 1 or parameters.limit > 100):
+            raise ValueError("limit must be an integer from 1 through 100")
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="AdminUsersStartsWithDesc", plan_hash=ADMIN_USERS_STARTS_WITH_DESC_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": AdminUsersStartsWithDescFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def admin_users_starts_with_desc_after_commit(self, parameters: AdminUsersStartsWithDescParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[AdminUsersStartsWithDescResult]:
+        return await self.admin_users_starts_with_desc(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_account_by_id(self, parameters: FindAccountByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountById", plan_hash=FIND_ACCOUNT_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindAccountByIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_account_by_id_after_commit(self, parameters: FindAccountByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByIdResult]:
+        return await self.find_account_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_account_by_provider(self, parameters: FindAccountByProviderParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByProviderResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountByProvider", plan_hash=FIND_ACCOUNT_BY_PROVIDER_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindAccountByProviderFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_account_by_provider_after_commit(self, parameters: FindAccountByProviderParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountByProviderResult]:
+        return await self.find_account_by_provider(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_accounts_by_user_id(self, parameters: FindAccountsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountsByUserId", plan_hash=FIND_ACCOUNTS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindAccountsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_accounts_by_user_id_after_commit(self, parameters: FindAccountsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserIdResult]:
+        return await self.find_accounts_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_accounts_by_user_id_pages(self, parameters: FindAccountsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindAccountsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindAccountsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindAccountsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, after=None)
+            page = await self.find_accounts_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def find_accounts_by_user_provider(self, parameters: FindAccountsByUserProviderParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserProviderResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindAccountsByUserProvider", plan_hash=FIND_ACCOUNTS_BY_USER_PROVIDER_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindAccountsByUserProviderFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_accounts_by_user_provider_after_commit(self, parameters: FindAccountsByUserProviderParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindAccountsByUserProviderResult]:
+        return await self.find_accounts_by_user_provider(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_accounts_by_user_provider_pages(self, parameters: FindAccountsByUserProviderParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindAccountsByUserProviderResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindAccountsByUserProviderResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindAccountsByUserProviderParams(organization_id=parameters.organization_id, user_id=parameters.user_id, provider_id=parameters.provider_id, after=None)
+            page = await self.find_accounts_by_user_provider(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def find_active_sessions_by_user_id(self, parameters: FindActiveSessionsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindActiveSessionsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindActiveSessionsByUserId", plan_hash=FIND_ACTIVE_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindActiveSessionsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_active_sessions_by_user_id_after_commit(self, parameters: FindActiveSessionsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindActiveSessionsByUserIdResult]:
+        return await self.find_active_sessions_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_active_sessions_by_user_id_pages(self, parameters: FindActiveSessionsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindActiveSessionsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindActiveSessionsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindActiveSessionsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, expires_after=parameters.expires_after, after=None)
+            page = await self.find_active_sessions_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def find_expired_verification_ids(self, parameters: FindExpiredVerificationIdsParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindExpiredVerificationIdsResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindExpiredVerificationIds", plan_hash=FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindExpiredVerificationIdsFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_expired_verification_ids_after_commit(self, parameters: FindExpiredVerificationIdsParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindExpiredVerificationIdsResult]:
+        return await self.find_expired_verification_ids(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_expired_verification_ids_pages(self, parameters: FindExpiredVerificationIdsParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindExpiredVerificationIdsResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindExpiredVerificationIdsResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindExpiredVerificationIdsParams(organization_id=parameters.organization_id, expires_before=parameters.expires_before, after=None)
+            page = await self.find_expired_verification_ids(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def find_latest_verification(self, parameters: FindLatestVerificationParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindLatestVerificationResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindLatestVerification", plan_hash=FIND_LATEST_VERIFICATION_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindLatestVerificationFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_latest_verification_after_commit(self, parameters: FindLatestVerificationParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindLatestVerificationResult]:
+        return await self.find_latest_verification(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_session_by_id(self, parameters: FindSessionByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionById", plan_hash=FIND_SESSION_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionByIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_session_by_id_after_commit(self, parameters: FindSessionByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByIdResult]:
+        return await self.find_session_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_session_by_token(self, parameters: FindSessionByTokenParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByTokenResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionByToken", plan_hash=FIND_SESSION_BY_TOKEN_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionByTokenFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_session_by_token_after_commit(self, parameters: FindSessionByTokenParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionByTokenResult]:
+        return await self.find_session_by_token(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_sessions_by_token_set(self, parameters: FindSessionsByTokenSetParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionsByTokenSet", plan_hash=FIND_SESSIONS_BY_TOKEN_SET_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindSessionsByTokenSetFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_sessions_by_token_set_after_commit(self, parameters: FindSessionsByTokenSetParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetResult]:
+        return await self.find_sessions_by_token_set(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_sessions_by_user_id(self, parameters: FindSessionsByUserIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByUserIdResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindSessionsByUserId", plan_hash=FIND_SESSIONS_BY_USER_ID_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindSessionsByUserIdFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_sessions_by_user_id_after_commit(self, parameters: FindSessionsByUserIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByUserIdResult]:
+        return await self.find_sessions_by_user_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_sessions_by_user_id_pages(self, parameters: FindSessionsByUserIdParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindSessionsByUserIdResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindSessionsByUserIdResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindSessionsByUserIdParams(organization_id=parameters.organization_id, user_id=parameters.user_id, after=None)
+            page = await self.find_sessions_by_user_id(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def find_user_by_email(self, parameters: FindUserByEmailParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByEmailResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindUserByEmail", plan_hash=FIND_USER_BY_EMAIL_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+            accept_compact_result=True,
+        )
+        outcomes = {
+            "Found": FindUserByEmailFound,
+        }
+        return raw._map_value(lambda value: _decode_find_user_by_email_compact(value) if isinstance(value, dict) and "$riffdb_compact" in value else decode_variant(outcomes, value))
+
+    async def find_user_by_email_after_commit(self, parameters: FindUserByEmailParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByEmailResult]:
+        return await self.find_user_by_email(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_user_by_id(self, parameters: FindUserByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindUserById", plan_hash=FIND_USER_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindUserByIdFound,
+            "Missing": FindUserByIdMissing,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_user_by_id_after_commit(self, parameters: FindUserByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindUserByIdResult]:
+        return await self.find_user_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_verification_by_id(self, parameters: FindVerificationByIdParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationByIdResult]:
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindVerificationById", plan_hash=FIND_VERIFICATION_BY_ID_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindVerificationByIdFound,
+            "Missing": FindVerificationByIdMissing,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_verification_by_id_after_commit(self, parameters: FindVerificationByIdParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationByIdResult]:
+        return await self.find_verification_by_id(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_verifications_by_identifier(self, parameters: FindVerificationsByIdentifierParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationsByIdentifierResult]:
+        encoded_parameters = encode_record(parameters)
+        generated_cursor = parameters.after
+        if generated_cursor is not None:
+            if options.cursor is not None:
+                raise ValueError("generated cursor conflicts with query options")
+            options = QueryOptions(cursor=generated_cursor, read_after_commit=options.read_after_commit, consistency=options.consistency)
+        encoded_parameters.pop("after", None)
+        if options.read_after_commit is None and self._read_after_commit is not None:
+            options = QueryOptions(cursor=options.cursor, read_after_commit=self._read_after_commit, consistency=options.consistency)
+        raw = await self._transport._execute_named_query(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            contract_bundle_hash=CONTRACT_BUNDLE_HASH, module_hash=QUERY_MODULE_HASH,
+            query_name="FindVerificationsByIdentifier", plan_hash=FIND_VERIFICATIONS_BY_IDENTIFIER_QUERY_PLAN_HASH,
+            parameters=encoded_parameters, options=options,
+        )
+        outcomes = {
+            "Found": FindVerificationsByIdentifierFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_verifications_by_identifier_after_commit(self, parameters: FindVerificationsByIdentifierParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindVerificationsByIdentifierResult]:
+        return await self.find_verifications_by_identifier(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    async def find_verifications_by_identifier_pages(self, parameters: FindVerificationsByIdentifierParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> list[TypedQueryResult[FindVerificationsByIdentifierResult]]:
+        if isinstance(max_pages, bool) or not isinstance(max_pages, int) or max_pages < 1 or max_pages > 1024:
+            raise ValueError("max_pages must be an integer from 1 through 1024")
+        if parameters.after is not None and options.cursor is not None:
+            raise ValueError("generated cursor conflicts with query options")
+        cursor = options.cursor if options.cursor is not None else parameters.after
+        pages: list[TypedQueryResult[FindVerificationsByIdentifierResult]] = []
+        for _ in range(max_pages):
+            page_parameters = FindVerificationsByIdentifierParams(organization_id=parameters.organization_id, identifier=parameters.identifier, after=None)
+            page = await self.find_verifications_by_identifier(page_parameters, QueryOptions(cursor=cursor, read_after_commit=options.read_after_commit, consistency=options.consistency))
+            pages.append(page)
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+        return pages
+
+    async def consume_verification(self, input: ConsumeVerificationInput) -> TypedCommandResult[ConsumeVerificationOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerification", plan_hash=CONSUME_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationConsumed": ConsumeVerificationVerificationConsumed,
+            "VerificationConsumeMissing": ConsumeVerificationVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def consume_verification_batch(
+        self, inputs: Sequence[ConsumeVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationOutcome]:
+        return await self._transport._command_batch(inputs, options, self.consume_verification, progress)
+
+    async def consume_verification_set(self, input: ConsumeVerificationSetInput) -> TypedCommandResult[ConsumeVerificationSetOutcome]:
+        if not 1 <= len(input.verification_ids) <= 32:
+            raise ValueError("invalid bounded collection length for ConsumeVerificationSet.verification_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerificationSet", plan_hash=CONSUME_VERIFICATION_SET_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationSetConsumed": ConsumeVerificationSetVerificationSetConsumed,
+            "VerificationConsumeMissing": ConsumeVerificationSetVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationSetOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def consume_verification_set_batch(
+        self, inputs: Sequence[ConsumeVerificationSetInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationSetOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 32:
+                raise ValueError("invalid bounded collection length for ConsumeVerificationSet.verification_ids")
+        return await self._transport._command_batch(inputs, options, self.consume_verification_set, progress)
+
+    async def create_account(self, input: CreateAccountInput) -> TypedCommandResult[CreateAccountOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateAccount", plan_hash=CREATE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountCreated": CreateAccountAccountCreated,
+            "AccountUserMissing": CreateAccountAccountUserMissing,
+            "AccountAlreadyExists": CreateAccountAccountAlreadyExists,
+        }
+        result: TypedCommandResult[CreateAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_account_batch(
+        self, inputs: Sequence[CreateAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateAccountOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_account, progress)
+
+    async def create_oauth_user_graph(self, input: CreateOAuthUserGraphInput) -> TypedCommandResult[CreateOAuthUserGraphOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateOAuthUserGraph", plan_hash=CREATE_OAUTH_USER_GRAPH_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "OAuthUserExists": CreateOAuthUserGraphOAuthUserExists,
+            "OAuthAccountExists": CreateOAuthUserGraphOAuthAccountExists,
+            "OAuthUserGraphCreated": CreateOAuthUserGraphOAuthUserGraphCreated,
+        }
+        result: TypedCommandResult[CreateOAuthUserGraphOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_oauth_user_graph_batch(
+        self, inputs: Sequence[CreateOAuthUserGraphInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateOAuthUserGraphOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_oauth_user_graph, progress)
+
+    async def create_session(self, input: CreateSessionInput) -> TypedCommandResult[CreateSessionOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateSession", plan_hash=CREATE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionCreated": CreateSessionSessionCreated,
+            "SessionUserMissing": CreateSessionSessionUserMissing,
+            "SessionAlreadyExists": CreateSessionSessionAlreadyExists,
+        }
+        result: TypedCommandResult[CreateSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_session_batch(
+        self, inputs: Sequence[CreateSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateSessionOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_session, progress)
+
+    async def create_signup_graph(self, input: CreateSignupGraphInput) -> TypedCommandResult[CreateSignupGraphOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateSignupGraph", plan_hash=CREATE_SIGNUP_GRAPH_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SignupUserExists": CreateSignupGraphSignupUserExists,
+            "SignupGraphCreated": CreateSignupGraphSignupGraphCreated,
+            "SignupAccountExists": CreateSignupGraphSignupAccountExists,
+            "SignupSessionExists": CreateSignupGraphSignupSessionExists,
+        }
+        result: TypedCommandResult[CreateSignupGraphOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_signup_graph_batch(
+        self, inputs: Sequence[CreateSignupGraphInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateSignupGraphOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_signup_graph, progress)
+
+    async def create_user(self, input: CreateUserInput) -> TypedCommandResult[CreateUserOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateUser", plan_hash=CREATE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserCreated": CreateUserUserCreated,
+            "UserAlreadyExists": CreateUserUserAlreadyExists,
+        }
+        result: TypedCommandResult[CreateUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_user_batch(
+        self, inputs: Sequence[CreateUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateUserOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_user, progress)
+
+    async def create_verification(self, input: CreateVerificationInput) -> TypedCommandResult[CreateVerificationOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="CreateVerification", plan_hash=CREATE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationCreated": CreateVerificationVerificationCreated,
+            "VerificationAlreadyExists": CreateVerificationVerificationAlreadyExists,
+        }
+        result: TypedCommandResult[CreateVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def create_verification_batch(
+        self, inputs: Sequence[CreateVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[CreateVerificationOutcome]:
+        return await self._transport._command_batch(inputs, options, self.create_verification, progress)
+
+    async def delete_account(self, input: DeleteAccountInput) -> TypedCommandResult[DeleteAccountOutcome]:
+        if not 1 <= len(input.account_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteAccount.account_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteAccount", plan_hash=DELETE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountDeleted": DeleteAccountAccountDeleted,
+            "AccountMissing": DeleteAccountAccountMissing,
+        }
+        result: TypedCommandResult[DeleteAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def delete_account_batch(
+        self, inputs: Sequence[DeleteAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteAccountOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.account_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteAccount.account_ids")
+        return await self._transport._command_batch(inputs, options, self.delete_account, progress)
+
+    async def delete_session(self, input: DeleteSessionInput) -> TypedCommandResult[DeleteSessionOutcome]:
+        if not 1 <= len(input.session_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteSession.session_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteSession", plan_hash=DELETE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionDeleted": DeleteSessionSessionDeleted,
+            "SessionMissing": DeleteSessionSessionMissing,
+        }
+        result: TypedCommandResult[DeleteSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def delete_session_batch(
+        self, inputs: Sequence[DeleteSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteSessionOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.session_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteSession.session_ids")
+        return await self._transport._command_batch(inputs, options, self.delete_session, progress)
+
+    async def delete_user(self, input: DeleteUserInput) -> TypedCommandResult[DeleteUserOutcome]:
+        if not 1 <= len(input.user_ids) <= 1:
+            raise ValueError("invalid bounded collection length for DeleteUser.user_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteUser", plan_hash=DELETE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserDeleted": DeleteUserUserDeleted,
+            "DeleteUserMissing": DeleteUserDeleteUserMissing,
+            "DeleteUserCascadeLimitExceeded": DeleteUserDeleteUserCascadeLimitExceeded,
+        }
+        result: TypedCommandResult[DeleteUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def delete_user_batch(
+        self, inputs: Sequence[DeleteUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteUserOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.user_ids) <= 1:
+                raise ValueError("invalid bounded collection length for DeleteUser.user_ids")
+        return await self._transport._command_batch(inputs, options, self.delete_user, progress)
+
+    async def delete_verification(self, input: DeleteVerificationInput) -> TypedCommandResult[DeleteVerificationOutcome]:
+        if not 1 <= len(input.verification_ids) <= 32:
+            raise ValueError("invalid bounded collection length for DeleteVerification.verification_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="DeleteVerification", plan_hash=DELETE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationDeleted": DeleteVerificationVerificationDeleted,
+            "VerificationMissing": DeleteVerificationVerificationMissing,
+        }
+        result: TypedCommandResult[DeleteVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def delete_verification_batch(
+        self, inputs: Sequence[DeleteVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[DeleteVerificationOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 32:
+                raise ValueError("invalid bounded collection length for DeleteVerification.verification_ids")
+        return await self._transport._command_batch(inputs, options, self.delete_verification, progress)
+
+    async def update_account(self, input: UpdateAccountInput) -> TypedCommandResult[UpdateAccountOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateAccount", plan_hash=UPDATE_ACCOUNT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "AccountUpdated": UpdateAccountAccountUpdated,
+            "AccountUpdateStale": UpdateAccountAccountUpdateStale,
+            "AccountUpdateMissing": UpdateAccountAccountUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateAccountOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def update_account_batch(
+        self, inputs: Sequence[UpdateAccountInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateAccountOutcome]:
+        return await self._transport._command_batch(inputs, options, self.update_account, progress)
+
+    async def update_account_passwords(self, input: UpdateAccountPasswordsInput) -> TypedCommandResult[UpdateAccountPasswordsOutcome]:
+        if not 1 <= len(input.updates) <= 8:
+            raise ValueError("invalid bounded collection length for UpdateAccountPasswords.updates")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateAccountPasswords", plan_hash=UPDATE_ACCOUNT_PASSWORDS_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": UpdateAccountPasswordsPasswordAccountStale,
+            "PasswordAccountMissing": UpdateAccountPasswordsPasswordAccountMissing,
+            "AccountPasswordsUpdated": UpdateAccountPasswordsAccountPasswordsUpdated,
+            "PasswordProviderMismatch": UpdateAccountPasswordsPasswordProviderMismatch,
+        }
+        result: TypedCommandResult[UpdateAccountPasswordsOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def update_account_passwords_batch(
+        self, inputs: Sequence[UpdateAccountPasswordsInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateAccountPasswordsOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.updates) <= 8:
+                raise ValueError("invalid bounded collection length for UpdateAccountPasswords.updates")
+        return await self._transport._command_batch(inputs, options, self.update_account_passwords, progress)
+
+    async def update_session(self, input: UpdateSessionInput) -> TypedCommandResult[UpdateSessionOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateSession", plan_hash=UPDATE_SESSION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "SessionUpdated": UpdateSessionSessionUpdated,
+            "SessionUpdateStale": UpdateSessionSessionUpdateStale,
+            "SessionUpdateMissing": UpdateSessionSessionUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateSessionOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def update_session_batch(
+        self, inputs: Sequence[UpdateSessionInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateSessionOutcome]:
+        return await self._transport._command_batch(inputs, options, self.update_session, progress)
+
+    async def update_user(self, input: UpdateUserInput) -> TypedCommandResult[UpdateUserOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateUser", plan_hash=UPDATE_USER_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "UserUpdated": UpdateUserUserUpdated,
+            "UserUpdateStale": UpdateUserUserUpdateStale,
+            "UserUpdateMissing": UpdateUserUserUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateUserOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def update_user_batch(
+        self, inputs: Sequence[UpdateUserInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateUserOutcome]:
+        return await self._transport._command_batch(inputs, options, self.update_user, progress)
+
+    async def update_verification(self, input: UpdateVerificationInput) -> TypedCommandResult[UpdateVerificationOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateVerification", plan_hash=UPDATE_VERIFICATION_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationUpdated": UpdateVerificationVerificationUpdated,
+            "VerificationUpdateStale": UpdateVerificationVerificationUpdateStale,
+            "VerificationUpdateMissing": UpdateVerificationVerificationUpdateMissing,
+        }
+        result: TypedCommandResult[UpdateVerificationOutcome] = raw._map_outcome(lambda value: decode_variant(outcomes, value))
+        if self._track_causal_writes and result.commit_sequence is not None and result.commit_sequence > 0:
+            self._read_after_commit = result.commit_sequence if self._read_after_commit is None or result.commit_sequence > self._read_after_commit else self._read_after_commit
+        return result
+
+    async def update_verification_batch(
+        self, inputs: Sequence[UpdateVerificationInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateVerificationOutcome]:
+        return await self._transport._command_batch(inputs, options, self.update_verification, progress)