@riffdb/better-auth 0.0.0-stage → 0.2.1

package/generated/python/client.py

@@ -0,0 +1,4454 @@
+# @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] = "74fd255eefcf04f0b054dbb6c4a0bed43a7312d82f7755687c9229ee3206ddfc"
+QUERY_MODULE_HASH: Final[str] = "8dff3a38f6c0a915d7653e7571a2ef5795a89b452990d705f38fe0ac93b5ad9a"
+
+@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] = "056edbaabe43e1dc95f1f6af9838747f54d927a90d5bc9f2be045ae266d107d3"
+
+@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] = "b64d213477dd2275d98422a6c3460b0cae932dd96255fe9d565005e8afa37fc4"
+
+@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] = "57aba8cf311c301e985adc324f97b4d963a38e6efa6058a82e248854d75f2f05"
+
+@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] = "7aede9eda624f5b4eb4280ca7b8a1421466ce30091177c9abab4f125987eb4ff"
+
+@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] = "453cb6c81f506a1f0ac99bed3cc85da59176d2cb83597d5812d771683a60cb4c"
+
+@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] = "924c7acfdcf3f7970917ac611b6eafc9175ac69f735d9e1cc01414fcc6f0e696"
+
+@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] = "cab8ad8456533e4ce97388948e4f703cac6f2eebb641b83a91c3b005ece7fffb"
+
+@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] = "add0aed3dbd0caea0de2857133a857d49eb7bfc0e031d117270cc873137da5ec"
+
+@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] = "23c1561fb3956217e79d1b358be468e55c4021b887e927a4fb3c0484c92be872"
+
+@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] = "14a08df3dd8a74ea0a5622804bf0c2424086ee73eb10ce57d7df336a7d25f5ba"
+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] = "e6c4517a46d725780e79725ca3fdaba2208ef4b282d49f484121eee76c043831"
+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] = "ccdc524ca64ad667c209de25b4ce977f43b53ffdd8eb1b70fedf29fc99f27da6"
+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] = "21d13b3c30b4a4059f3c436e290d11c20f0f1d1154e05fb48ae3dd0da882526d"
+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] = "de1e5232a64a32057699b5ac21f1b43e69d755a3c143595f906fe63e16147264"
+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_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH: Final[str] = "f968271d103a76cc6b2a5496f5cceffe4cff5aa39d2a370379b518d8e7d90771"
+FIND_CREDENTIAL_ACCOUNT_SECRET_OUTPUTS: Final[tuple[tuple[str, str, str], ...]] = (
+    ("FindCredentialAccount", "Account", "access_token"),
+    ("FindCredentialAccount", "Account", "refresh_token"),
+    ("FindCredentialAccount", "Account", "id_token"),
+    ("FindCredentialAccount", "Account", "password"),
+)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindCredentialAccountParams:
+    organization_id: UUID
+    user_id: UUID
+    account_id: str
+    provider_id: str
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FindCredentialAccountFoundAccounts:
+    organization_id: UUID = field(repr=False)
+    user_id: UUID = field(repr=False)
+    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)
+    id_token: str | None = field(repr=False)
+    password: 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)
+    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 FindCredentialAccountFound:
+    accounts: tuple[FindCredentialAccountFoundAccounts, ...] = field(repr=False)
+    outcome: Literal["Found"] = field(default="Found", init=False)
+
+    def is_found(self) -> bool:
+        return True
+
+    def unwrap_found(self) -> FindCredentialAccountFound:
+        return self
+
+FindCredentialAccountResult: TypeAlias = FindCredentialAccountFound
+
+FIND_EXPIRED_VERIFICATION_IDS_QUERY_PLAN_HASH: Final[str] = "6c799850ba3b2eb3222aac85a76f40492c46de76870075b029f3b4ac897ed8b9"
+
+@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] = "b3832c0a8a316d3fcbc62b388fbe09ceb6624b55482195f7642553467cba6fcb"
+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] = "c92eb2035c0e3ca7dedbaa42a4e2efe7bc4786a65213394da7f5d3beb579a2a1"
+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] = "a8a12334a3d34c30d54be828bdcc9b9b77223303c3f9681e4a602c92341876ec"
+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] = "7e23187b537599c4c2361d34ea866b5b719f63feda0135587b5ec6afd5ce62f6"
+FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS: Final[int] = 32
+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] = "a3277546d8b0c0059b850c368ae4925000c255e69b7ff005f4b3d2ef61b504af"
+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] = "b167b8cb2fb5ce19685491b47da4e816665b840e0f0e463666f6302134472b9a"
+
+@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] = "25d4a0a77d5df64ab6187528f9fac6b205a03c33e01c9ea6b573e8316b78b924"
+
+@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] = "54f07c7eba7d51857dd6473e39304dc798bf7084ca946dfa7f0203633a5133ac"
+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] = "4c768ae1d966454e9b791cd57a6311476947b5c457020943a50bc3cfee90765b"
+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 ConsumeVerificationSnapshotInput:
+    request_id: UUID
+    organization_id: UUID
+    verification_id: UUID
+    expected_revision: Annotated[int, "u64"]
+
+CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH: Final[str] = "1a80a36f34b4699c972fc1e6f48cad3f85da54e202831a6986aea084db09788b"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSnapshotVerificationConsumed:
+    outcome: Literal["VerificationConsumed"] = field(default="VerificationConsumed", init=False)
+
+    def is_verification_consumed(self) -> bool:
+        return True
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSnapshotVerificationConsumeStale:
+    outcome: Literal["VerificationConsumeStale"] = field(default="VerificationConsumeStale", init=False)
+
+    def is_verification_consumed(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return True
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ConsumeVerificationSnapshotVerificationConsumeMissing:
+    outcome: Literal["VerificationConsumeMissing"] = field(default="VerificationConsumeMissing", init=False)
+
+    def is_verification_consumed(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return True
+
+ConsumeVerificationSnapshotOutcome: TypeAlias = ConsumeVerificationSnapshotVerificationConsumed | ConsumeVerificationSnapshotVerificationConsumeStale | ConsumeVerificationSnapshotVerificationConsumeMissing
+
+@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 ResetCredentialPasswordInput:
+    user_id: UUID
+    password: str
+    account_id: UUID
+    request_id: UUID
+    updated_at: Timestamp
+    organization_id: UUID
+    account_revision: Annotated[int, "u64"]
+    verification_ids: tuple[UUID, ...]
+    external_account_id: str
+    verification_revision: Annotated[int, "u64"]
+
+RESET_CREDENTIAL_PASSWORD_PLAN_HASH: Final[str] = "ed87f267831fb0823b0e9bbf51d7b302a715a95c0cea69faf7922c0e4e7f375e"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordPasswordAccountStale:
+    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_credential_password_reset(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordPasswordAccountMissing:
+    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_credential_password_reset(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordCredentialPasswordReset:
+    outcome: Literal["CredentialPasswordReset"] = field(default="CredentialPasswordReset", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_credential_password_reset(self) -> bool:
+        return True
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordPasswordProviderMismatch:
+    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_credential_password_reset(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return True
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordVerificationConsumeStale:
+    outcome: Literal["VerificationConsumeStale"] = field(default="VerificationConsumeStale", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_credential_password_reset(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return True
+
+    def is_verification_consume_missing(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ResetCredentialPasswordVerificationConsumeMissing:
+    outcome: Literal["VerificationConsumeMissing"] = field(default="VerificationConsumeMissing", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_credential_password_reset(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_verification_consume_stale(self) -> bool:
+        return False
+
+    def is_verification_consume_missing(self) -> bool:
+        return True
+
+ResetCredentialPasswordOutcome: TypeAlias = ResetCredentialPasswordPasswordAccountStale | ResetCredentialPasswordPasswordAccountMissing | ResetCredentialPasswordCredentialPasswordReset | ResetCredentialPasswordPasswordProviderMismatch | ResetCredentialPasswordVerificationConsumeStale | ResetCredentialPasswordVerificationConsumeMissing
+
+@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 UpdateCredentialPasswordInput:
+    user_id: UUID
+    password: str
+    account_id: UUID
+    request_id: UUID
+    updated_at: Timestamp
+    organization_id: UUID
+    expected_revision: Annotated[int, "u64"]
+    external_account_id: str
+
+UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH: Final[str] = "08781a68739c705ab6ffe51a0de547605e1a7dd2fd2b8075445d40db923d1f15"
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateCredentialPasswordPasswordAccountStale:
+    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_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_credential_password_updated(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateCredentialPasswordPasswordAccountMissing:
+    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_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_credential_password_updated(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateCredentialPasswordPasswordProviderMismatch:
+    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_password_provider_mismatch(self) -> bool:
+        return True
+
+    def is_credential_password_updated(self) -> bool:
+        return False
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UpdateCredentialPasswordCredentialPasswordUpdated:
+    outcome: Literal["CredentialPasswordUpdated"] = field(default="CredentialPasswordUpdated", init=False)
+
+    def is_password_account_stale(self) -> bool:
+        return False
+
+    def is_password_account_missing(self) -> bool:
+        return False
+
+    def is_password_provider_mismatch(self) -> bool:
+        return False
+
+    def is_credential_password_updated(self) -> bool:
+        return True
+
+UpdateCredentialPasswordOutcome: TypeAlias = UpdateCredentialPasswordPasswordAccountStale | UpdateCredentialPasswordPasswordAccountMissing | UpdateCredentialPasswordPasswordProviderMismatch | UpdateCredentialPasswordCredentialPasswordUpdated
+
+@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_credential_account(self, parameters: FindCredentialAccountParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindCredentialAccountResult]:
+        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="FindCredentialAccount", plan_hash=FIND_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindCredentialAccountFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    def find_credential_account_after_commit(self, parameters: FindCredentialAccountParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindCredentialAccountResult]:
+        return self.find_credential_account(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    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_token_set_all(self, parameters: FindSessionsByTokenSetParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetFound]:
+        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 options.cursor is not None:
+            raise ValueError("find_sessions_by_token_set_all does not accept an initial cursor")
+        items = tuple(dict.fromkeys(parameters.tokens))
+        if not items:
+            raise ValueError("tokens must contain at least 1 item")
+        pinned_head = options.read_after_commit if options.read_after_commit is not None else self._read_after_commit
+        highest_head = 0
+        merged: list[FindSessionsByTokenSetFoundSessions] = []
+        latest_page: TypedQueryResult[FindSessionsByTokenSetResult] | None = None
+        pages_remaining = max_pages
+        for offset in range(0, len(items), FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS):
+            chunk = items[offset:offset + FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS]
+            chunk_cursor: str | None = None
+            while True:
+                if pages_remaining < 1:
+                    raise ValueError("find_sessions_by_token_set_all exceeded max_pages (1..=1024)")
+                pages_remaining -= 1
+                chunk_parameters = FindSessionsByTokenSetParams(organization_id=parameters.organization_id, tokens=chunk)
+                page = self.find_sessions_by_token_set(chunk_parameters, QueryOptions(cursor=chunk_cursor, read_after_commit=pinned_head, consistency=options.consistency))
+                found = page.value.unwrap_found()
+                merged.extend(found.sessions)
+                latest_page = page
+                if page.application_head > highest_head:
+                    highest_head = page.application_head
+                if pinned_head is None or page.application_head > pinned_head:
+                    pinned_head = page.application_head
+                if not page.next_cursor:
+                    break
+                chunk_cursor = page.next_cursor
+        assert latest_page is not None
+        return TypedQueryResult(identity=latest_page.identity, value=FindSessionsByTokenSetFound(sessions=tuple(merged)), application_head=highest_head, next_cursor=None)
+
+    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 consume_verification_snapshot(self, input: ConsumeVerificationSnapshotInput) -> TypedCommandResult[ConsumeVerificationSnapshotOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerificationSnapshot", plan_hash=CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationConsumed": ConsumeVerificationSnapshotVerificationConsumed,
+            "VerificationConsumeStale": ConsumeVerificationSnapshotVerificationConsumeStale,
+            "VerificationConsumeMissing": ConsumeVerificationSnapshotVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationSnapshotOutcome] = 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_snapshot_batch(
+        self, inputs: Sequence[ConsumeVerificationSnapshotInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationSnapshotOutcome]:
+        return self._transport._command_batch(inputs, options, self.consume_verification_snapshot, 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 reset_credential_password(self, input: ResetCredentialPasswordInput) -> TypedCommandResult[ResetCredentialPasswordOutcome]:
+        if not 1 <= len(input.verification_ids) <= 1:
+            raise ValueError("invalid bounded collection length for ResetCredentialPassword.verification_ids")
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ResetCredentialPassword", plan_hash=RESET_CREDENTIAL_PASSWORD_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": ResetCredentialPasswordPasswordAccountStale,
+            "PasswordAccountMissing": ResetCredentialPasswordPasswordAccountMissing,
+            "CredentialPasswordReset": ResetCredentialPasswordCredentialPasswordReset,
+            "PasswordProviderMismatch": ResetCredentialPasswordPasswordProviderMismatch,
+            "VerificationConsumeStale": ResetCredentialPasswordVerificationConsumeStale,
+            "VerificationConsumeMissing": ResetCredentialPasswordVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ResetCredentialPasswordOutcome] = 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 reset_credential_password_batch(
+        self, inputs: Sequence[ResetCredentialPasswordInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ResetCredentialPasswordOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 1:
+                raise ValueError("invalid bounded collection length for ResetCredentialPassword.verification_ids")
+        return self._transport._command_batch(inputs, options, self.reset_credential_password, 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_credential_password(self, input: UpdateCredentialPasswordInput) -> TypedCommandResult[UpdateCredentialPasswordOutcome]:
+        raw = self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateCredentialPassword", plan_hash=UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": UpdateCredentialPasswordPasswordAccountStale,
+            "PasswordAccountMissing": UpdateCredentialPasswordPasswordAccountMissing,
+            "PasswordProviderMismatch": UpdateCredentialPasswordPasswordProviderMismatch,
+            "CredentialPasswordUpdated": UpdateCredentialPasswordCredentialPasswordUpdated,
+        }
+        result: TypedCommandResult[UpdateCredentialPasswordOutcome] = 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_credential_password_batch(
+        self, inputs: Sequence[UpdateCredentialPasswordInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateCredentialPasswordOutcome]:
+        return self._transport._command_batch(inputs, options, self.update_credential_password, 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_credential_account(self, parameters: FindCredentialAccountParams, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindCredentialAccountResult]:
+        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="FindCredentialAccount", plan_hash=FIND_CREDENTIAL_ACCOUNT_QUERY_PLAN_HASH,
+            parameters=encode_record(parameters), options=options,
+        )
+        outcomes = {
+            "Found": FindCredentialAccountFound,
+        }
+        return raw._map_value(lambda value: decode_variant(outcomes, value))
+
+    async def find_credential_account_after_commit(self, parameters: FindCredentialAccountParams, commit_sequence: int, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindCredentialAccountResult]:
+        return await self.find_credential_account(parameters, QueryOptions(cursor=options.cursor, read_after_commit=commit_sequence, consistency=options.consistency))
+
+    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_token_set_all(self, parameters: FindSessionsByTokenSetParams, max_pages: int = 64, options: QueryOptions = QueryOptions()) -> TypedQueryResult[FindSessionsByTokenSetFound]:
+        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 options.cursor is not None:
+            raise ValueError("find_sessions_by_token_set_all does not accept an initial cursor")
+        items = tuple(dict.fromkeys(parameters.tokens))
+        if not items:
+            raise ValueError("tokens must contain at least 1 item")
+        pinned_head = options.read_after_commit if options.read_after_commit is not None else self._read_after_commit
+        highest_head = 0
+        merged: list[FindSessionsByTokenSetFoundSessions] = []
+        latest_page: TypedQueryResult[FindSessionsByTokenSetResult] | None = None
+        pages_remaining = max_pages
+        for offset in range(0, len(items), FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS):
+            chunk = items[offset:offset + FIND_SESSIONS_BY_TOKEN_SET_TOKENS_MAX_ITEMS]
+            chunk_cursor: str | None = None
+            while True:
+                if pages_remaining < 1:
+                    raise ValueError("find_sessions_by_token_set_all exceeded max_pages (1..=1024)")
+                pages_remaining -= 1
+                chunk_parameters = FindSessionsByTokenSetParams(organization_id=parameters.organization_id, tokens=chunk)
+                page = await self.find_sessions_by_token_set(chunk_parameters, QueryOptions(cursor=chunk_cursor, read_after_commit=pinned_head, consistency=options.consistency))
+                found = page.value.unwrap_found()
+                merged.extend(found.sessions)
+                latest_page = page
+                if page.application_head > highest_head:
+                    highest_head = page.application_head
+                if pinned_head is None or page.application_head > pinned_head:
+                    pinned_head = page.application_head
+                if not page.next_cursor:
+                    break
+                chunk_cursor = page.next_cursor
+        assert latest_page is not None
+        return TypedQueryResult(identity=latest_page.identity, value=FindSessionsByTokenSetFound(sessions=tuple(merged)), application_head=highest_head, next_cursor=None)
+
+    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 consume_verification_snapshot(self, input: ConsumeVerificationSnapshotInput) -> TypedCommandResult[ConsumeVerificationSnapshotOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ConsumeVerificationSnapshot", plan_hash=CONSUME_VERIFICATION_SNAPSHOT_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "VerificationConsumed": ConsumeVerificationSnapshotVerificationConsumed,
+            "VerificationConsumeStale": ConsumeVerificationSnapshotVerificationConsumeStale,
+            "VerificationConsumeMissing": ConsumeVerificationSnapshotVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ConsumeVerificationSnapshotOutcome] = 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_snapshot_batch(
+        self, inputs: Sequence[ConsumeVerificationSnapshotInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ConsumeVerificationSnapshotOutcome]:
+        return await self._transport._command_batch(inputs, options, self.consume_verification_snapshot, 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 reset_credential_password(self, input: ResetCredentialPasswordInput) -> TypedCommandResult[ResetCredentialPasswordOutcome]:
+        if not 1 <= len(input.verification_ids) <= 1:
+            raise ValueError("invalid bounded collection length for ResetCredentialPassword.verification_ids")
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="ResetCredentialPassword", plan_hash=RESET_CREDENTIAL_PASSWORD_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": ResetCredentialPasswordPasswordAccountStale,
+            "PasswordAccountMissing": ResetCredentialPasswordPasswordAccountMissing,
+            "CredentialPasswordReset": ResetCredentialPasswordCredentialPasswordReset,
+            "PasswordProviderMismatch": ResetCredentialPasswordPasswordProviderMismatch,
+            "VerificationConsumeStale": ResetCredentialPasswordVerificationConsumeStale,
+            "VerificationConsumeMissing": ResetCredentialPasswordVerificationConsumeMissing,
+        }
+        result: TypedCommandResult[ResetCredentialPasswordOutcome] = 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 reset_credential_password_batch(
+        self, inputs: Sequence[ResetCredentialPasswordInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[ResetCredentialPasswordOutcome]:
+        for input in inputs:
+            if not 1 <= len(input.verification_ids) <= 1:
+                raise ValueError("invalid bounded collection length for ResetCredentialPassword.verification_ids")
+        return await self._transport._command_batch(inputs, options, self.reset_credential_password, 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_credential_password(self, input: UpdateCredentialPasswordInput) -> TypedCommandResult[UpdateCredentialPasswordOutcome]:
+        raw = await self._transport._execute_command(
+            contract_lineage=CONTRACT_LINEAGE, contract_version=CONTRACT_VERSION,
+            command_name="UpdateCredentialPassword", plan_hash=UPDATE_CREDENTIAL_PASSWORD_PLAN_HASH,
+            input=encode_record(input), attempts=self._command_attempts,
+        )
+        outcomes = {
+            "PasswordAccountStale": UpdateCredentialPasswordPasswordAccountStale,
+            "PasswordAccountMissing": UpdateCredentialPasswordPasswordAccountMissing,
+            "PasswordProviderMismatch": UpdateCredentialPasswordPasswordProviderMismatch,
+            "CredentialPasswordUpdated": UpdateCredentialPasswordCredentialPasswordUpdated,
+        }
+        result: TypedCommandResult[UpdateCredentialPasswordOutcome] = 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_credential_password_batch(
+        self, inputs: Sequence[UpdateCredentialPasswordInput], options: CommandBatchOptions,
+        progress: Callable[[CommandBatchProgress], None] | None = None,
+    ) -> CommandBatchResult[UpdateCredentialPasswordOutcome]:
+        return await self._transport._command_batch(inputs, options, self.update_credential_password, 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)