# Auto-regenerated by scripts/sdk-public-api.sh — see CONTRIBUTING.md.
# Captures the public API surface; CI fails on drift.

=== account/__init__.py ===
class AuthContext
    license_key: str
    order_id: str
    email: str
    device_id: str
class AccountNamespace
    branding: AccountBranding
    preferences: AccountPreferences
    cases: AccountCases
    email: AccountEmail
    reference_data: AccountReferenceData
    def close(self) -> None

=== account/branding.py ===
class BrandingDetail
    imo_name: str
    imo_logo: str
    primary_color: str
    nav_color: str
    bg_color: str
    button_color: str
    active_button_color: str
    header_text_color: str
    hide_affiliate_leads: bool
    prevent_product_selection: bool
    default_settings: str
class BrandingLookupRequest
    source: str
class AccountBranding
    def lookup(self, request: BrandingLookupRequest | None) -> BrandingDetail

=== account/case_crypto.py ===
def system_random_bytes(n: int) -> bytes
class CaseEnvelope
    ciphertext: str
    iv: str
    tag: str
class EncryptedCase
    envelope: CaseEnvelope
    key_fragment: str
class CaseDecryptError(ValueError)
def encrypt_case(product: str, payload: Any, random_bytes: RandomBytes | None) -> EncryptedCase
def decrypt_case(product: str, envelope: CaseEnvelope, key_fragment: str) -> Any

=== account/case_link.py ===
DEFAULT_CASE_VIEWER_BASE_URL = ...
class ParsedLink
    code: str
    key_fragment: str
def assemble_link(viewer_base_url: str, code: str, key_fragment: str) -> str
def parse_link(link: str) -> ParsedLink

=== account/cases.py ===
class CaseCreateRequest
    input: dict[str, Any] | str
    results: Any
    products: tuple[str, ...]
class CaseCreateResult
    hash: str
    url: str
    readonly: bool
    created_at: str
class CaseSummary
    hash: str
    url: str
    readonly: bool
    created_at: str
    input: Any
    results: Any
    products: tuple[str, ...]
class CaseEmailRequest
    case_id: str
    to: str
class CaseEmailResult
    queued: bool
class CaseShareRequest
    product: str
    payload: Any
class CaseShareResult
    id: str
    link: str
class CaseOpenResult
    product: str
    payload: Any
class AccountCases
    def create(self, request: CaseCreateRequest) -> CaseCreateResult
    def get(self, case_id: str) -> CaseSummary
    def list(self) -> tuple[CaseSummary, ...]
    def email(self, request: CaseEmailRequest) -> CaseEmailResult
    def share(self, request: CaseShareRequest) -> CaseShareResult
    def open(self, link: str) -> CaseOpenResult

=== account/email.py ===
class EmailAttachment
    filename: str
    content: str
class EmailEnqueueRequest
    to: str | tuple[str, ...]
    subject: str
    body: str
    attachments: tuple[EmailAttachment, ...]
class EmailEnqueueResult
    status: Literal['queued']
class AccountEmail
    def enqueue(self, request: EmailEnqueueRequest) -> EmailEnqueueResult

=== account/preferences.py ===
class PreferencesLookupRequest
    scope: str
class PreferencesLookupResult
    prefs: PreferencesDocument
class PreferencesSetRequest
    scope: str
    prefs: PreferencesDocument
class PreferencesSetResult
    ok: bool
class AccountPreferences
    def lookup(self, scope: str) -> PreferencesLookupResult
    def set(self, scope: str, prefs: PreferencesDocument) -> PreferencesSetResult

=== account/reference_data.py ===
class ReferenceDataRequest
    scope: str
    dataset: str
    payload: dict[str, Any] | None
class AccountReferenceData
    def get(self, scope: str, *, dataset: str, payload: dict[str, Any] | None) -> ReferenceDataResult

=== catalog/carriers.py ===
class ProductCarrierMetadata
    display_name: str
    products: tuple[Product, ...]
    states: tuple[str, ...]

=== catalog/conditions.py ===
class ConditionCategoryMetadata
    display_name: str
    conditions: tuple[str, ...]

=== catalog/errors.py ===
class ErrorCode(str, Enum)
ErrorAdviceCodes: dict[str, str]
ErrorDocUrls: dict[str, str]

=== catalog/medications.py ===
class MedicationUseMetadata
    display_name: str
    medications: tuple[str, ...]

=== catalog/products.py ===
class Product
    id: str
    name: str
    product_class: str
    carrier: str

=== catalog/scopes.py ===
class Scope(str, Enum)
ScopeDescriptions: dict[str, str]

=== catalog/sign_events.py ===
class SignEvent(str, Enum)
SignEventLabels: dict[str, str]

=== catalog/states.py ===
class State(str, Enum)
class StateMetadata
    abbreviation: str
    name: str
    is_territory: bool

=== core/auth.py ===
class BearerAuth
    token: str
    def is_test(self) -> bool
    def headers(self) -> dict[str, str]
class LicenseAuth
    keycode: str
    email: str
class SessionAuth
    session_id: str
    session_secret: str

=== core/bootstrap.py ===
class BootstrapInput
    keycode: str
    email: str
    license_key: str
    device_id: str
    method: str
    path: str
    timestamp: int
class BootstrapSignature
    serialized_body: str
    canonical: str
    hex: str
    header: str
def build_bootstrap_signature(inp: BootstrapInput) -> BootstrapSignature

=== core/constants.py ===
class ErrorCode(str, Enum)
class UsState(str, Enum)
ProductLabels: Final

=== core/credential_store.py ===
class CredentialStore(Protocol)
    def get(self, key: str) -> str | None
    def set(self, key: str, value: str) -> None
    def remove(self, key: str) -> None
class CredentialKeys
    DEVICE_ID: Final[str]
    LICENSE_KEY: Final[str]
    ORDER_ID: Final[str]
CREDENTIAL_KEYS: Final[CredentialKeys]
class InMemoryCredentialStore
    def get(self, key: str) -> str | None
    def set(self, key: str, value: str) -> None
    def remove(self, key: str) -> None
def in_memory_credential_store() -> CredentialStore
def from_mapping(*, getter: Callable[[str], str | None], setter: Callable[[str, str], None], remover: Callable[[str], None]) -> CredentialStore

=== core/debug.py ===
class DebugLogger
    def log_request(self, method: str, url: str, headers: Mapping[str, str], body: str | None, *, attempt: int) -> None
    def log_response(self, method: str, url: str, status: int, headers: Mapping[str, str], body: str | None, *, attempt: int) -> None
def redact_headers(headers: Mapping[str, str]) -> dict[str, str]
def redact_body_string(body: str | None) -> str | None

=== core/env.py ===
class EnvReader(Protocol)
    def get(self, key: str) -> str | None
class OsEnvReader
    def get(self, key: str) -> str | None
def default_env() -> EnvReader
class IsaConfigError(Exception)
def require_env(env: EnvReader, key: str, *, factory_name: str) -> str

=== core/envelope.py ===
T = ...
class RawResponse
    status: int
    url: str
    headers: Mapping[str, str]
class Envelope(Generic[T])
    data: T
    request_id: str
    idempotency_key: str
    livemode: bool
    retry_attempts: int
def extract_envelope_fields(raw: Mapping[str, Any], *, idempotency_key_sent: str | None, retry_attempts: int) -> tuple[str, str, bool, int]

=== core/errors.py ===
LICENSE_ERROR_CODES: Final[frozenset[str]]
PREQUALIFY_ERROR_CODES: Final[frozenset[str]]
class ISAError(Exception)
    code: str
class IsaIdempotencyConflictError(IsaApiError)
class LicenseError(ISAError)
class PrequalifyError(ISAError)
class ValidationError(ISAError)
class AuthError(ISAError)
class RateLimitError(ISAError)
class IsaPermissionError(ISAError)
class IsaTransportError(ISAError)
LEGACY_ERR_MAP: Final[dict[str, str]]
def from_http_response(status: int, body: str, *, request_id: str | None, retry_after_seconds: float | None) -> ISAError
def from_problem_details(problem: dict[str, Any], *, http_status: int | None, request_id: str | None) -> ISAError

=== core/idempotency.py ===
def generate_idempotency_key() -> str

=== core/json_response.py ===
def dataset_items_from_body(body: str) -> list[Any]
def inner_data_object(body: str, *, context: str) -> dict[str, Any]
def inner_data_with_request_id(body: str, *, context: str) -> tuple[dict[str, Any], str]

=== core/license_hmac.py ===
def system_license_clock() -> int
def strip_quotes(value: str) -> str
def build_license_header(license_key: str, order_id: str, email: str) -> str
def compute_device_signature(body: str, device_id: str) -> str
class LicenseHMACHeaders
    authorization: str
    x_device_id: str
    x_device_signature: str
    x_license_method: str
    x_license_uri: str
    x_license_timestamp: str
    def as_dict(self) -> dict[str, str]
def build_license_hmac_headers(*, license_key: str, order_id: str, email: str, method: str, request_uri: str, body: str, device_id: str, clock: LicenseClock | None) -> LicenseHMACHeaders

=== core/session.py ===
class Session
    session_id: str
    session_secret: str
    expires_at: datetime
class ExchangeInput
    keycode: str
    email: str
    license_key: str
    device_id: str
class SessionExchangeError(RuntimeError)
class SessionStore
    def bootstrap_count(self) -> int
    def current_secret(self) -> Session | None
    def bootstrap(self) -> Session
    def invalidate(self) -> None
    def on_activity(self) -> None
class SessionInterceptor
    def request(self, method: str, url: str, *, headers: dict[str, str], body: str | None) -> TransportResponse

=== core/sign_request.py ===
def format_timestamp(now: datetime) -> str
def canonical_string(method: str, path: str, body: bytes | str, timestamp: str, session_id: str) -> str
class SignedHeaders
    authorization: str
    isa_session_id: str
    isa_timestamp: str
    isa_signature: str
    def as_dict(self) -> dict[str, str]
def sign_request(*, method: str, path: str, body: bytes | str, session_id: str, session_secret: str, clock: SignClock | None) -> SignedHeaders

=== core/transport.py ===
class TransportResponse
    status: int
    body: str
    headers: dict[str, str]
    def request_id(self) -> str | None
class Transport(Protocol)
    def request(self, method: str, url: str, *, headers: dict[str, str], body: str | None) -> TransportResponse
class HttpTransport
    def request(self, method: str, url: str, *, headers: dict[str, str], body: str | None) -> TransportResponse
    def close(self) -> None
def raise_for_status(response: TransportResponse) -> None

=== core/value_types.py ===
class Money
    amount_minor: int
    currency: str
    def to_major(self) -> Decimal
class Email
    value: str
class Url
    value: str

=== core/wire.py ===
def applicant_to_wire_dict(applicant: Applicant) -> dict[str, Any]
def load_json_value(body: str, *, context: str) -> Any
def load_json_object(body: str, *, context: str) -> dict[str, Any]
def request_id_from_envelope(raw: dict[str, Any]) -> str

=== isa.py ===
class Isa
    def with_bearer(cls, token: str | None, *, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None, case_storage: CaseStorage | None, dataset_bundle_fetcher: Callable[[], Any] | None) -> Isa
    def with_license(cls, keycode: str | None, email: str | None, *, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None, credential_store: CredentialStore | None, license_clock: LicenseClock | None, api_version: Mapping[str, str] | None, case_storage: CaseStorage | None, dataset_bundle_fetcher: Callable[[], Any] | None) -> Isa
    def with_keycode(cls, keycode: str | None, email: str | None, *, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None, credential_store: CredentialStore | None, license_clock: LicenseClock | None, api_version: Mapping[str, str] | None, case_storage: CaseStorage | None, dataset_bundle_fetcher: Callable[[], Any] | None, autocorrector: Any | None, match_algorithm: Any | None, autocomplete_algorithm: Any | None) -> Isa
    def for_form(cls, form_token: str, *, base_url: str, timeout: float, transport: Transport | None) -> Isa
    def authenticate(cls, *, token: str | None, keycode: str | None, email: str | None, form_token: str | None, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None, credential_store: CredentialStore | None, license_clock: LicenseClock | None) -> Isa
    def create(cls, options: IsaCreateOptions | None, *, auth: IsaAuthSupplier | None, engine: IsaEngine | None, timeout: float | None, api_version: IsaApiVersion | None, client_version: str | None, transport: Transport | None, env: EnvReader | None, credential_store: CredentialStore | None, license_clock: LicenseClock | None) -> Isa
    def with_session(cls, *, session_id: str | None, session_secret: str | None, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None) -> Isa
    def from_env(cls, *, base_url: str, timeout: float, transport: Transport | None, env: EnvReader | None, credential_store: CredentialStore | None) -> Isa
    def account(self) -> AccountNamespace
    def on_license_refreshed(self, listener: LicenseRefreshedListener) -> Callable[[], None]
    def close(self) -> None
class ZyinsNamespace
    prequalify: _PrequalifyV3Callable
    quote: _QuoteV3Callable
    def set_dataset_bundle(self, bundle: DatasetBundleV3) -> None
    def license(self) -> LicenseFacade
    def cases(self) -> Any
    def autocorrector(self) -> Any
    def matcher(self) -> Any
    def autocomplete(self) -> Any

=== proxy/__init__.py ===
class ProxyNamespace
    def call(self, *, integration_uuid: str | None, integration_id: int | None, params: Any, method: str, idempotency_key: str | None, clock: Callable[[], Any] | None, uuid_factory: Callable[[], str] | None, transport: Transport | None, timeout: float) -> Any

=== proxy/call.py ===
DEFAULT_PROXY_ORIGIN = ...
DEFAULT_PROXY_TIMEOUT_SECONDS = ...
class SessionBinding
    session_id: str
    session_secret: str
    proxy_origin: str
def call(binding: SessionBinding, *, integration_uuid: str | None, integration_id: int | None, params: Any, method: str, idempotency_key: str | None, clock: SignClock | None, uuid_factory: Callable[[], str] | None, transport: Transport | None, timeout: float) -> Any
def require_session_binding(session_id: str | None, session_secret: str | None, *, proxy_origin: str) -> SessionBinding

=== rapidsign/__init__.py ===
class RapidsignNamespace

=== webhooks.py ===
class WebhooksNamespace
    def verify(self, *args, **kwargs) -> None

=== zyins/account_namespaces.py ===
class BrandingSubClient
    def lookup(self) -> BrandingDetail
class PreferencesSubClient
    def lookup(self) -> PreferencesResult
    def set(self, input: PreferencesSetInput, *, idempotency_key: str | None) -> PreferencesResult
class CasesSubClient
    def create(self, input: CaseCreateInput, *, idempotency_key: str | None) -> CaseCreateResult
    def share(self, input: CaseCreateInput, *, idempotency_key: str | None) -> CaseCreateResult
    def email(self, input: EmailEnqueueInput, *, idempotency_key: str | None) -> EmailEnqueueResult
class EmailSubClient
    def enqueue(self, input: EmailEnqueueInput, *, idempotency_key: str | None) -> EmailEnqueueResult

=== zyins/applicant.py ===
class Sex(str, Enum)
def sex_wire_code(sex: Sex) -> str
class NicotineDuration(str, Enum)
class NicotineProductUsage(BaseModel)
    type: str
    frequency: str
class NicotineUsageInput(BaseModel)
    last_used: NicotineDuration
    product_usage: tuple[NicotineProductUsage, ...]
class NicotineUsage(str, Enum)
class Medication(BaseModel)
    name: str
    use: str
    first_fill: str
    last_fill: str
class Condition(BaseModel)
    name: str
    was_diagnosed: str
    last_treatment: str
class Applicant(BaseModel)
    dob: str
    sex: Sex
    height_inches: int
    weight_pounds: int
    state: State | str
    zip: str | None
    nicotine_use: NicotineUsageInput | NicotineUsage
    medications: tuple[Medication, ...]
    conditions: tuple[Condition, ...]

=== zyins/branding.py ===
class BrandingDetail(BaseModel)
    imo_name: str
    imo_logo: str
    nav_color: str
    main_color: str
    button_color: str
    active_button_color: str
    bg_color: str
    header_text_color: str
    hide_affiliate_leads: bool
    prevent_product_selection: bool
    default_settings: str
def parse_lookup_response(raw: str) -> BrandingDetail

=== zyins/bundled_api_versions.py ===
BUNDLED_API_VERSIONS: Final[Mapping[str, str]]
def resolve_api_version(override: Mapping[str, str] | None, surface: str) -> str

=== zyins/cases/__init__.py ===
class CaseCreateInput(BaseModel)
    input: dict[str, Any] | str
    results: Any
    products: list[str]
    def to_wire_body(self) -> str
class CaseCreateResult(BaseModel)
    object: str
    hash: str
    url: str
    readonly: bool
    created_at: str
def parse_create_response(raw: str) -> CaseCreateResult
class EmailEnqueueInput(BaseModel)
    to: str
    subject: str
    body_html: str
    attachment_filename: str
    attachment_content: str
    def to_wire_body(self) -> str
class EmailEnqueueResult(BaseModel)
    enqueue_id: str
def parse_email_response(raw: str) -> EmailEnqueueResult
class CasesFacade
    def save(self, record: CaseRecord) -> PutResult
    def recall(self, id: str, recall_token: str | None) -> CaseRecord | None

=== zyins/cases/storage.py ===
class CaseRecord
    payload: Any
    product: str
    id: str | None
    metadata: dict[str, Any]
class PutResult
    id: str
    recall_token: str | None
class CaseStorage(Protocol)
    def put(self, record: CaseRecord) -> PutResult
    def get(self, id: str, recall_token: str | None) -> CaseRecord | None

=== zyins/cases/zero_knowledge.py ===
class CaseDecryptError(ValueError)
class ZeroKnowledgeCaseStorage(CaseStorage)
    def put(self, record: CaseRecord) -> PutResult
    def get(self, id: str, recall_token: str | None) -> CaseRecord | None
    def delete(self, id: str) -> None

=== zyins/client.py ===
DEFAULT_BASE_URL = ...
DEFAULT_TIMEOUT_SECONDS = ...
DEFAULT_VERSION_HEADER = ...
class ZyInsClient
    def close(self) -> None
class PrequalifySubClient
    def run(self, input: PrequalifyInput, *, idempotency_key: str | None) -> PrequalifyResult
class QuoteSubClient
    def run(self, input: QuoteInput, *, idempotency_key: str | None) -> QuoteResult
class DatasetsSubClient
    def list(self) -> tuple[Dataset, ...]
    def get(self, id: str) -> Dataset
class ReferenceDataSubClient
    def get(self, kind: str, **params) -> ReferenceDataResponse
class UsageSubClient
    def summary(self, period: str) -> UsageSummary
class LicenseSubClient
    def check(self, input: LicenseCheckInput, *, idempotency_key: str | None) -> LicenseCheckResult
    def deactivate(self, input: LicenseDeactivateInput, *, idempotency_key: str | None) -> LicenseDeactivateResult
class HealthSubClient
    def get_readiness(self) -> ReadinessResult
class CaseSubClient
    def email(self, input: dict[str, Any], *, idempotency_key: str | None) -> dict[str, Any]

=== zyins/coverage.py ===
class CoverageType(str, Enum)
class QuoteType(str, Enum)
class Coverage(BaseModel)
    type: CoverageType
    amount: int
    amounts: tuple[int, ...]
    FACE_VALUE: ClassVar[CoverageType]
    MONTHLY_BUDGET: ClassVar[CoverageType]
    def face_value(cls, amount: int) -> Coverage
    def monthly_budget(cls, amount: int) -> Coverage
    def face_values(cls, amounts: Sequence[int]) -> Coverage
    def monthly_budgets(cls, amounts: Sequence[int]) -> Coverage
    def is_face_value(self) -> bool
    def is_monthly_budget(self) -> bool
    def is_multi(self) -> bool

=== zyins/credential_state.py ===
class LicenseCredentialSnapshot
    keycode: str
    email: str
    device_id: str
    license_key: str
    order_id: str
class LicenseRefreshedEvent
    license_key: str
    device_id: str
    email: str
    order_id: str
class IsaCredentialState
    def auth(self) -> AuthContext
    def snapshot(self) -> LicenseCredentialSnapshot
    def on_license_refreshed(self, listener: LicenseRefreshedListener) -> Callable[[], None]
    def refresh_license_key(self, license_key: str) -> None
    def clear_license_key(self) -> None
def mint_device_id() -> str
def load_or_mint_device_id(store: CredentialStore) -> str

=== zyins/datasets.py ===
class Dataset(BaseModel)
    id: str
    name: str
    version: str
    description: str
    record_count: int
def parse_dataset_list(body: str) -> tuple[Dataset, ...]
def parse_dataset(body: str) -> Dataset

=== zyins/datasets_v3.py ===
class DatasetCategory(str, Enum)
class ReferenceEntity
    id: str
    name: str
class ConditionRow
    id: str
    name: str
    treated_with: Sequence[MedicationRelation]
class MedicationRow
    id: str
    name: str
    used_for: Sequence[ConditionRelation]
class MedicationRelation
    id: str
    name: str
    prescription_count: int
class ConditionRelation
    id: str
    name: str
    prescription_count: int
class NicotineOptionRow
    id: str
    name: str
    type: str
class SpellingCorrectionRow
    id: str
    from_: str
    to: str
class DatasetEntry
    version: str
    item_count: int
    items: Sequence[ReferenceEntity]
class FrequencyGraphs
    use_map: Mapping[str, Mapping[str, int]]
class DatasetBundleV3
    version: str
    medications: Sequence[ReferenceEntity]
    conditions: Sequence[ReferenceEntity]
    products: Sequence[ReferenceEntity]
    corrections: Sequence[ReferenceEntity]
    nicotine_options: Sequence[ReferenceEntity]
    medications_by_condition: Mapping[str, Sequence[str]]
    frequency_graphs: FrequencyGraphs
    datasets: Mapping[str, DatasetEntry | None]
    etag: str | None
    condition_rows: Sequence[ConditionRow]
    medication_rows: Sequence[MedicationRow]
    nicotine_option_rows: Sequence[NicotineOptionRow]
    spelling_corrections: Sequence[SpellingCorrectionRow]
    products_by_family: Mapping[str, Sequence[ReferenceEntity]]
    discontinued_products: Mapping[str, int]
    state_derivatives: Sequence[str]
class DatasetsV3NotModified
    not_modified: Literal[True]
    etag: str | None
def is_not_modified(result: DatasetBundleV3 | DatasetsV3NotModified) -> bool
class DatasetsV3GetOptions
    include: Sequence[DatasetCategory] | None
    fields: Literal['full', 'meta'] | None
    if_none_match: str | None
def get_datasets_v3(options: DatasetsV3GetOptions | None, *, transport: Transport, base_url: str, headers: Mapping[str, str]) -> DatasetBundleV3 | DatasetsV3NotModified
def parse_datasets_v3_envelope(body: str, *, etag: str | None) -> DatasetBundleV3

=== zyins/health.py ===
class ProbeResult(BaseModel)
    status: str
    latency_ms: int
    message: str
    checked_at: str
class ReadinessResult(BaseModel)
    ready: bool
    status: str
    db: ProbeResult
    cache: ProbeResult
    downstream_services: dict[str, ProbeResult]
    checked_at: str
def parse_readiness(raw: str) -> ReadinessResult

=== zyins/isa_options.py ===
class BearerAuthSupplier
    kind: Literal['bearer']
    token: str | None
class LicenseAuthSupplier
    kind: Literal['license']
    keycode: str | None
    email: str | None
class FormAuthSupplier
    kind: Literal['form']
    form_token: str
class SessionAuthSupplier
    kind: Literal['session']
    session_id: str | None
    session_secret: str | None
class BearerAuth
    def from_token(token: str) -> IsaAuthSupplier
    def from_env() -> IsaAuthSupplier
class LicenseAuth
    def from_keycode(keycode: str, email: str) -> IsaAuthSupplier
    def from_env() -> IsaAuthSupplier
class FormAuth
    def from_token(form_token: str) -> IsaAuthSupplier
class SessionAuth
    def from_credentials(session_id: str, session_secret: str) -> IsaAuthSupplier
    def from_env() -> IsaAuthSupplier
PRODUCTION_REMOTE_ORIGIN = ...
PRODUCTION_PROXY_ORIGIN = ...
class RemoteEngineSelector
    kind: Literal['remote']
    base_url: str
class LocalEngineSelector
    kind: Literal['local']
    base_url: str
class ProxyEngineSelector
    kind: Literal['proxy']
    proxy_origin: str
class InMemoryEngineSelector
    kind: Literal['in_memory']
class RemoteEngine
    def default() -> IsaEngine
    def at(base_url: str) -> IsaEngine
class LocalEngine
    def at(base_url: str) -> IsaEngine
class ProxyEngine
    def default() -> IsaEngine
    def at(proxy_origin: str) -> IsaEngine
InMemoryEngine: IsaEngine
DEFAULT_TIMEOUT_SECONDS = ...
class IsaCreateOptions
    auth: IsaAuthSupplier
    engine: IsaEngine | None
    timeout: float
    api_version: IsaApiVersion
    client_version: str | None
    transport: Transport | None
class ResolvedIsaOptions
    auth: IsaAuthSupplier
    engine: IsaEngine
    timeout_seconds: float
    api_version: IsaApiVersion
    client_version: str | None
    transport: Transport | None
    base_url: str
    proxy_origin: str | None
def resolve_isa_options(opts: IsaCreateOptions) -> ResolvedIsaOptions

=== zyins/license.py ===
class LicenseActivateResult(BaseModel)
    license_key: str
    order_id: str
    email: str
    request_id: str
class LicenseCheckResult(BaseModel)
    active: bool
    email: str
    request_id: str
def parse_activate(body: str) -> LicenseActivateResult
def parse_check(body: str) -> LicenseCheckResult

=== zyins/licenses.py ===
class LicenseCheckInput(BaseModel)
    email: str
    keycode: str
    device_id: str
    license_key: str
    def to_wire_body(self) -> str
class LicenseCheckResult(BaseModel)
    status: str
class LicenseDeactivateInput(BaseModel)
    email: str
    keycode: str
    device_id: str
    def to_wire_body(self) -> str
class LicenseDeactivateResult(BaseModel)
    status: str
def parse_check_response(raw: str) -> LicenseCheckResult
def parse_deactivate_response(raw: str) -> LicenseDeactivateResult

=== zyins/licenses_facade.py ===
class LicenseActivateResult
    status: str
    license_key: str
    remaining_activations: int
class LicenseCheckResult
    status: str
class LicenseDeactivateResult
    status: str
class LicenseFacade
    def activate(self, *, email: str | None, keycode: str | None, device_id: str | None) -> LicenseActivateResult
    def check(self, *, email: str | None, keycode: str | None, device_id: str | None, license_key: str | None) -> LicenseCheckResult
    def deactivate(self, *, email: str | None, keycode: str | None, device_id: str | None) -> LicenseDeactivateResult

=== zyins/logos.py ===
LOGOS_PATH = ...
class LogosResponse
    status: int
    body: bytes
    headers: dict[str, str]
    def text(self) -> str
class LogosFetch(Protocol)
class LogosSubClient
    def get(self, carrier: str, *, data_uri: bool) -> bytes | str
    def close(self) -> None

=== zyins/measurements.py ===
class HeightParseError(ValueError)
class WeightParseError(ValueError)
class Height
    inches: int
    MIN_INCHES: ClassVar[int]
    MAX_INCHES: ClassVar[int]
    def from_inches(cls, inches: int) -> Height
    def from_feet_inches(cls, feet: int, inches: int) -> Height
    def from_cm(cls, cm: float) -> Height
    def from_string(cls, value: str) -> Height
    def cm(self) -> float
    def feet_and_inches(self) -> tuple[int, int]
class Weight
    pounds: int
    MIN_POUNDS: ClassVar[int]
    MAX_POUNDS: ClassVar[int]
    def from_pounds(cls, pounds: int) -> Weight
    def from_kilograms(cls, kg: float) -> Weight
    def from_string(cls, value: str) -> Weight
    def kilograms(self) -> float

=== zyins/plan_info_label.py ===
def title_case_label(key: str) -> str
class PlanInfoItem
    key: str
    label: str
    values: tuple[str, ...]
def coerce_plan_info(raw: object) -> tuple[PlanInfoItem, ...]

=== zyins/preferences.py ===
class PreferencesSetInput(BaseModel)
    prefs: dict[str, Any]
    def to_wire_body(self) -> str
class PreferencesResult(BaseModel)
    prefs: dict[str, Any]
def parse_preferences_response(raw: str, *, fallback: dict[str, Any] | None) -> PreferencesResult

=== zyins/prequalify.py ===
class PrequalifyInput(BaseModel)
    applicant: Applicant
    coverage: Coverage
    products: str | ProductSelection
    def to_wire_body(self) -> str
class Carrier(BaseModel)
    id: str
    name: str
class PlanProduct(BaseModel)
    wire_token: str
    display_name: str
class Eligibility(BaseModel)
    eligible: bool
    category: str
    coverage_tier: str
class Premium(BaseModel)
    cents: int
    display: str
    mode: str
    modes: dict[str, int]
    rate_class: str
class PrequalifyPlan(BaseModel)
    carrier: Carrier
    product: PlanProduct
    eligibility: Eligibility
    premium: Premium | None
    brand: str
    tier: str
    monthly_premium: float
    face_value: int
    product_token: str
class PrequalifyResult(BaseModel)
    plans: tuple[PrequalifyPlan, ...]
    request_id: str
def parse_prequalify_response(body: str) -> PrequalifyResult

=== zyins/prequalify_v3.py ===
class V3EligibilityCategory(str, Enum)
class V3Eligibility
    category: V3EligibilityCategory | None
    eligible: bool
    reasons: Sequence[str]
class V3Amount
    cents: int
    display: str
class V3Money
    amount: V3Amount
    period: V3Period | None
class V3Premium
    amount: V3Amount
    default_mode: str
    modes: Mapping[str, V3Amount]
class V3PricingRow
    rate_class: str
    primary: bool
    eligibility: V3Eligibility
    rank: int | None
    premium: V3Premium | None
class V3OfferCarrier
    id: str
    name: str
    logo_url: str
class V3OfferProduct
    id: str
    slug: str
    name: str
    display_name: str
    type: str
    wire_token: str
class V3Offer
    object: Literal['plan_offer']
    id: str
    eligible: bool
    carrier: V3OfferCarrier
    product: V3OfferProduct
    plan_info: Sequence[Mapping[str, Any]]
    death_benefit: V3Money | None
    pricing: Sequence[V3PricingRow]
    metadata: Mapping[str, Any]
    budget: V3Money | None
class PrequalifyV3Result
    plans: Sequence[V3Offer]
    request_id: str
    idempotency_key: str
    livemode: bool
    retry_attempts: int
def by_amount(plans: Sequence[V3Offer]) -> dict[int, list[V3Offer]]
def offer_premium(offer: V3Offer) -> V3Premium | None
class PrequalifyV3Options
    only_product_class: str | None
    include_product_class: Sequence[str]
    min_rank: str | None
    show_unreleased: bool | None
    skip_health_based_underwriting: bool | None
    include_ineligible: bool | None
class PrequalifyV3Request
    applicant: Applicant
    coverage: Coverage
    products: ProductSelection
    options: PrequalifyV3Options | None
def prequalify_v3(request: PrequalifyV3Request, *, transport: Transport, base_url: str, headers: Mapping[str, str], idempotency_key: str | None) -> PrequalifyV3Result
def serialize_v3_prequalify_body(*, applicant: Applicant, coverage: Coverage, products: ProductSelection, options: PrequalifyV3Options | None) -> str
def serialize_wire_body(*, applicant: Applicant, coverage: Coverage, products: ProductSelection, options: PrequalifyV3Options | None) -> str
def parse_prequalify_v3_envelope(body: str, *, idempotency_key: str, retry_attempts: int) -> PrequalifyV3Result
def coerce_amount(raw: object) -> V3Amount
def coerce_money(raw: object) -> V3Money
def coerce_carrier(raw: object) -> V3OfferCarrier
def coerce_product(raw: object) -> V3OfferProduct
def coerce_pricing_row(raw: object) -> V3PricingRow

=== zyins/product.py ===
class ProductType(str, Enum)
class ProductSelection
    def of(cls, products: Product | Sequence[Product]) -> ProductSelection
    def list(self) -> tuple[Product, ...]
    def to_wire_array(self) -> tuple[str, ...]

=== zyins/quote.py ===
class QuoteInput(BaseModel)
    applicant: Applicant
    coverage: Coverage
    products: str | ProductSelection
    riders: tuple[str, ...]
    def to_wire_body(self) -> str
class QuotedPlan(BaseModel)
    brand: str
    tier: str
    product_token: str
    monthly_premium: float
    annual_premium: float
    face_value: int
    rider_premiums: dict[str, float]
class QuoteResult(BaseModel)
    plans: tuple[QuotedPlan, ...]
    request_id: str
def parse_quote_response(body: str) -> QuoteResult

=== zyins/quote_v3.py ===
class QuoteV3Result
    plans: Sequence[V3Offer]
    request_id: str
    idempotency_key: str
    livemode: bool
    retry_attempts: int
class QuoteV3Options(PrequalifyV3Options)
class QuoteV3Request
    applicant: Applicant
    coverage: Coverage
    products: ProductSelection
    options: QuoteV3Options | None
def quote_v3(request: QuoteV3Request, *, transport: Transport, base_url: str, headers: Mapping[str, str], idempotency_key: str | None) -> QuoteV3Result
def parse_quote_v3_envelope(body: str, *, idempotency_key: str, retry_attempts: int) -> QuoteV3Result

=== zyins/reference/__init__.py ===
class ReferenceFacade
    medications: _KindMatcher
    conditions: _KindMatcher
    concepts: _ConceptMatcher
    def match(self, text: str) -> Concept
    def match_many(self, texts: Sequence[str]) -> list[Concept]
def match(text: str, bundle: DatasetBundleV3) -> Concept
def match_medication(text: str, bundle: DatasetBundleV3) -> Concept
def match_condition(text: str, bundle: DatasetBundleV3) -> Concept
def bind(bundle: DatasetBundleV3) -> ReferenceFacade
reference: _ReferenceNamespace

=== zyins/reference/autocomplete_algorithm.py ===
class AutocompleteOptions
    limit: int
    kinds: Sequence[ConceptKind]
    frequencies: Mapping[str, int] | None
    starts_with_only: bool
    sort: Sort
class AutocompleteAlgorithm(Protocol)
    async def rank(self, query: str, candidates: Sequence[Concept], options: AutocompleteOptions) -> list[Suggestion]
class DefaultAutocompleteAlgorithm
    def version_tag(self) -> str | None
    def clone(self, **overrides) -> DefaultAutocompleteAlgorithm
    async def rank(self, query: str, candidates: Sequence[Concept], options: AutocompleteOptions) -> list[Suggestion]

=== zyins/reference/autocorrector.py ===
class AutocorrectAppliedEvent
    original: str
    corrected: str
    mode: AutocorrectMode
    window: str
    correction: str
class Autocorrector(Protocol)
    def correct(self, text: str, *, mode: AutocorrectMode) -> str
class DefaultAutocorrector
    def version_tag(self) -> str | None
    def clone(self, **overrides) -> DefaultAutocorrector
    def correct(self, text: str, *, mode: AutocorrectMode) -> str
def create(*, typo_map: Mapping[str, str], version_tag: str | None, on_applied: Callable[[AutocorrectAppliedEvent], None] | None) -> DefaultAutocorrector

=== zyins/reference/concept.py ===
class ConceptKind(str, Enum)
class Concept
    id: str | None
    name: str
    kind: ConceptKind
    is_known: bool
    input_text: str
    def conditions(self, sort: Sort) -> tuple[Concept, ...]
    def medications(self, sort: Sort) -> tuple[Concept, ...]
    def equals(self, other: object) -> bool
class MedicationConcept(Protocol)
    id: str | None
    name: str
    kind: ConceptKind
    is_known: bool
    input_text: str
    def conditions(self, sort: Sort) -> Sequence[Concept]
    def medications(self, sort: Sort) -> Sequence[Concept]
    def equals(self, other: object) -> bool
class ConditionConcept(Protocol)
    id: str | None
    name: str
    kind: ConceptKind
    is_known: bool
    input_text: str
    def conditions(self, sort: Sort) -> Sequence[Concept]
    def medications(self, sort: Sort) -> Sequence[Concept]
    def equals(self, other: object) -> bool

=== zyins/reference/index.py ===
class ReferenceIndex
    version: str
    condition_names: Mapping[str, str]
    medication_names: Mapping[str, str]
    medications_by_condition: Mapping[str, Sequence[str]]
    conditions_by_medication: Mapping[str, Sequence[str]]
    use_map: Mapping[str, Mapping[str, int]]
    condition_id_by_check_key: Mapping[str, str]
    medication_id_by_check_key: Mapping[str, str]
    def from_bundle(cls, bundle: DatasetBundleV3) -> ReferenceIndex
    def lookup_medication(self, text: str) -> str | None
    def lookup_condition(self, text: str) -> str | None
    def lookup_either(self, text: str) -> tuple[ConceptKind, str] | None
    def medication_name(self, entity_id: str) -> str | None
    def condition_name(self, entity_id: str) -> str | None
    def conditions_for_medication(self, medication_id: str, input_text: str, sort: Sort) -> tuple[Concept, ...]
    def medications_for_condition(self, condition_id: str, input_text: str, sort: Sort) -> tuple[Concept, ...]
    def all_medication_concepts(self) -> tuple[Concept, ...]
    def all_condition_concepts(self) -> tuple[Concept, ...]
    def build_medication_concept(self, entity_id: str, input_text: str) -> Concept
    def build_condition_concept(self, entity_id: str, input_text: str) -> Concept
    def build_unknown_concept(self, input_text: str) -> Concept

=== zyins/reference/match_algorithm.py ===
class MatchAlgorithm(Protocol)
    def match(self, query: str, candidates: Sequence[Concept]) -> Concept
class DefaultMatchAlgorithm
    def version_tag(self) -> str | None
    def clone(self, **overrides) -> DefaultMatchAlgorithm
    def match(self, query: str, candidates: Sequence[Concept]) -> Concept

=== zyins/reference/reference_index.py ===
class ReferenceIndex
    version: str
    concepts: Sequence[Concept]
    medications: Sequence[Concept]
    conditions: Sequence[Concept]
    frequencies: Mapping[str, int]
    typo_map: Mapping[str, str]
    medications_by_condition: Mapping[str, Sequence[str]]
    conditions_by_medication: Mapping[str, Sequence[str]]
    use_map: Mapping[str, Mapping[str, int]]
    def from_bundle(cls, bundle: DatasetBundleV3) -> ReferenceIndex
    def concept_for_id(self, entity_id: str) -> Concept | None
    def conditions_for_medication(self, medication_id: str, input_text: str, sort: Sort) -> tuple[Concept, ...]
    def medications_for_condition(self, condition_id: str, input_text: str, sort: Sort) -> tuple[Concept, ...]

=== zyins/reference/sort.py ===
class Sort(str, Enum)

=== zyins/reference/suggestion.py ===
class Suggestion
    concept: Concept
    score: float
    matched_span: tuple[int, int]
    rank: int
    def id(self) -> str | None
    def name(self) -> str
    def kind(self) -> ConceptKind
    def is_known(self) -> bool
    def input_text(self) -> str

=== zyins/reference_data.py ===
class ReferenceDataResponse(BaseModel)
    kind: str
    data: dict[str, Any]
    request_id: str
def parse_reference_data(body: str, *, kind: str) -> ReferenceDataResponse

=== zyins/reference_v3.py ===
class Sort(str, Enum)
class ConceptKind(str, Enum)
class Concept
    id: str | None
    name: str
    kind: ConceptKind
    is_known: bool
    input_text: str
    def conditions(self, sort: Sort) -> Sequence[Concept]
    def medications(self, sort: Sort) -> Sequence[Concept]
def match_medication(text: str, bundle: DatasetBundleV3) -> Concept
def match_condition(text: str, bundle: DatasetBundleV3) -> Concept
def match_concept(text: str, bundle: DatasetBundleV3) -> Concept
class BundleBoundMatcher
    def match(self, text: str) -> Concept
class ReferenceService
    medications: BundleBoundMatcher
    conditions: BundleBoundMatcher
    concepts: BundleBoundMatcher
def make_reference_service(bundle: DatasetBundleV3) -> ReferenceService

=== zyins/usage.py ===
class UsageSummary(BaseModel)
    period: str
    prequalify_calls: int
    quote_calls: int
    total_calls: int
    request_id: str
def parse_usage_summary(body: str, *, period: str) -> UsageSummary

