# -*- coding: utf-8 -*-
# code generated by Prisma. DO NOT EDIT.
# pyright: reportUnusedImport=false
# fmt: off

# global imports for type checking
from builtins import bool as _bool
from builtins import int as _int
from builtins import float as _float
from builtins import str as _str
import sys
import decimal
import datetime
from typing import (
    TYPE_CHECKING,
    Optional,
    Iterable,
    Iterator,
    Sequence,
    Callable,
    ClassVar,
    NoReturn,
    TypeVar,
    Generic,
    Mapping,
    Tuple,
    Union,
    List,
    Dict,
    Type,
    Any,
    Set,
    overload,
    cast,
)
from typing_extensions import TypedDict, Literal


LiteralString = str
# -- template models.py.jinja --
from pydantic import BaseModel

from . import fields, actions
from ._types import FuncType
from ._builder import serialize_base64
from ._compat import PYDANTIC_V2, ConfigDict

if TYPE_CHECKING:
    from .client import Prisma


_PrismaModelT = TypeVar('_PrismaModelT', bound='_PrismaModel')


class _PrismaModel(BaseModel):
    if PYDANTIC_V2:
        model_config: ClassVar[ConfigDict] = ConfigDict(
            use_enum_values=True,
            arbitrary_types_allowed=True,
            populate_by_name=True,
        )
    elif not TYPE_CHECKING:
        from ._compat import BaseConfig

        class Config(BaseConfig):
            use_enum_values: bool = True
            arbitrary_types_allowed: bool = True
            allow_population_by_field_name: bool = True
            json_encoders: Dict[Any, FuncType] = {
                fields.Base64: serialize_base64,
            }

    # TODO: ensure this is required by subclasses
    __prisma_model__: ClassVar[str]


class BaseLiteLLM_BudgetTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_BudgetTable']] = 'LiteLLM_BudgetTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_BudgetTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_BudgetTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_CredentialsTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_CredentialsTable']] = 'LiteLLM_CredentialsTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_CredentialsTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_CredentialsTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ProxyModelTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ProxyModelTable']] = 'LiteLLM_ProxyModelTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ProxyModelTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ProxyModelTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_AgentsTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_AgentsTable']] = 'LiteLLM_AgentsTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_AgentsTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_AgentsTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_OrganizationTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_OrganizationTable']] = 'LiteLLM_OrganizationTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_OrganizationTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_OrganizationTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ModelTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ModelTable']] = 'LiteLLM_ModelTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ModelTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ModelTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_TeamTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_TeamTable']] = 'LiteLLM_TeamTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_TeamTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_TeamTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ProjectTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ProjectTable']] = 'LiteLLM_ProjectTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ProjectTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ProjectTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DeletedTeamTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DeletedTeamTable']] = 'LiteLLM_DeletedTeamTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DeletedTeamTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DeletedTeamTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_UserTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_UserTable']] = 'LiteLLM_UserTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_UserTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_UserTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ObjectPermissionTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ObjectPermissionTable']] = 'LiteLLM_ObjectPermissionTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ObjectPermissionTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ObjectPermissionTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_MCPServerTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_MCPServerTable']] = 'LiteLLM_MCPServerTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_MCPServerTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_MCPServerTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_MCPUserCredentials(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_MCPUserCredentials']] = 'LiteLLM_MCPUserCredentials'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_MCPUserCredentialsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_MCPUserCredentialsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_VerificationToken(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_VerificationToken']] = 'LiteLLM_VerificationToken'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_VerificationTokenActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_VerificationTokenActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_JWTKeyMapping(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_JWTKeyMapping']] = 'LiteLLM_JWTKeyMapping'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_JWTKeyMappingActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_JWTKeyMappingActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DeprecatedVerificationToken(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DeprecatedVerificationToken']] = 'LiteLLM_DeprecatedVerificationToken'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DeprecatedVerificationTokenActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DeprecatedVerificationTokenActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DeletedVerificationToken(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DeletedVerificationToken']] = 'LiteLLM_DeletedVerificationToken'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DeletedVerificationTokenActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DeletedVerificationTokenActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_EndUserTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_EndUserTable']] = 'LiteLLM_EndUserTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_EndUserTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_EndUserTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_TagTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_TagTable']] = 'LiteLLM_TagTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_TagTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_TagTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_Config(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_Config']] = 'LiteLLM_Config'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ConfigActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ConfigActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SpendLogs(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SpendLogs']] = 'LiteLLM_SpendLogs'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SpendLogsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SpendLogsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ErrorLogs(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ErrorLogs']] = 'LiteLLM_ErrorLogs'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ErrorLogsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ErrorLogsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_UserNotifications(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_UserNotifications']] = 'LiteLLM_UserNotifications'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_UserNotificationsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_UserNotificationsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_TeamMembership(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_TeamMembership']] = 'LiteLLM_TeamMembership'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_TeamMembershipActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_TeamMembershipActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_OrganizationMembership(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_OrganizationMembership']] = 'LiteLLM_OrganizationMembership'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_OrganizationMembershipActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_OrganizationMembershipActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_InvitationLink(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_InvitationLink']] = 'LiteLLM_InvitationLink'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_InvitationLinkActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_InvitationLinkActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_AuditLog(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_AuditLog']] = 'LiteLLM_AuditLog'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_AuditLogActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_AuditLogActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyUserSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyUserSpend']] = 'LiteLLM_DailyUserSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyUserSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyUserSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyOrganizationSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyOrganizationSpend']] = 'LiteLLM_DailyOrganizationSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyOrganizationSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyOrganizationSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyEndUserSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyEndUserSpend']] = 'LiteLLM_DailyEndUserSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyEndUserSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyEndUserSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyAgentSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyAgentSpend']] = 'LiteLLM_DailyAgentSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyAgentSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyAgentSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyTeamSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyTeamSpend']] = 'LiteLLM_DailyTeamSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyTeamSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyTeamSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyTagSpend(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyTagSpend']] = 'LiteLLM_DailyTagSpend'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyTagSpendActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyTagSpendActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_CronJob(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_CronJob']] = 'LiteLLM_CronJob'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_CronJobActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_CronJobActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ManagedFileTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ManagedFileTable']] = 'LiteLLM_ManagedFileTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ManagedFileTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ManagedFileTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ManagedObjectTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ManagedObjectTable']] = 'LiteLLM_ManagedObjectTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ManagedObjectTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ManagedObjectTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ManagedVectorStoreTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ManagedVectorStoreTable']] = 'LiteLLM_ManagedVectorStoreTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ManagedVectorStoreTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ManagedVectorStoreTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ManagedVectorStoresTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ManagedVectorStoresTable']] = 'LiteLLM_ManagedVectorStoresTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ManagedVectorStoresTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ManagedVectorStoresTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_GuardrailsTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_GuardrailsTable']] = 'LiteLLM_GuardrailsTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_GuardrailsTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_GuardrailsTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyGuardrailMetrics(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyGuardrailMetrics']] = 'LiteLLM_DailyGuardrailMetrics'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyGuardrailMetricsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyGuardrailMetricsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_DailyPolicyMetrics(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_DailyPolicyMetrics']] = 'LiteLLM_DailyPolicyMetrics'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_DailyPolicyMetricsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_DailyPolicyMetricsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SpendLogGuardrailIndex(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SpendLogGuardrailIndex']] = 'LiteLLM_SpendLogGuardrailIndex'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SpendLogGuardrailIndexActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SpendLogGuardrailIndexActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SpendLogToolIndex(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SpendLogToolIndex']] = 'LiteLLM_SpendLogToolIndex'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SpendLogToolIndexActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SpendLogToolIndexActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_PromptTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_PromptTable']] = 'LiteLLM_PromptTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_PromptTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_PromptTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_HealthCheckTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_HealthCheckTable']] = 'LiteLLM_HealthCheckTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_HealthCheckTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_HealthCheckTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SearchToolsTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SearchToolsTable']] = 'LiteLLM_SearchToolsTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SearchToolsTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SearchToolsTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SSOConfig(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SSOConfig']] = 'LiteLLM_SSOConfig'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SSOConfigActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SSOConfigActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ManagedVectorStoreIndexTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ManagedVectorStoreIndexTable']] = 'LiteLLM_ManagedVectorStoreIndexTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ManagedVectorStoreIndexTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ManagedVectorStoreIndexTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_CacheConfig(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_CacheConfig']] = 'LiteLLM_CacheConfig'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_CacheConfigActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_CacheConfigActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_UISettings(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_UISettings']] = 'LiteLLM_UISettings'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_UISettingsActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_UISettingsActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ConfigOverrides(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ConfigOverrides']] = 'LiteLLM_ConfigOverrides'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ConfigOverridesActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ConfigOverridesActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_SkillsTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_SkillsTable']] = 'LiteLLM_SkillsTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_SkillsTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_SkillsTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_PolicyTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_PolicyTable']] = 'LiteLLM_PolicyTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_PolicyTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_PolicyTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_PolicyAttachmentTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_PolicyAttachmentTable']] = 'LiteLLM_PolicyAttachmentTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_PolicyAttachmentTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_PolicyAttachmentTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ToolTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ToolTable']] = 'LiteLLM_ToolTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ToolTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ToolTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_AccessGroupTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_AccessGroupTable']] = 'LiteLLM_AccessGroupTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_AccessGroupTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_AccessGroupTableActions[_PrismaModelT](client or get_client(), cls)


class BaseLiteLLM_ClaudeCodePluginTable(_PrismaModel):
    __prisma_model__: ClassVar[Literal['LiteLLM_ClaudeCodePluginTable']] = 'LiteLLM_ClaudeCodePluginTable'  # pyright: ignore[reportIncompatibleVariableOverride]

    @classmethod
    def prisma(cls: Type[_PrismaModelT], client: Optional['Prisma'] = None) -> 'actions.LiteLLM_ClaudeCodePluginTableActions[_PrismaModelT]':
        from .client import get_client

        return actions.LiteLLM_ClaudeCodePluginTableActions[_PrismaModelT](client or get_client(), cls)