from __future__ import annotations

import datetime
from typing import (
    Annotated,
    Any,
    List,
    Literal,
    NotRequired,
    Optional,
    TypeAlias,
    TypedDict,
)

from pydantic import BaseModel, Field, Json

NetRequestStatus: TypeAlias = Literal["PENDING", "SUCCESS", "ERROR"]

RealtimeEqualityOp: TypeAlias = Literal["eq", "neq", "lt", "lte", "gt", "gte", "in"]

RealtimeAction: TypeAlias = Literal["INSERT", "UPDATE", "DELETE", "TRUNCATE", "ERROR"]

StorageBuckettype: TypeAlias = Literal["STANDARD", "ANALYTICS"]

AuthFactorType: TypeAlias = Literal["totp", "webauthn", "phone"]

AuthFactorStatus: TypeAlias = Literal["unverified", "verified"]

AuthAalLevel: TypeAlias = Literal["aal1", "aal2", "aal3"]

AuthCodeChallengeMethod: TypeAlias = Literal["s256", "plain"]

AuthOneTimeTokenType: TypeAlias = Literal["confirmation_token", "reauthentication_token", "recovery_token", "email_change_token_new", "email_change_token_current", "phone_change_token"]

AuthOauthRegistrationType: TypeAlias = Literal["dynamic", "manual"]

AuthOauthAuthorizationStatus: TypeAlias = Literal["pending", "approved", "denied", "expired"]

AuthOauthResponseType: TypeAlias = Literal["code"]

AuthOauthClientType: TypeAlias = Literal["public", "confidential"]

class AuthUsers(BaseModel):
    aud: Optional[str] = Field(alias="aud")
    banned_until: Optional[datetime.datetime] = Field(alias="banned_until")
    confirmation_sent_at: Optional[datetime.datetime] = Field(alias="confirmation_sent_at")
    confirmation_token: Optional[str] = Field(alias="confirmation_token")
    confirmed_at: Optional[datetime.datetime] = Field(alias="confirmed_at")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    deleted_at: Optional[datetime.datetime] = Field(alias="deleted_at")
    email: Optional[str] = Field(alias="email")
    email_change: Optional[str] = Field(alias="email_change")
    email_change_confirm_status: Optional[int] = Field(alias="email_change_confirm_status")
    email_change_sent_at: Optional[datetime.datetime] = Field(alias="email_change_sent_at")
    email_change_token_current: Optional[str] = Field(alias="email_change_token_current")
    email_change_token_new: Optional[str] = Field(alias="email_change_token_new")
    email_confirmed_at: Optional[datetime.datetime] = Field(alias="email_confirmed_at")
    encrypted_password: Optional[str] = Field(alias="encrypted_password")
    id: uuid.UUID = Field(alias="id")
    instance_id: Optional[uuid.UUID] = Field(alias="instance_id")
    invited_at: Optional[datetime.datetime] = Field(alias="invited_at")
    is_anonymous: bool = Field(alias="is_anonymous")
    is_sso_user: bool = Field(alias="is_sso_user")
    is_super_admin: Optional[bool] = Field(alias="is_super_admin")
    last_sign_in_at: Optional[datetime.datetime] = Field(alias="last_sign_in_at")
    phone: Optional[str] = Field(alias="phone")
    phone_change: Optional[str] = Field(alias="phone_change")
    phone_change_sent_at: Optional[datetime.datetime] = Field(alias="phone_change_sent_at")
    phone_change_token: Optional[str] = Field(alias="phone_change_token")
    phone_confirmed_at: Optional[datetime.datetime] = Field(alias="phone_confirmed_at")
    raw_app_meta_data: Optional[Json[Any]] = Field(alias="raw_app_meta_data")
    raw_user_meta_data: Optional[Json[Any]] = Field(alias="raw_user_meta_data")
    reauthentication_sent_at: Optional[datetime.datetime] = Field(alias="reauthentication_sent_at")
    reauthentication_token: Optional[str] = Field(alias="reauthentication_token")
    recovery_sent_at: Optional[datetime.datetime] = Field(alias="recovery_sent_at")
    recovery_token: Optional[str] = Field(alias="recovery_token")
    role: Optional[str] = Field(alias="role")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class AuthUsersInsert(TypedDict):
    aud: NotRequired[Annotated[str, Field(alias="aud")]]
    banned_until: NotRequired[Annotated[datetime.datetime, Field(alias="banned_until")]]
    confirmation_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="confirmation_sent_at")]]
    confirmation_token: NotRequired[Annotated[str, Field(alias="confirmation_token")]]
    confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="confirmed_at")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    deleted_at: NotRequired[Annotated[datetime.datetime, Field(alias="deleted_at")]]
    email: NotRequired[Annotated[str, Field(alias="email")]]
    email_change: NotRequired[Annotated[str, Field(alias="email_change")]]
    email_change_confirm_status: NotRequired[Annotated[int, Field(alias="email_change_confirm_status")]]
    email_change_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="email_change_sent_at")]]
    email_change_token_current: NotRequired[Annotated[str, Field(alias="email_change_token_current")]]
    email_change_token_new: NotRequired[Annotated[str, Field(alias="email_change_token_new")]]
    email_confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="email_confirmed_at")]]
    encrypted_password: NotRequired[Annotated[str, Field(alias="encrypted_password")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    invited_at: NotRequired[Annotated[datetime.datetime, Field(alias="invited_at")]]
    is_anonymous: NotRequired[Annotated[bool, Field(alias="is_anonymous")]]
    is_sso_user: NotRequired[Annotated[bool, Field(alias="is_sso_user")]]
    is_super_admin: NotRequired[Annotated[bool, Field(alias="is_super_admin")]]
    last_sign_in_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_sign_in_at")]]
    phone: NotRequired[Annotated[str, Field(alias="phone")]]
    phone_change: NotRequired[Annotated[str, Field(alias="phone_change")]]
    phone_change_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="phone_change_sent_at")]]
    phone_change_token: NotRequired[Annotated[str, Field(alias="phone_change_token")]]
    phone_confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="phone_confirmed_at")]]
    raw_app_meta_data: NotRequired[Annotated[Json[Any], Field(alias="raw_app_meta_data")]]
    raw_user_meta_data: NotRequired[Annotated[Json[Any], Field(alias="raw_user_meta_data")]]
    reauthentication_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="reauthentication_sent_at")]]
    reauthentication_token: NotRequired[Annotated[str, Field(alias="reauthentication_token")]]
    recovery_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="recovery_sent_at")]]
    recovery_token: NotRequired[Annotated[str, Field(alias="recovery_token")]]
    role: NotRequired[Annotated[str, Field(alias="role")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthUsersUpdate(TypedDict):
    aud: NotRequired[Annotated[str, Field(alias="aud")]]
    banned_until: NotRequired[Annotated[datetime.datetime, Field(alias="banned_until")]]
    confirmation_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="confirmation_sent_at")]]
    confirmation_token: NotRequired[Annotated[str, Field(alias="confirmation_token")]]
    confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="confirmed_at")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    deleted_at: NotRequired[Annotated[datetime.datetime, Field(alias="deleted_at")]]
    email: NotRequired[Annotated[str, Field(alias="email")]]
    email_change: NotRequired[Annotated[str, Field(alias="email_change")]]
    email_change_confirm_status: NotRequired[Annotated[int, Field(alias="email_change_confirm_status")]]
    email_change_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="email_change_sent_at")]]
    email_change_token_current: NotRequired[Annotated[str, Field(alias="email_change_token_current")]]
    email_change_token_new: NotRequired[Annotated[str, Field(alias="email_change_token_new")]]
    email_confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="email_confirmed_at")]]
    encrypted_password: NotRequired[Annotated[str, Field(alias="encrypted_password")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    invited_at: NotRequired[Annotated[datetime.datetime, Field(alias="invited_at")]]
    is_anonymous: NotRequired[Annotated[bool, Field(alias="is_anonymous")]]
    is_sso_user: NotRequired[Annotated[bool, Field(alias="is_sso_user")]]
    is_super_admin: NotRequired[Annotated[bool, Field(alias="is_super_admin")]]
    last_sign_in_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_sign_in_at")]]
    phone: NotRequired[Annotated[str, Field(alias="phone")]]
    phone_change: NotRequired[Annotated[str, Field(alias="phone_change")]]
    phone_change_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="phone_change_sent_at")]]
    phone_change_token: NotRequired[Annotated[str, Field(alias="phone_change_token")]]
    phone_confirmed_at: NotRequired[Annotated[datetime.datetime, Field(alias="phone_confirmed_at")]]
    raw_app_meta_data: NotRequired[Annotated[Json[Any], Field(alias="raw_app_meta_data")]]
    raw_user_meta_data: NotRequired[Annotated[Json[Any], Field(alias="raw_user_meta_data")]]
    reauthentication_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="reauthentication_sent_at")]]
    reauthentication_token: NotRequired[Annotated[str, Field(alias="reauthentication_token")]]
    recovery_sent_at: NotRequired[Annotated[datetime.datetime, Field(alias="recovery_sent_at")]]
    recovery_token: NotRequired[Annotated[str, Field(alias="recovery_token")]]
    role: NotRequired[Annotated[str, Field(alias="role")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthRefreshTokens(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    id: int = Field(alias="id")
    instance_id: Optional[uuid.UUID] = Field(alias="instance_id")
    parent: Optional[str] = Field(alias="parent")
    revoked: Optional[bool] = Field(alias="revoked")
    session_id: Optional[uuid.UUID] = Field(alias="session_id")
    token: Optional[str] = Field(alias="token")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    user_id: Optional[str] = Field(alias="user_id")

class AuthRefreshTokensInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    parent: NotRequired[Annotated[str, Field(alias="parent")]]
    revoked: NotRequired[Annotated[bool, Field(alias="revoked")]]
    session_id: NotRequired[Annotated[uuid.UUID, Field(alias="session_id")]]
    token: NotRequired[Annotated[str, Field(alias="token")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[str, Field(alias="user_id")]]

class AuthRefreshTokensUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    parent: NotRequired[Annotated[str, Field(alias="parent")]]
    revoked: NotRequired[Annotated[bool, Field(alias="revoked")]]
    session_id: NotRequired[Annotated[uuid.UUID, Field(alias="session_id")]]
    token: NotRequired[Annotated[str, Field(alias="token")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[str, Field(alias="user_id")]]

class AuthInstances(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    raw_base_config: Optional[str] = Field(alias="raw_base_config")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    uuid: Optional[uuid.UUID] = Field(alias="uuid")

class AuthInstancesInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    raw_base_config: NotRequired[Annotated[str, Field(alias="raw_base_config")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    uuid: NotRequired[Annotated[uuid.UUID, Field(alias="uuid")]]

class AuthInstancesUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    raw_base_config: NotRequired[Annotated[str, Field(alias="raw_base_config")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    uuid: NotRequired[Annotated[uuid.UUID, Field(alias="uuid")]]

class AuthAuditLogEntries(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    instance_id: Optional[uuid.UUID] = Field(alias="instance_id")
    ip_address: str = Field(alias="ip_address")
    payload: Optional[Json[Any]] = Field(alias="payload")

class AuthAuditLogEntriesInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    ip_address: NotRequired[Annotated[str, Field(alias="ip_address")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]

class AuthAuditLogEntriesUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    instance_id: NotRequired[Annotated[uuid.UUID, Field(alias="instance_id")]]
    ip_address: NotRequired[Annotated[str, Field(alias="ip_address")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]

class AuthSchemaMigrations(BaseModel):
    version: str = Field(alias="version")

class AuthSchemaMigrationsInsert(TypedDict):
    version: Annotated[str, Field(alias="version")]

class AuthSchemaMigrationsUpdate(TypedDict):
    version: NotRequired[Annotated[str, Field(alias="version")]]

class StorageBuckets(BaseModel):
    allowed_mime_types: Optional[List[str]] = Field(alias="allowed_mime_types")
    avif_autodetection: Optional[bool] = Field(alias="avif_autodetection")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    file_size_limit: Optional[int] = Field(alias="file_size_limit")
    id: str = Field(alias="id")
    name: str = Field(alias="name")
    owner: Optional[uuid.UUID] = Field(alias="owner")
    owner_id: Optional[str] = Field(alias="owner_id")
    public: Optional[bool] = Field(alias="public")
    type: StorageBuckettype = Field(alias="type")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class StorageBucketsInsert(TypedDict):
    allowed_mime_types: NotRequired[Annotated[List[str], Field(alias="allowed_mime_types")]]
    avif_autodetection: NotRequired[Annotated[bool, Field(alias="avif_autodetection")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    file_size_limit: NotRequired[Annotated[int, Field(alias="file_size_limit")]]
    id: Annotated[str, Field(alias="id")]
    name: Annotated[str, Field(alias="name")]
    owner: NotRequired[Annotated[uuid.UUID, Field(alias="owner")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    public: NotRequired[Annotated[bool, Field(alias="public")]]
    type: NotRequired[Annotated[StorageBuckettype, Field(alias="type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageBucketsUpdate(TypedDict):
    allowed_mime_types: NotRequired[Annotated[List[str], Field(alias="allowed_mime_types")]]
    avif_autodetection: NotRequired[Annotated[bool, Field(alias="avif_autodetection")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    file_size_limit: NotRequired[Annotated[int, Field(alias="file_size_limit")]]
    id: NotRequired[Annotated[str, Field(alias="id")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    owner: NotRequired[Annotated[uuid.UUID, Field(alias="owner")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    public: NotRequired[Annotated[bool, Field(alias="public")]]
    type: NotRequired[Annotated[StorageBuckettype, Field(alias="type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageObjects(BaseModel):
    bucket_id: Optional[str] = Field(alias="bucket_id")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    last_accessed_at: Optional[datetime.datetime] = Field(alias="last_accessed_at")
    level: Optional[int] = Field(alias="level")
    metadata: Optional[Json[Any]] = Field(alias="metadata")
    name: Optional[str] = Field(alias="name")
    owner: Optional[uuid.UUID] = Field(alias="owner")
    owner_id: Optional[str] = Field(alias="owner_id")
    path_tokens: Optional[List[str]] = Field(alias="path_tokens")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    user_metadata: Optional[Json[Any]] = Field(alias="user_metadata")
    version: Optional[str] = Field(alias="version")

class StorageObjectsInsert(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    last_accessed_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_accessed_at")]]
    level: NotRequired[Annotated[int, Field(alias="level")]]
    metadata: NotRequired[Annotated[Json[Any], Field(alias="metadata")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    owner: NotRequired[Annotated[uuid.UUID, Field(alias="owner")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    path_tokens: NotRequired[Annotated[List[str], Field(alias="path_tokens")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_metadata: NotRequired[Annotated[Json[Any], Field(alias="user_metadata")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class StorageObjectsUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    last_accessed_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_accessed_at")]]
    level: NotRequired[Annotated[int, Field(alias="level")]]
    metadata: NotRequired[Annotated[Json[Any], Field(alias="metadata")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    owner: NotRequired[Annotated[uuid.UUID, Field(alias="owner")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    path_tokens: NotRequired[Annotated[List[str], Field(alias="path_tokens")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_metadata: NotRequired[Annotated[Json[Any], Field(alias="user_metadata")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class StorageMigrations(BaseModel):
    executed_at: Optional[datetime.datetime] = Field(alias="executed_at")
    hash: str = Field(alias="hash")
    id: int = Field(alias="id")
    name: str = Field(alias="name")

class StorageMigrationsInsert(TypedDict):
    executed_at: NotRequired[Annotated[datetime.datetime, Field(alias="executed_at")]]
    hash: Annotated[str, Field(alias="hash")]
    id: Annotated[int, Field(alias="id")]
    name: Annotated[str, Field(alias="name")]

class StorageMigrationsUpdate(TypedDict):
    executed_at: NotRequired[Annotated[datetime.datetime, Field(alias="executed_at")]]
    hash: NotRequired[Annotated[str, Field(alias="hash")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]

class VaultSecrets(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    description: str = Field(alias="description")
    id: uuid.UUID = Field(alias="id")
    key_id: Optional[uuid.UUID] = Field(alias="key_id")
    name: Optional[str] = Field(alias="name")
    nonce: Optional[bytes] = Field(alias="nonce")
    secret: str = Field(alias="secret")
    updated_at: datetime.datetime = Field(alias="updated_at")

class VaultSecretsInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    description: NotRequired[Annotated[str, Field(alias="description")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    key_id: NotRequired[Annotated[uuid.UUID, Field(alias="key_id")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    nonce: NotRequired[Annotated[bytes, Field(alias="nonce")]]
    secret: Annotated[str, Field(alias="secret")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class VaultSecretsUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    description: NotRequired[Annotated[str, Field(alias="description")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    key_id: NotRequired[Annotated[uuid.UUID, Field(alias="key_id")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    nonce: NotRequired[Annotated[bytes, Field(alias="nonce")]]
    secret: NotRequired[Annotated[str, Field(alias="secret")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class NetHttpRequestQueue(BaseModel):
    body: Optional[bytes] = Field(alias="body")
    headers: Optional[Json[Any]] = Field(alias="headers")
    id: int = Field(alias="id")
    method: str = Field(alias="method")
    timeout_milliseconds: int = Field(alias="timeout_milliseconds")
    url: str = Field(alias="url")

class NetHttpRequestQueueInsert(TypedDict):
    body: NotRequired[Annotated[bytes, Field(alias="body")]]
    headers: NotRequired[Annotated[Json[Any], Field(alias="headers")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    method: Annotated[str, Field(alias="method")]
    timeout_milliseconds: Annotated[int, Field(alias="timeout_milliseconds")]
    url: Annotated[str, Field(alias="url")]

class NetHttpRequestQueueUpdate(TypedDict):
    body: NotRequired[Annotated[bytes, Field(alias="body")]]
    headers: NotRequired[Annotated[Json[Any], Field(alias="headers")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    method: NotRequired[Annotated[str, Field(alias="method")]]
    timeout_milliseconds: NotRequired[Annotated[int, Field(alias="timeout_milliseconds")]]
    url: NotRequired[Annotated[str, Field(alias="url")]]

class NetHttpResponse(BaseModel):
    content: Optional[str] = Field(alias="content")
    content_type: Optional[str] = Field(alias="content_type")
    created: datetime.datetime = Field(alias="created")
    error_msg: Optional[str] = Field(alias="error_msg")
    headers: Optional[Json[Any]] = Field(alias="headers")
    id: Optional[int] = Field(alias="id")
    status_code: Optional[int] = Field(alias="status_code")
    timed_out: Optional[bool] = Field(alias="timed_out")

class NetHttpResponseInsert(TypedDict):
    content: NotRequired[Annotated[str, Field(alias="content")]]
    content_type: NotRequired[Annotated[str, Field(alias="content_type")]]
    created: NotRequired[Annotated[datetime.datetime, Field(alias="created")]]
    error_msg: NotRequired[Annotated[str, Field(alias="error_msg")]]
    headers: NotRequired[Annotated[Json[Any], Field(alias="headers")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    status_code: NotRequired[Annotated[int, Field(alias="status_code")]]
    timed_out: NotRequired[Annotated[bool, Field(alias="timed_out")]]

class NetHttpResponseUpdate(TypedDict):
    content: NotRequired[Annotated[str, Field(alias="content")]]
    content_type: NotRequired[Annotated[str, Field(alias="content_type")]]
    created: NotRequired[Annotated[datetime.datetime, Field(alias="created")]]
    error_msg: NotRequired[Annotated[str, Field(alias="error_msg")]]
    headers: NotRequired[Annotated[Json[Any], Field(alias="headers")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    status_code: NotRequired[Annotated[int, Field(alias="status_code")]]
    timed_out: NotRequired[Annotated[bool, Field(alias="timed_out")]]

class SupabaseFunctionsMigrations(BaseModel):
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    version: str = Field(alias="version")

class SupabaseFunctionsMigrationsInsert(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: Annotated[str, Field(alias="version")]

class SupabaseFunctionsMigrationsUpdate(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class SupabaseFunctionsHooks(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    hook_name: str = Field(alias="hook_name")
    hook_table_id: int = Field(alias="hook_table_id")
    id: int = Field(alias="id")
    request_id: Optional[int] = Field(alias="request_id")

class SupabaseFunctionsHooksInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    hook_name: Annotated[str, Field(alias="hook_name")]
    hook_table_id: Annotated[int, Field(alias="hook_table_id")]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    request_id: NotRequired[Annotated[int, Field(alias="request_id")]]

class SupabaseFunctionsHooksUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    hook_name: NotRequired[Annotated[str, Field(alias="hook_name")]]
    hook_table_id: NotRequired[Annotated[int, Field(alias="hook_table_id")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    request_id: NotRequired[Annotated[int, Field(alias="request_id")]]

class RealtimeSchemaMigrations(BaseModel):
    inserted_at: Optional[datetime.datetime] = Field(alias="inserted_at")
    version: int = Field(alias="version")

class RealtimeSchemaMigrationsInsert(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: Annotated[int, Field(alias="version")]

class RealtimeSchemaMigrationsUpdate(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: NotRequired[Annotated[int, Field(alias="version")]]

class RealtimeTenants(BaseModel):
    broadcast_adapter: Optional[str] = Field(alias="broadcast_adapter")
    external_id: Optional[str] = Field(alias="external_id")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    jwt_jwks: Optional[Json[Any]] = Field(alias="jwt_jwks")
    jwt_secret: Optional[str] = Field(alias="jwt_secret")
    max_bytes_per_second: int = Field(alias="max_bytes_per_second")
    max_channels_per_client: int = Field(alias="max_channels_per_client")
    max_concurrent_users: int = Field(alias="max_concurrent_users")
    max_events_per_second: int = Field(alias="max_events_per_second")
    max_joins_per_second: int = Field(alias="max_joins_per_second")
    max_payload_size_in_kb: Optional[int] = Field(alias="max_payload_size_in_kb")
    max_presence_events_per_second: Optional[int] = Field(alias="max_presence_events_per_second")
    migrations_ran: Optional[int] = Field(alias="migrations_ran")
    name: Optional[str] = Field(alias="name")
    notify_private_alpha: Optional[bool] = Field(alias="notify_private_alpha")
    postgres_cdc_default: Optional[str] = Field(alias="postgres_cdc_default")
    private_only: bool = Field(alias="private_only")
    suspend: Optional[bool] = Field(alias="suspend")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeTenantsInsert(TypedDict):
    broadcast_adapter: NotRequired[Annotated[str, Field(alias="broadcast_adapter")]]
    external_id: NotRequired[Annotated[str, Field(alias="external_id")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    inserted_at: Annotated[datetime.datetime, Field(alias="inserted_at")]
    jwt_jwks: NotRequired[Annotated[Json[Any], Field(alias="jwt_jwks")]]
    jwt_secret: NotRequired[Annotated[str, Field(alias="jwt_secret")]]
    max_bytes_per_second: NotRequired[Annotated[int, Field(alias="max_bytes_per_second")]]
    max_channels_per_client: NotRequired[Annotated[int, Field(alias="max_channels_per_client")]]
    max_concurrent_users: NotRequired[Annotated[int, Field(alias="max_concurrent_users")]]
    max_events_per_second: NotRequired[Annotated[int, Field(alias="max_events_per_second")]]
    max_joins_per_second: NotRequired[Annotated[int, Field(alias="max_joins_per_second")]]
    max_payload_size_in_kb: NotRequired[Annotated[int, Field(alias="max_payload_size_in_kb")]]
    max_presence_events_per_second: NotRequired[Annotated[int, Field(alias="max_presence_events_per_second")]]
    migrations_ran: NotRequired[Annotated[int, Field(alias="migrations_ran")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    notify_private_alpha: NotRequired[Annotated[bool, Field(alias="notify_private_alpha")]]
    postgres_cdc_default: NotRequired[Annotated[str, Field(alias="postgres_cdc_default")]]
    private_only: NotRequired[Annotated[bool, Field(alias="private_only")]]
    suspend: NotRequired[Annotated[bool, Field(alias="suspend")]]
    updated_at: Annotated[datetime.datetime, Field(alias="updated_at")]

class RealtimeTenantsUpdate(TypedDict):
    broadcast_adapter: NotRequired[Annotated[str, Field(alias="broadcast_adapter")]]
    external_id: NotRequired[Annotated[str, Field(alias="external_id")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    jwt_jwks: NotRequired[Annotated[Json[Any], Field(alias="jwt_jwks")]]
    jwt_secret: NotRequired[Annotated[str, Field(alias="jwt_secret")]]
    max_bytes_per_second: NotRequired[Annotated[int, Field(alias="max_bytes_per_second")]]
    max_channels_per_client: NotRequired[Annotated[int, Field(alias="max_channels_per_client")]]
    max_concurrent_users: NotRequired[Annotated[int, Field(alias="max_concurrent_users")]]
    max_events_per_second: NotRequired[Annotated[int, Field(alias="max_events_per_second")]]
    max_joins_per_second: NotRequired[Annotated[int, Field(alias="max_joins_per_second")]]
    max_payload_size_in_kb: NotRequired[Annotated[int, Field(alias="max_payload_size_in_kb")]]
    max_presence_events_per_second: NotRequired[Annotated[int, Field(alias="max_presence_events_per_second")]]
    migrations_ran: NotRequired[Annotated[int, Field(alias="migrations_ran")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    notify_private_alpha: NotRequired[Annotated[bool, Field(alias="notify_private_alpha")]]
    postgres_cdc_default: NotRequired[Annotated[str, Field(alias="postgres_cdc_default")]]
    private_only: NotRequired[Annotated[bool, Field(alias="private_only")]]
    suspend: NotRequired[Annotated[bool, Field(alias="suspend")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeExtensions(BaseModel):
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    settings: Optional[Json[Any]] = Field(alias="settings")
    tenant_external_id: Optional[str] = Field(alias="tenant_external_id")
    type: Optional[str] = Field(alias="type")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeExtensionsInsert(TypedDict):
    id: Annotated[uuid.UUID, Field(alias="id")]
    inserted_at: Annotated[datetime.datetime, Field(alias="inserted_at")]
    settings: NotRequired[Annotated[Json[Any], Field(alias="settings")]]
    tenant_external_id: NotRequired[Annotated[str, Field(alias="tenant_external_id")]]
    type: NotRequired[Annotated[str, Field(alias="type")]]
    updated_at: Annotated[datetime.datetime, Field(alias="updated_at")]

class RealtimeExtensionsUpdate(TypedDict):
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    settings: NotRequired[Annotated[Json[Any], Field(alias="settings")]]
    tenant_external_id: NotRequired[Annotated[str, Field(alias="tenant_external_id")]]
    type: NotRequired[Annotated[str, Field(alias="type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeSchemaMigrations(BaseModel):
    inserted_at: Optional[datetime.datetime] = Field(alias="inserted_at")
    version: int = Field(alias="version")

class RealtimeSchemaMigrationsInsert(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: Annotated[int, Field(alias="version")]

class RealtimeSchemaMigrationsUpdate(TypedDict):
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    version: NotRequired[Annotated[int, Field(alias="version")]]

class RealtimeSubscription(BaseModel):
    claims: Json[Any] = Field(alias="claims")
    claims_role: PgCatalogRegrole = Field(alias="claims_role")
    created_at: datetime.datetime = Field(alias="created_at")
    entity: PgCatalogRegclass = Field(alias="entity")
    filters: List[RealtimeUserDefinedFilter] = Field(alias="filters")
    id: int = Field(alias="id")
    subscription_id: uuid.UUID = Field(alias="subscription_id")

class RealtimeSubscriptionInsert(TypedDict):
    claims: Annotated[Json[Any], Field(alias="claims")]
    claims_role: NotRequired[Annotated[PgCatalogRegrole, Field(alias="claims_role")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    entity: Annotated[PgCatalogRegclass, Field(alias="entity")]
    filters: NotRequired[Annotated[List[RealtimeUserDefinedFilter], Field(alias="filters")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    subscription_id: Annotated[uuid.UUID, Field(alias="subscription_id")]

class RealtimeSubscriptionUpdate(TypedDict):
    claims: NotRequired[Annotated[Json[Any], Field(alias="claims")]]
    claims_role: NotRequired[Annotated[PgCatalogRegrole, Field(alias="claims_role")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    entity: NotRequired[Annotated[PgCatalogRegclass, Field(alias="entity")]]
    filters: NotRequired[Annotated[List[RealtimeUserDefinedFilter], Field(alias="filters")]]
    id: NotRequired[Annotated[int, Field(alias="id")]]
    subscription_id: NotRequired[Annotated[uuid.UUID, Field(alias="subscription_id")]]

class RealtimeMessages(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessagesInsert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessagesUpdate(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251115(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251115Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251115Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251116(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251116Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251116Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251117(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251117Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251117Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251118(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251118Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251118Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251119(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251119Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251119Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageS3MultipartUploads(BaseModel):
    bucket_id: str = Field(alias="bucket_id")
    created_at: datetime.datetime = Field(alias="created_at")
    id: str = Field(alias="id")
    in_progress_size: int = Field(alias="in_progress_size")
    key: str = Field(alias="key")
    owner_id: Optional[str] = Field(alias="owner_id")
    upload_signature: str = Field(alias="upload_signature")
    user_metadata: Optional[Json[Any]] = Field(alias="user_metadata")
    version: str = Field(alias="version")

class StorageS3MultipartUploadsInsert(TypedDict):
    bucket_id: Annotated[str, Field(alias="bucket_id")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[str, Field(alias="id")]
    in_progress_size: NotRequired[Annotated[int, Field(alias="in_progress_size")]]
    key: Annotated[str, Field(alias="key")]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    upload_signature: Annotated[str, Field(alias="upload_signature")]
    user_metadata: NotRequired[Annotated[Json[Any], Field(alias="user_metadata")]]
    version: Annotated[str, Field(alias="version")]

class StorageS3MultipartUploadsUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[str, Field(alias="id")]]
    in_progress_size: NotRequired[Annotated[int, Field(alias="in_progress_size")]]
    key: NotRequired[Annotated[str, Field(alias="key")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    upload_signature: NotRequired[Annotated[str, Field(alias="upload_signature")]]
    user_metadata: NotRequired[Annotated[Json[Any], Field(alias="user_metadata")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class StorageS3MultipartUploadsParts(BaseModel):
    bucket_id: str = Field(alias="bucket_id")
    created_at: datetime.datetime = Field(alias="created_at")
    etag: str = Field(alias="etag")
    id: uuid.UUID = Field(alias="id")
    key: str = Field(alias="key")
    owner_id: Optional[str] = Field(alias="owner_id")
    part_number: int = Field(alias="part_number")
    size: int = Field(alias="size")
    upload_id: str = Field(alias="upload_id")
    version: str = Field(alias="version")

class StorageS3MultipartUploadsPartsInsert(TypedDict):
    bucket_id: Annotated[str, Field(alias="bucket_id")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    etag: Annotated[str, Field(alias="etag")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    key: Annotated[str, Field(alias="key")]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    part_number: Annotated[int, Field(alias="part_number")]
    size: NotRequired[Annotated[int, Field(alias="size")]]
    upload_id: Annotated[str, Field(alias="upload_id")]
    version: Annotated[str, Field(alias="version")]

class StorageS3MultipartUploadsPartsUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    etag: NotRequired[Annotated[str, Field(alias="etag")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    key: NotRequired[Annotated[str, Field(alias="key")]]
    owner_id: NotRequired[Annotated[str, Field(alias="owner_id")]]
    part_number: NotRequired[Annotated[int, Field(alias="part_number")]]
    size: NotRequired[Annotated[int, Field(alias="size")]]
    upload_id: NotRequired[Annotated[str, Field(alias="upload_id")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class StoragePrefixes(BaseModel):
    bucket_id: str = Field(alias="bucket_id")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    level: int = Field(alias="level")
    name: str = Field(alias="name")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class StoragePrefixesInsert(TypedDict):
    bucket_id: Annotated[str, Field(alias="bucket_id")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    level: NotRequired[Annotated[int, Field(alias="level")]]
    name: Annotated[str, Field(alias="name")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StoragePrefixesUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    level: NotRequired[Annotated[int, Field(alias="level")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageBucketsAnalytics(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    format: str = Field(alias="format")
    id: str = Field(alias="id")
    type: StorageBuckettype = Field(alias="type")
    updated_at: datetime.datetime = Field(alias="updated_at")

class StorageBucketsAnalyticsInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    format: NotRequired[Annotated[str, Field(alias="format")]]
    id: Annotated[str, Field(alias="id")]
    type: NotRequired[Annotated[StorageBuckettype, Field(alias="type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageBucketsAnalyticsUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    format: NotRequired[Annotated[str, Field(alias="format")]]
    id: NotRequired[Annotated[str, Field(alias="id")]]
    type: NotRequired[Annotated[StorageBuckettype, Field(alias="type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageIcebergNamespaces(BaseModel):
    bucket_id: str = Field(alias="bucket_id")
    created_at: datetime.datetime = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    name: str = Field(alias="name")
    updated_at: datetime.datetime = Field(alias="updated_at")

class StorageIcebergNamespacesInsert(TypedDict):
    bucket_id: Annotated[str, Field(alias="bucket_id")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    name: Annotated[str, Field(alias="name")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageIcebergNamespacesUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageIcebergTables(BaseModel):
    bucket_id: str = Field(alias="bucket_id")
    created_at: datetime.datetime = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    location: str = Field(alias="location")
    name: str = Field(alias="name")
    namespace_id: uuid.UUID = Field(alias="namespace_id")
    updated_at: datetime.datetime = Field(alias="updated_at")

class StorageIcebergTablesInsert(TypedDict):
    bucket_id: Annotated[str, Field(alias="bucket_id")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    location: Annotated[str, Field(alias="location")]
    name: Annotated[str, Field(alias="name")]
    namespace_id: Annotated[uuid.UUID, Field(alias="namespace_id")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class StorageIcebergTablesUpdate(TypedDict):
    bucket_id: NotRequired[Annotated[str, Field(alias="bucket_id")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    location: NotRequired[Annotated[str, Field(alias="location")]]
    name: NotRequired[Annotated[str, Field(alias="name")]]
    namespace_id: NotRequired[Annotated[uuid.UUID, Field(alias="namespace_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthIdentities(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    email: Optional[str] = Field(alias="email")
    id: uuid.UUID = Field(alias="id")
    identity_data: Json[Any] = Field(alias="identity_data")
    last_sign_in_at: Optional[datetime.datetime] = Field(alias="last_sign_in_at")
    provider: str = Field(alias="provider")
    provider_id: str = Field(alias="provider_id")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    user_id: uuid.UUID = Field(alias="user_id")

class AuthIdentitiesInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    email: NotRequired[Annotated[str, Field(alias="email")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    identity_data: Annotated[Json[Any], Field(alias="identity_data")]
    last_sign_in_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_sign_in_at")]]
    provider: Annotated[str, Field(alias="provider")]
    provider_id: Annotated[str, Field(alias="provider_id")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: Annotated[uuid.UUID, Field(alias="user_id")]

class AuthIdentitiesUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    email: NotRequired[Annotated[str, Field(alias="email")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    identity_data: NotRequired[Annotated[Json[Any], Field(alias="identity_data")]]
    last_sign_in_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_sign_in_at")]]
    provider: NotRequired[Annotated[str, Field(alias="provider")]]
    provider_id: NotRequired[Annotated[str, Field(alias="provider_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthSessions(BaseModel):
    aal: Optional[AuthAalLevel] = Field(alias="aal")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    factor_id: Optional[uuid.UUID] = Field(alias="factor_id")
    id: uuid.UUID = Field(alias="id")
    ip: Optional[PgCatalogInet] = Field(alias="ip")
    not_after: Optional[datetime.datetime] = Field(alias="not_after")
    oauth_client_id: Optional[uuid.UUID] = Field(alias="oauth_client_id")
    refreshed_at: Optional[datetime.datetime] = Field(alias="refreshed_at")
    tag: Optional[str] = Field(alias="tag")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    user_agent: Optional[str] = Field(alias="user_agent")
    user_id: uuid.UUID = Field(alias="user_id")

class AuthSessionsInsert(TypedDict):
    aal: NotRequired[Annotated[AuthAalLevel, Field(alias="aal")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    factor_id: NotRequired[Annotated[uuid.UUID, Field(alias="factor_id")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    ip: NotRequired[Annotated[PgCatalogInet, Field(alias="ip")]]
    not_after: NotRequired[Annotated[datetime.datetime, Field(alias="not_after")]]
    oauth_client_id: NotRequired[Annotated[uuid.UUID, Field(alias="oauth_client_id")]]
    refreshed_at: NotRequired[Annotated[datetime.datetime, Field(alias="refreshed_at")]]
    tag: NotRequired[Annotated[str, Field(alias="tag")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_agent: NotRequired[Annotated[str, Field(alias="user_agent")]]
    user_id: Annotated[uuid.UUID, Field(alias="user_id")]

class AuthSessionsUpdate(TypedDict):
    aal: NotRequired[Annotated[AuthAalLevel, Field(alias="aal")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    factor_id: NotRequired[Annotated[uuid.UUID, Field(alias="factor_id")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    ip: NotRequired[Annotated[PgCatalogInet, Field(alias="ip")]]
    not_after: NotRequired[Annotated[datetime.datetime, Field(alias="not_after")]]
    oauth_client_id: NotRequired[Annotated[uuid.UUID, Field(alias="oauth_client_id")]]
    refreshed_at: NotRequired[Annotated[datetime.datetime, Field(alias="refreshed_at")]]
    tag: NotRequired[Annotated[str, Field(alias="tag")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_agent: NotRequired[Annotated[str, Field(alias="user_agent")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthMfaFactors(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    factor_type: AuthFactorType = Field(alias="factor_type")
    friendly_name: Optional[str] = Field(alias="friendly_name")
    id: uuid.UUID = Field(alias="id")
    last_challenged_at: Optional[datetime.datetime] = Field(alias="last_challenged_at")
    phone: Optional[str] = Field(alias="phone")
    secret: Optional[str] = Field(alias="secret")
    status: AuthFactorStatus = Field(alias="status")
    updated_at: datetime.datetime = Field(alias="updated_at")
    user_id: uuid.UUID = Field(alias="user_id")
    web_authn_aaguid: Optional[uuid.UUID] = Field(alias="web_authn_aaguid")
    web_authn_credential: Optional[Json[Any]] = Field(alias="web_authn_credential")

class AuthMfaFactorsInsert(TypedDict):
    created_at: Annotated[datetime.datetime, Field(alias="created_at")]
    factor_type: Annotated[AuthFactorType, Field(alias="factor_type")]
    friendly_name: NotRequired[Annotated[str, Field(alias="friendly_name")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    last_challenged_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_challenged_at")]]
    phone: NotRequired[Annotated[str, Field(alias="phone")]]
    secret: NotRequired[Annotated[str, Field(alias="secret")]]
    status: Annotated[AuthFactorStatus, Field(alias="status")]
    updated_at: Annotated[datetime.datetime, Field(alias="updated_at")]
    user_id: Annotated[uuid.UUID, Field(alias="user_id")]
    web_authn_aaguid: NotRequired[Annotated[uuid.UUID, Field(alias="web_authn_aaguid")]]
    web_authn_credential: NotRequired[Annotated[Json[Any], Field(alias="web_authn_credential")]]

class AuthMfaFactorsUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    factor_type: NotRequired[Annotated[AuthFactorType, Field(alias="factor_type")]]
    friendly_name: NotRequired[Annotated[str, Field(alias="friendly_name")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    last_challenged_at: NotRequired[Annotated[datetime.datetime, Field(alias="last_challenged_at")]]
    phone: NotRequired[Annotated[str, Field(alias="phone")]]
    secret: NotRequired[Annotated[str, Field(alias="secret")]]
    status: NotRequired[Annotated[AuthFactorStatus, Field(alias="status")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]
    web_authn_aaguid: NotRequired[Annotated[uuid.UUID, Field(alias="web_authn_aaguid")]]
    web_authn_credential: NotRequired[Annotated[Json[Any], Field(alias="web_authn_credential")]]

class AuthMfaChallenges(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    factor_id: uuid.UUID = Field(alias="factor_id")
    id: uuid.UUID = Field(alias="id")
    ip_address: PgCatalogInet = Field(alias="ip_address")
    otp_code: Optional[str] = Field(alias="otp_code")
    verified_at: Optional[datetime.datetime] = Field(alias="verified_at")
    web_authn_session_data: Optional[Json[Any]] = Field(alias="web_authn_session_data")

class AuthMfaChallengesInsert(TypedDict):
    created_at: Annotated[datetime.datetime, Field(alias="created_at")]
    factor_id: Annotated[uuid.UUID, Field(alias="factor_id")]
    id: Annotated[uuid.UUID, Field(alias="id")]
    ip_address: Annotated[PgCatalogInet, Field(alias="ip_address")]
    otp_code: NotRequired[Annotated[str, Field(alias="otp_code")]]
    verified_at: NotRequired[Annotated[datetime.datetime, Field(alias="verified_at")]]
    web_authn_session_data: NotRequired[Annotated[Json[Any], Field(alias="web_authn_session_data")]]

class AuthMfaChallengesUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    factor_id: NotRequired[Annotated[uuid.UUID, Field(alias="factor_id")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    ip_address: NotRequired[Annotated[PgCatalogInet, Field(alias="ip_address")]]
    otp_code: NotRequired[Annotated[str, Field(alias="otp_code")]]
    verified_at: NotRequired[Annotated[datetime.datetime, Field(alias="verified_at")]]
    web_authn_session_data: NotRequired[Annotated[Json[Any], Field(alias="web_authn_session_data")]]

class AuthMfaAmrClaims(BaseModel):
    authentication_method: str = Field(alias="authentication_method")
    created_at: datetime.datetime = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    session_id: uuid.UUID = Field(alias="session_id")
    updated_at: datetime.datetime = Field(alias="updated_at")

class AuthMfaAmrClaimsInsert(TypedDict):
    authentication_method: Annotated[str, Field(alias="authentication_method")]
    created_at: Annotated[datetime.datetime, Field(alias="created_at")]
    id: Annotated[uuid.UUID, Field(alias="id")]
    session_id: Annotated[uuid.UUID, Field(alias="session_id")]
    updated_at: Annotated[datetime.datetime, Field(alias="updated_at")]

class AuthMfaAmrClaimsUpdate(TypedDict):
    authentication_method: NotRequired[Annotated[str, Field(alias="authentication_method")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    session_id: NotRequired[Annotated[uuid.UUID, Field(alias="session_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSsoProviders(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    disabled: Optional[bool] = Field(alias="disabled")
    id: uuid.UUID = Field(alias="id")
    resource_id: Optional[str] = Field(alias="resource_id")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class AuthSsoProvidersInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    disabled: NotRequired[Annotated[bool, Field(alias="disabled")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    resource_id: NotRequired[Annotated[str, Field(alias="resource_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSsoProvidersUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    disabled: NotRequired[Annotated[bool, Field(alias="disabled")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    resource_id: NotRequired[Annotated[str, Field(alias="resource_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSsoDomains(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    domain: str = Field(alias="domain")
    id: uuid.UUID = Field(alias="id")
    sso_provider_id: uuid.UUID = Field(alias="sso_provider_id")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class AuthSsoDomainsInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    domain: Annotated[str, Field(alias="domain")]
    id: Annotated[uuid.UUID, Field(alias="id")]
    sso_provider_id: Annotated[uuid.UUID, Field(alias="sso_provider_id")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSsoDomainsUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    domain: NotRequired[Annotated[str, Field(alias="domain")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    sso_provider_id: NotRequired[Annotated[uuid.UUID, Field(alias="sso_provider_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSamlProviders(BaseModel):
    attribute_mapping: Optional[Json[Any]] = Field(alias="attribute_mapping")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    entity_id: str = Field(alias="entity_id")
    id: uuid.UUID = Field(alias="id")
    metadata_url: Optional[str] = Field(alias="metadata_url")
    metadata_xml: str = Field(alias="metadata_xml")
    name_id_format: Optional[str] = Field(alias="name_id_format")
    sso_provider_id: uuid.UUID = Field(alias="sso_provider_id")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class AuthSamlProvidersInsert(TypedDict):
    attribute_mapping: NotRequired[Annotated[Json[Any], Field(alias="attribute_mapping")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    entity_id: Annotated[str, Field(alias="entity_id")]
    id: Annotated[uuid.UUID, Field(alias="id")]
    metadata_url: NotRequired[Annotated[str, Field(alias="metadata_url")]]
    metadata_xml: Annotated[str, Field(alias="metadata_xml")]
    name_id_format: NotRequired[Annotated[str, Field(alias="name_id_format")]]
    sso_provider_id: Annotated[uuid.UUID, Field(alias="sso_provider_id")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSamlProvidersUpdate(TypedDict):
    attribute_mapping: NotRequired[Annotated[Json[Any], Field(alias="attribute_mapping")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    entity_id: NotRequired[Annotated[str, Field(alias="entity_id")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    metadata_url: NotRequired[Annotated[str, Field(alias="metadata_url")]]
    metadata_xml: NotRequired[Annotated[str, Field(alias="metadata_xml")]]
    name_id_format: NotRequired[Annotated[str, Field(alias="name_id_format")]]
    sso_provider_id: NotRequired[Annotated[uuid.UUID, Field(alias="sso_provider_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSamlRelayStates(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    flow_state_id: Optional[uuid.UUID] = Field(alias="flow_state_id")
    for_email: Optional[str] = Field(alias="for_email")
    id: uuid.UUID = Field(alias="id")
    redirect_to: Optional[str] = Field(alias="redirect_to")
    request_id: str = Field(alias="request_id")
    sso_provider_id: uuid.UUID = Field(alias="sso_provider_id")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class AuthSamlRelayStatesInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    flow_state_id: NotRequired[Annotated[uuid.UUID, Field(alias="flow_state_id")]]
    for_email: NotRequired[Annotated[str, Field(alias="for_email")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    redirect_to: NotRequired[Annotated[str, Field(alias="redirect_to")]]
    request_id: Annotated[str, Field(alias="request_id")]
    sso_provider_id: Annotated[uuid.UUID, Field(alias="sso_provider_id")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthSamlRelayStatesUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    flow_state_id: NotRequired[Annotated[uuid.UUID, Field(alias="flow_state_id")]]
    for_email: NotRequired[Annotated[str, Field(alias="for_email")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    redirect_to: NotRequired[Annotated[str, Field(alias="redirect_to")]]
    request_id: NotRequired[Annotated[str, Field(alias="request_id")]]
    sso_provider_id: NotRequired[Annotated[uuid.UUID, Field(alias="sso_provider_id")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthFlowState(BaseModel):
    auth_code: str = Field(alias="auth_code")
    auth_code_issued_at: Optional[datetime.datetime] = Field(alias="auth_code_issued_at")
    authentication_method: str = Field(alias="authentication_method")
    code_challenge: str = Field(alias="code_challenge")
    code_challenge_method: AuthCodeChallengeMethod = Field(alias="code_challenge_method")
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    provider_access_token: Optional[str] = Field(alias="provider_access_token")
    provider_refresh_token: Optional[str] = Field(alias="provider_refresh_token")
    provider_type: str = Field(alias="provider_type")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")
    user_id: Optional[uuid.UUID] = Field(alias="user_id")

class AuthFlowStateInsert(TypedDict):
    auth_code: Annotated[str, Field(alias="auth_code")]
    auth_code_issued_at: NotRequired[Annotated[datetime.datetime, Field(alias="auth_code_issued_at")]]
    authentication_method: Annotated[str, Field(alias="authentication_method")]
    code_challenge: Annotated[str, Field(alias="code_challenge")]
    code_challenge_method: Annotated[AuthCodeChallengeMethod, Field(alias="code_challenge_method")]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    provider_access_token: NotRequired[Annotated[str, Field(alias="provider_access_token")]]
    provider_refresh_token: NotRequired[Annotated[str, Field(alias="provider_refresh_token")]]
    provider_type: Annotated[str, Field(alias="provider_type")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthFlowStateUpdate(TypedDict):
    auth_code: NotRequired[Annotated[str, Field(alias="auth_code")]]
    auth_code_issued_at: NotRequired[Annotated[datetime.datetime, Field(alias="auth_code_issued_at")]]
    authentication_method: NotRequired[Annotated[str, Field(alias="authentication_method")]]
    code_challenge: NotRequired[Annotated[str, Field(alias="code_challenge")]]
    code_challenge_method: NotRequired[Annotated[AuthCodeChallengeMethod, Field(alias="code_challenge_method")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    provider_access_token: NotRequired[Annotated[str, Field(alias="provider_access_token")]]
    provider_refresh_token: NotRequired[Annotated[str, Field(alias="provider_refresh_token")]]
    provider_type: NotRequired[Annotated[str, Field(alias="provider_type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthOneTimeTokens(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    id: uuid.UUID = Field(alias="id")
    relates_to: str = Field(alias="relates_to")
    token_hash: str = Field(alias="token_hash")
    token_type: AuthOneTimeTokenType = Field(alias="token_type")
    updated_at: datetime.datetime = Field(alias="updated_at")
    user_id: uuid.UUID = Field(alias="user_id")

class AuthOneTimeTokensInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    relates_to: Annotated[str, Field(alias="relates_to")]
    token_hash: Annotated[str, Field(alias="token_hash")]
    token_type: Annotated[AuthOneTimeTokenType, Field(alias="token_type")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: Annotated[uuid.UUID, Field(alias="user_id")]

class AuthOneTimeTokensUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    relates_to: NotRequired[Annotated[str, Field(alias="relates_to")]]
    token_hash: NotRequired[Annotated[str, Field(alias="token_hash")]]
    token_type: NotRequired[Annotated[AuthOneTimeTokenType, Field(alias="token_type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthOauthClients(BaseModel):
    client_name: Optional[str] = Field(alias="client_name")
    client_secret_hash: Optional[str] = Field(alias="client_secret_hash")
    client_type: AuthOauthClientType = Field(alias="client_type")
    client_uri: Optional[str] = Field(alias="client_uri")
    created_at: datetime.datetime = Field(alias="created_at")
    deleted_at: Optional[datetime.datetime] = Field(alias="deleted_at")
    grant_types: str = Field(alias="grant_types")
    id: uuid.UUID = Field(alias="id")
    logo_uri: Optional[str] = Field(alias="logo_uri")
    redirect_uris: str = Field(alias="redirect_uris")
    registration_type: AuthOauthRegistrationType = Field(alias="registration_type")
    updated_at: datetime.datetime = Field(alias="updated_at")

class AuthOauthClientsInsert(TypedDict):
    client_name: NotRequired[Annotated[str, Field(alias="client_name")]]
    client_secret_hash: NotRequired[Annotated[str, Field(alias="client_secret_hash")]]
    client_type: NotRequired[Annotated[AuthOauthClientType, Field(alias="client_type")]]
    client_uri: NotRequired[Annotated[str, Field(alias="client_uri")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    deleted_at: NotRequired[Annotated[datetime.datetime, Field(alias="deleted_at")]]
    grant_types: Annotated[str, Field(alias="grant_types")]
    id: Annotated[uuid.UUID, Field(alias="id")]
    logo_uri: NotRequired[Annotated[str, Field(alias="logo_uri")]]
    redirect_uris: Annotated[str, Field(alias="redirect_uris")]
    registration_type: Annotated[AuthOauthRegistrationType, Field(alias="registration_type")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthOauthClientsUpdate(TypedDict):
    client_name: NotRequired[Annotated[str, Field(alias="client_name")]]
    client_secret_hash: NotRequired[Annotated[str, Field(alias="client_secret_hash")]]
    client_type: NotRequired[Annotated[AuthOauthClientType, Field(alias="client_type")]]
    client_uri: NotRequired[Annotated[str, Field(alias="client_uri")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    deleted_at: NotRequired[Annotated[datetime.datetime, Field(alias="deleted_at")]]
    grant_types: NotRequired[Annotated[str, Field(alias="grant_types")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    logo_uri: NotRequired[Annotated[str, Field(alias="logo_uri")]]
    redirect_uris: NotRequired[Annotated[str, Field(alias="redirect_uris")]]
    registration_type: NotRequired[Annotated[AuthOauthRegistrationType, Field(alias="registration_type")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class AuthOauthAuthorizations(BaseModel):
    approved_at: Optional[datetime.datetime] = Field(alias="approved_at")
    authorization_code: Optional[str] = Field(alias="authorization_code")
    authorization_id: str = Field(alias="authorization_id")
    client_id: uuid.UUID = Field(alias="client_id")
    code_challenge: Optional[str] = Field(alias="code_challenge")
    code_challenge_method: Optional[AuthCodeChallengeMethod] = Field(alias="code_challenge_method")
    created_at: datetime.datetime = Field(alias="created_at")
    expires_at: datetime.datetime = Field(alias="expires_at")
    id: uuid.UUID = Field(alias="id")
    redirect_uri: str = Field(alias="redirect_uri")
    resource: Optional[str] = Field(alias="resource")
    response_type: AuthOauthResponseType = Field(alias="response_type")
    scope: str = Field(alias="scope")
    state: Optional[str] = Field(alias="state")
    status: AuthOauthAuthorizationStatus = Field(alias="status")
    user_id: Optional[uuid.UUID] = Field(alias="user_id")

class AuthOauthAuthorizationsInsert(TypedDict):
    approved_at: NotRequired[Annotated[datetime.datetime, Field(alias="approved_at")]]
    authorization_code: NotRequired[Annotated[str, Field(alias="authorization_code")]]
    authorization_id: Annotated[str, Field(alias="authorization_id")]
    client_id: Annotated[uuid.UUID, Field(alias="client_id")]
    code_challenge: NotRequired[Annotated[str, Field(alias="code_challenge")]]
    code_challenge_method: NotRequired[Annotated[AuthCodeChallengeMethod, Field(alias="code_challenge_method")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    expires_at: NotRequired[Annotated[datetime.datetime, Field(alias="expires_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    redirect_uri: Annotated[str, Field(alias="redirect_uri")]
    resource: NotRequired[Annotated[str, Field(alias="resource")]]
    response_type: NotRequired[Annotated[AuthOauthResponseType, Field(alias="response_type")]]
    scope: Annotated[str, Field(alias="scope")]
    state: NotRequired[Annotated[str, Field(alias="state")]]
    status: NotRequired[Annotated[AuthOauthAuthorizationStatus, Field(alias="status")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthOauthAuthorizationsUpdate(TypedDict):
    approved_at: NotRequired[Annotated[datetime.datetime, Field(alias="approved_at")]]
    authorization_code: NotRequired[Annotated[str, Field(alias="authorization_code")]]
    authorization_id: NotRequired[Annotated[str, Field(alias="authorization_id")]]
    client_id: NotRequired[Annotated[uuid.UUID, Field(alias="client_id")]]
    code_challenge: NotRequired[Annotated[str, Field(alias="code_challenge")]]
    code_challenge_method: NotRequired[Annotated[AuthCodeChallengeMethod, Field(alias="code_challenge_method")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    expires_at: NotRequired[Annotated[datetime.datetime, Field(alias="expires_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    redirect_uri: NotRequired[Annotated[str, Field(alias="redirect_uri")]]
    resource: NotRequired[Annotated[str, Field(alias="resource")]]
    response_type: NotRequired[Annotated[AuthOauthResponseType, Field(alias="response_type")]]
    scope: NotRequired[Annotated[str, Field(alias="scope")]]
    state: NotRequired[Annotated[str, Field(alias="state")]]
    status: NotRequired[Annotated[AuthOauthAuthorizationStatus, Field(alias="status")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class AuthOauthConsents(BaseModel):
    client_id: uuid.UUID = Field(alias="client_id")
    granted_at: datetime.datetime = Field(alias="granted_at")
    id: uuid.UUID = Field(alias="id")
    revoked_at: Optional[datetime.datetime] = Field(alias="revoked_at")
    scopes: str = Field(alias="scopes")
    user_id: uuid.UUID = Field(alias="user_id")

class AuthOauthConsentsInsert(TypedDict):
    client_id: Annotated[uuid.UUID, Field(alias="client_id")]
    granted_at: NotRequired[Annotated[datetime.datetime, Field(alias="granted_at")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    revoked_at: NotRequired[Annotated[datetime.datetime, Field(alias="revoked_at")]]
    scopes: Annotated[str, Field(alias="scopes")]
    user_id: Annotated[uuid.UUID, Field(alias="user_id")]

class AuthOauthConsentsUpdate(TypedDict):
    client_id: NotRequired[Annotated[uuid.UUID, Field(alias="client_id")]]
    granted_at: NotRequired[Annotated[datetime.datetime, Field(alias="granted_at")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    revoked_at: NotRequired[Annotated[datetime.datetime, Field(alias="revoked_at")]]
    scopes: NotRequired[Annotated[str, Field(alias="scopes")]]
    user_id: NotRequired[Annotated[uuid.UUID, Field(alias="user_id")]]

class SupabaseMigrationsSchemaMigrations(BaseModel):
    name: Optional[str] = Field(alias="name")
    statements: Optional[List[str]] = Field(alias="statements")
    version: str = Field(alias="version")

class SupabaseMigrationsSchemaMigrationsInsert(TypedDict):
    name: NotRequired[Annotated[str, Field(alias="name")]]
    statements: NotRequired[Annotated[List[str], Field(alias="statements")]]
    version: Annotated[str, Field(alias="version")]

class SupabaseMigrationsSchemaMigrationsUpdate(TypedDict):
    name: NotRequired[Annotated[str, Field(alias="name")]]
    statements: NotRequired[Annotated[List[str], Field(alias="statements")]]
    version: NotRequired[Annotated[str, Field(alias="version")]]

class PublicProfiles(BaseModel):
    bio: Optional[str] = Field(alias="bio")
    created_at: datetime.datetime = Field(alias="created_at")
    display_name: Optional[str] = Field(alias="display_name")
    id: uuid.UUID = Field(alias="id")
    slug: Optional[str] = Field(alias="slug")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class PublicProfilesInsert(TypedDict):
    bio: NotRequired[Annotated[str, Field(alias="bio")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    display_name: NotRequired[Annotated[str, Field(alias="display_name")]]
    id: Annotated[uuid.UUID, Field(alias="id")]
    slug: NotRequired[Annotated[str, Field(alias="slug")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class PublicProfilesUpdate(TypedDict):
    bio: NotRequired[Annotated[str, Field(alias="bio")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    display_name: NotRequired[Annotated[str, Field(alias="display_name")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    slug: NotRequired[Annotated[str, Field(alias="slug")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class PublicProfilesInfo(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    dob: Optional[datetime.date] = Field(alias="dob")
    first_name: Optional[str] = Field(alias="first_name")
    last_name: Optional[str] = Field(alias="last_name")
    profile_id: uuid.UUID = Field(alias="profile_id")
    profile_location: Optional[str] = Field(alias="profile_location")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class PublicProfilesInfoInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    dob: NotRequired[Annotated[datetime.date, Field(alias="dob")]]
    first_name: NotRequired[Annotated[str, Field(alias="first_name")]]
    last_name: NotRequired[Annotated[str, Field(alias="last_name")]]
    profile_id: Annotated[uuid.UUID, Field(alias="profile_id")]
    profile_location: NotRequired[Annotated[str, Field(alias="profile_location")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class PublicProfilesInfoUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    dob: NotRequired[Annotated[datetime.date, Field(alias="dob")]]
    first_name: NotRequired[Annotated[str, Field(alias="first_name")]]
    last_name: NotRequired[Annotated[str, Field(alias="last_name")]]
    profile_id: NotRequired[Annotated[uuid.UUID, Field(alias="profile_id")]]
    profile_location: NotRequired[Annotated[str, Field(alias="profile_location")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class PublicShortkeys(BaseModel):
    created_at: datetime.datetime = Field(alias="created_at")
    id: str = Field(alias="id")

class PublicShortkeysInsert(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: Annotated[str, Field(alias="id")]

class PublicShortkeysUpdate(TypedDict):
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    id: NotRequired[Annotated[str, Field(alias="id")]]

class PublicNotes(BaseModel):
    author_id: Optional[uuid.UUID] = Field(alias="author_id")
    content: Optional[str] = Field(alias="content")
    created_at: datetime.datetime = Field(alias="created_at")
    featured_image: Optional[str] = Field(alias="featured_image")
    id: uuid.UUID = Field(alias="id")
    is_public: bool = Field(alias="is_public")
    slug: Optional[str] = Field(alias="slug")
    title: Optional[str] = Field(alias="title")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class PublicNotesInsert(TypedDict):
    author_id: NotRequired[Annotated[uuid.UUID, Field(alias="author_id")]]
    content: NotRequired[Annotated[str, Field(alias="content")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    featured_image: NotRequired[Annotated[str, Field(alias="featured_image")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    is_public: NotRequired[Annotated[bool, Field(alias="is_public")]]
    slug: NotRequired[Annotated[str, Field(alias="slug")]]
    title: NotRequired[Annotated[str, Field(alias="title")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class PublicNotesUpdate(TypedDict):
    author_id: NotRequired[Annotated[uuid.UUID, Field(alias="author_id")]]
    content: NotRequired[Annotated[str, Field(alias="content")]]
    created_at: NotRequired[Annotated[datetime.datetime, Field(alias="created_at")]]
    featured_image: NotRequired[Annotated[str, Field(alias="featured_image")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    is_public: NotRequired[Annotated[bool, Field(alias="is_public")]]
    slug: NotRequired[Annotated[str, Field(alias="slug")]]
    title: NotRequired[Annotated[str, Field(alias="title")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class SupabaseMigrationsSeedFiles(BaseModel):
    hash: str = Field(alias="hash")
    path: str = Field(alias="path")

class SupabaseMigrationsSeedFilesInsert(TypedDict):
    hash: Annotated[str, Field(alias="hash")]
    path: Annotated[str, Field(alias="path")]

class SupabaseMigrationsSeedFilesUpdate(TypedDict):
    hash: NotRequired[Annotated[str, Field(alias="hash")]]
    path: NotRequired[Annotated[str, Field(alias="path")]]

class RealtimeMessages20251120(BaseModel):
    event: Optional[str] = Field(alias="event")
    extension: str = Field(alias="extension")
    id: uuid.UUID = Field(alias="id")
    inserted_at: datetime.datetime = Field(alias="inserted_at")
    payload: Optional[Json[Any]] = Field(alias="payload")
    private: Optional[bool] = Field(alias="private")
    topic: str = Field(alias="topic")
    updated_at: datetime.datetime = Field(alias="updated_at")

class RealtimeMessages20251120Insert(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: Annotated[str, Field(alias="extension")]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: Annotated[str, Field(alias="topic")]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class RealtimeMessages20251120Update(TypedDict):
    event: NotRequired[Annotated[str, Field(alias="event")]]
    extension: NotRequired[Annotated[str, Field(alias="extension")]]
    id: NotRequired[Annotated[uuid.UUID, Field(alias="id")]]
    inserted_at: NotRequired[Annotated[datetime.datetime, Field(alias="inserted_at")]]
    payload: NotRequired[Annotated[Json[Any], Field(alias="payload")]]
    private: NotRequired[Annotated[bool, Field(alias="private")]]
    topic: NotRequired[Annotated[str, Field(alias="topic")]]
    updated_at: NotRequired[Annotated[datetime.datetime, Field(alias="updated_at")]]

class VaultDecryptedSecrets(BaseModel):
    created_at: Optional[datetime.datetime] = Field(alias="created_at")
    decrypted_secret: Optional[str] = Field(alias="decrypted_secret")
    description: Optional[str] = Field(alias="description")
    id: Optional[uuid.UUID] = Field(alias="id")
    key_id: Optional[uuid.UUID] = Field(alias="key_id")
    name: Optional[str] = Field(alias="name")
    nonce: Optional[bytes] = Field(alias="nonce")
    secret: Optional[str] = Field(alias="secret")
    updated_at: Optional[datetime.datetime] = Field(alias="updated_at")

class ExtensionsPgStatStatementsInfo(BaseModel):
    dealloc: Optional[int] = Field(alias="dealloc")
    stats_reset: Optional[datetime.datetime] = Field(alias="stats_reset")

class ExtensionsPgStatStatements(BaseModel):
    calls: Optional[int] = Field(alias="calls")
    dbid: Optional[PgCatalogOid] = Field(alias="dbid")
    jit_deform_count: Optional[int] = Field(alias="jit_deform_count")
    jit_deform_time: Optional[float] = Field(alias="jit_deform_time")
    jit_emission_count: Optional[int] = Field(alias="jit_emission_count")
    jit_emission_time: Optional[float] = Field(alias="jit_emission_time")
    jit_functions: Optional[int] = Field(alias="jit_functions")
    jit_generation_time: Optional[float] = Field(alias="jit_generation_time")
    jit_inlining_count: Optional[int] = Field(alias="jit_inlining_count")
    jit_inlining_time: Optional[float] = Field(alias="jit_inlining_time")
    jit_optimization_count: Optional[int] = Field(alias="jit_optimization_count")
    jit_optimization_time: Optional[float] = Field(alias="jit_optimization_time")
    local_blk_read_time: Optional[float] = Field(alias="local_blk_read_time")
    local_blk_write_time: Optional[float] = Field(alias="local_blk_write_time")
    local_blks_dirtied: Optional[int] = Field(alias="local_blks_dirtied")
    local_blks_hit: Optional[int] = Field(alias="local_blks_hit")
    local_blks_read: Optional[int] = Field(alias="local_blks_read")
    local_blks_written: Optional[int] = Field(alias="local_blks_written")
    max_exec_time: Optional[float] = Field(alias="max_exec_time")
    max_plan_time: Optional[float] = Field(alias="max_plan_time")
    mean_exec_time: Optional[float] = Field(alias="mean_exec_time")
    mean_plan_time: Optional[float] = Field(alias="mean_plan_time")
    min_exec_time: Optional[float] = Field(alias="min_exec_time")
    min_plan_time: Optional[float] = Field(alias="min_plan_time")
    minmax_stats_since: Optional[datetime.datetime] = Field(alias="minmax_stats_since")
    plans: Optional[int] = Field(alias="plans")
    query: Optional[str] = Field(alias="query")
    queryid: Optional[int] = Field(alias="queryid")
    rows: Optional[int] = Field(alias="rows")
    shared_blk_read_time: Optional[float] = Field(alias="shared_blk_read_time")
    shared_blk_write_time: Optional[float] = Field(alias="shared_blk_write_time")
    shared_blks_dirtied: Optional[int] = Field(alias="shared_blks_dirtied")
    shared_blks_hit: Optional[int] = Field(alias="shared_blks_hit")
    shared_blks_read: Optional[int] = Field(alias="shared_blks_read")
    shared_blks_written: Optional[int] = Field(alias="shared_blks_written")
    stats_since: Optional[datetime.datetime] = Field(alias="stats_since")
    stddev_exec_time: Optional[float] = Field(alias="stddev_exec_time")
    stddev_plan_time: Optional[float] = Field(alias="stddev_plan_time")
    temp_blk_read_time: Optional[float] = Field(alias="temp_blk_read_time")
    temp_blk_write_time: Optional[float] = Field(alias="temp_blk_write_time")
    temp_blks_read: Optional[int] = Field(alias="temp_blks_read")
    temp_blks_written: Optional[int] = Field(alias="temp_blks_written")
    toplevel: Optional[bool] = Field(alias="toplevel")
    total_exec_time: Optional[float] = Field(alias="total_exec_time")
    total_plan_time: Optional[float] = Field(alias="total_plan_time")
    userid: Optional[PgCatalogOid] = Field(alias="userid")
    wal_bytes: Optional[float] = Field(alias="wal_bytes")
    wal_fpi: Optional[int] = Field(alias="wal_fpi")
    wal_records: Optional[int] = Field(alias="wal_records")



class NetHttpResponse(BaseModel):
    status_code: int = Field(alias="status_code")
    headers: Json[Any] = Field(alias="headers")
    body: str = Field(alias="body")

class NetHttpResponseResult(BaseModel):
    status: NetRequestStatus = Field(alias="status")
    message: str = Field(alias="message")
    response: NetHttpResponse = Field(alias="response")

class RealtimeUserDefinedFilter(BaseModel):
    column_name: str = Field(alias="column_name")
    op: RealtimeEqualityOp = Field(alias="op")
    value: str = Field(alias="value")

class RealtimeWalRls(BaseModel):
    wal: Json[Any] = Field(alias="wal")
    is_rls_enabled: bool = Field(alias="is_rls_enabled")
    subscription_ids: List[uuid.UUID] = Field(alias="subscription_ids")
    errors: List[str] = Field(alias="errors")

class RealtimeWalColumn(BaseModel):
    name: str = Field(alias="name")
    type_name: str = Field(alias="type_name")
    type_oid: PgCatalogOid = Field(alias="type_oid")
    value: Json[Any] = Field(alias="value")
    is_pkey: bool = Field(alias="is_pkey")
    is_selectable: bool = Field(alias="is_selectable")