vapi-server-sdk 0.0.0a7__py3-none-any.whl

vapi/types/lmnt_voice.py

@@ -0,0 +1,52 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .lmnt_voice_id import LmntVoiceId
+from .chunk_plan import ChunkPlan
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class LmntVoice(UniversalBaseModel):
+    filler_injection_enabled: typing_extensions.Annotated[
+        typing.Optional[bool], FieldMetadata(alias="fillerInjectionEnabled")
+    ] = pydantic.Field(default=None)
+    """
+    This determines whether fillers are injected into the model output before inputting it into the voice provider.
+    
+    Default `false` because you can achieve better results with prompting the model.
+    """
+
+    provider: typing.Literal["lmnt"] = pydantic.Field(default="lmnt")
+    """
+    This is the voice provider that will be used.
+    """
+
+    voice_id: typing_extensions.Annotated[LmntVoiceId, FieldMetadata(alias="voiceId")] = pydantic.Field()
+    """
+    This is the provider-specific ID that will be used.
+    """
+
+    speed: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    This is the speed multiplier that will be used.
+    """
+
+    chunk_plan: typing_extensions.Annotated[typing.Optional[ChunkPlan], FieldMetadata(alias="chunkPlan")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the plan for chunking the model output before it is sent to the voice provider.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/lmnt_voice_id.py

@@ -0,0 +1,6 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .lmnt_voice_id_enum import LmntVoiceIdEnum
+
+LmntVoiceId = typing.Union[LmntVoiceIdEnum, str]

vapi/types/lmnt_voice_id_enum.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LmntVoiceIdEnum = typing.Union[typing.Literal["lily", "daniel"], typing.Any]

vapi/types/log.py

@@ -0,0 +1,164 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import pydantic
+import typing_extensions
+from ..core.serialization import FieldMetadata
+from .log_type import LogType
+import typing
+from .log_resource import LogResource
+from .log_request_http_method import LogRequestHttpMethod
+from .error import Error
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class Log(UniversalBaseModel):
+    time: float = pydantic.Field()
+    """
+    This is the timestamp at which the log was written.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this log belongs to.
+    """
+
+    type: LogType = pydantic.Field()
+    """
+    This is the type of the log.
+    """
+
+    resource: typing.Optional[LogResource] = pydantic.Field(default=None)
+    """
+    This is the specific resource, relevant only to API logs.
+    """
+
+    request_duration_seconds: typing_extensions.Annotated[float, FieldMetadata(alias="requestDurationSeconds")] = (
+        pydantic.Field()
+    )
+    """
+    'This is how long the request took.
+    """
+
+    request_started_at: typing_extensions.Annotated[str, FieldMetadata(alias="requestStartedAt")] = pydantic.Field()
+    """
+    This is the timestamp at which the request began.
+    """
+
+    request_finished_at: typing_extensions.Annotated[str, FieldMetadata(alias="requestFinishedAt")] = pydantic.Field()
+    """
+    This is the timestamp at which the request finished.
+    """
+
+    request_body: typing_extensions.Annotated[
+        typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="requestBody")
+    ] = pydantic.Field()
+    """
+    This is the body of the request.
+    """
+
+    request_http_method: typing_extensions.Annotated[LogRequestHttpMethod, FieldMetadata(alias="requestHttpMethod")] = (
+        pydantic.Field()
+    )
+    """
+    This is the request method.
+    """
+
+    request_url: typing_extensions.Annotated[str, FieldMetadata(alias="requestUrl")] = pydantic.Field()
+    """
+    This is the request URL.
+    """
+
+    request_path: typing_extensions.Annotated[str, FieldMetadata(alias="requestPath")] = pydantic.Field()
+    """
+    This is the request path.
+    """
+
+    request_query: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="requestQuery")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the request query.
+    """
+
+    response_http_code: typing_extensions.Annotated[float, FieldMetadata(alias="responseHttpCode")] = pydantic.Field()
+    """
+    This the HTTP status code of the response.
+    """
+
+    request_ip_address: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="requestIpAddress")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the request IP address.
+    """
+
+    request_origin: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="requestOrigin")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the origin of the request
+    """
+
+    response_body: typing_extensions.Annotated[
+        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="responseBody")
+    ] = pydantic.Field(default=None)
+    """
+    This is the body of the response.
+    """
+
+    request_headers: typing_extensions.Annotated[
+        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="requestHeaders")
+    ] = pydantic.Field(default=None)
+    """
+    These are the headers of the request.
+    """
+
+    error: typing.Optional[Error] = pydantic.Field(default=None)
+    """
+    This is the error, if one occurred.
+    """
+
+    assistant_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="assistantId")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the ID of the assistant.
+    """
+
+    phone_number_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="phoneNumberId")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the ID of the phone number.
+    """
+
+    customer_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="customerId")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the ID of the customer.
+    """
+
+    squad_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="squadId")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the ID of the squad.
+    """
+
+    call_id: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="callId")] = pydantic.Field(
+        default=None
+    )
+    """
+    This is the ID of the call.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/log_request_http_method.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LogRequestHttpMethod = typing.Union[typing.Literal["POST", "GET", "PUT", "PATCH", "DELETE"], typing.Any]

vapi/types/log_resource.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LogResource = typing.Union[
+    typing.Literal["assistant", "phone-number", "tool", "squad", "call", "file", "metric", "log"], typing.Any
+]

vapi/types/log_type.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+LogType = typing.Union[typing.Literal["API", "Webhook", "Call", "Provider"], typing.Any]

vapi/types/logs_paginated_response.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+from .log import Log
+from .pagination_meta import PaginationMeta
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class LogsPaginatedResponse(UniversalBaseModel):
+    results: typing.List[Log]
+    metadata: PaginationMeta
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_credential.py

@@ -0,0 +1,56 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import pydantic
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MakeCredential(UniversalBaseModel):
+    provider: typing.Literal["make"] = "make"
+    team_id: typing_extensions.Annotated[str, FieldMetadata(alias="teamId")] = pydantic.Field()
+    """
+    Team ID
+    """
+
+    region: str = pydantic.Field()
+    """
+    Region of your application. For example: eu1, eu2, us1, us2
+    """
+
+    api_key: typing_extensions.Annotated[str, FieldMetadata(alias="apiKey")] = pydantic.Field()
+    """
+    This is not returned in the API.
+    """
+
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the credential.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the org that this credential belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the credential was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the assistant was last updated.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_tool.py

@@ -0,0 +1,85 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .make_tool_messages_item import MakeToolMessagesItem
+import datetime as dt
+from .open_ai_function import OpenAiFunction
+from .server import Server
+from .make_tool_metadata import MakeToolMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MakeTool(UniversalBaseModel):
+    async_: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="async")] = pydantic.Field(
+        default=None
+    )
+    """
+    This determines if the tool is async.
+    
+    If async, the assistant will move forward without waiting for your server to respond. This is useful if you just want to trigger something on your server.
+    
+    If sync, the assistant will wait for your server to respond. This is useful if want assistant to respond with the result from your server.
+    
+    Defaults to synchronous (`false`).
+    """
+
+    messages: typing.Optional[typing.List[MakeToolMessagesItem]] = pydantic.Field(default=None)
+    """
+    These are the messages that will be spoken to the user as the tool is running.
+    
+    For some tools, this is auto-filled based on special fields like `tool.destinations`. For others like the function tool, these can be custom configured.
+    """
+
+    type: typing.Literal["make"] = "make"
+    id: str = pydantic.Field()
+    """
+    This is the unique identifier for the tool.
+    """
+
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")] = pydantic.Field()
+    """
+    This is the unique identifier for the organization that this tool belongs to.
+    """
+
+    created_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="createdAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the tool was created.
+    """
+
+    updated_at: typing_extensions.Annotated[dt.datetime, FieldMetadata(alias="updatedAt")] = pydantic.Field()
+    """
+    This is the ISO 8601 date-time string of when the tool was last updated.
+    """
+
+    function: typing.Optional[OpenAiFunction] = pydantic.Field(default=None)
+    """
+    This is the function definition of the tool.
+    
+    For `endCall`, `transferCall`, and `dtmf` tools, this is auto-filled based on tool-specific fields like `tool.destinations`. But, even in those cases, you can provide a custom function definition for advanced use cases.
+    
+    An example of an advanced use case is if you want to customize the message that's spoken for `endCall` tool. You can specify a function where it returns an argument "reason". Then, in `messages` array, you can have many "request-complete" messages. One of these messages will be triggered if the `messages[].conditions` matches the "reason" argument.
+    """
+
+    server: typing.Optional[Server] = pydantic.Field(default=None)
+    """
+    This is the server that will be hit when this tool is requested by the model.
+    
+    All requests will be sent with the call object among other things. You can find more details in the Server URL documentation.
+    
+    This overrides the serverUrl set on the org and the phoneNumber. Order of precedence: highest tool.server.url, then assistant.serverUrl, then phoneNumber.serverUrl, then org.serverUrl.
+    """
+
+    metadata: MakeToolMetadata
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_tool_messages_item.py

@@ -0,0 +1,9 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .tool_message_start import ToolMessageStart
+from .tool_message_complete import ToolMessageComplete
+from .tool_message_failed import ToolMessageFailed
+from .tool_message_delayed import ToolMessageDelayed
+
+MakeToolMessagesItem = typing.Union[ToolMessageStart, ToolMessageComplete, ToolMessageFailed, ToolMessageDelayed]

vapi/types/make_tool_metadata.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class MakeToolMetadata(UniversalBaseModel):
+    scenario_id: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="scenarioId")] = None
+    trigger_hook_id: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="triggerHookId")] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_tool_provider_details.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .tool_template_setup import ToolTemplateSetup
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MakeToolProviderDetails(UniversalBaseModel):
+    template_url: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="templateUrl")] = (
+        pydantic.Field(default=None)
+    )
+    """
+    This is the Template URL or the Snapshot URL corresponding to the Template.
+    """
+
+    setup_instructions: typing_extensions.Annotated[
+        typing.Optional[typing.List[ToolTemplateSetup]], FieldMetadata(alias="setupInstructions")
+    ] = None
+    type: typing.Literal["make"] = pydantic.Field(default="make")
+    """
+    The type of tool. "make" for Make tool.
+    """
+
+    scenario_id: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="scenarioId")] = None
+    scenario_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="scenarioName")] = None
+    trigger_hook_id: typing_extensions.Annotated[typing.Optional[float], FieldMetadata(alias="triggerHookId")] = None
+    trigger_hook_name: typing_extensions.Annotated[typing.Optional[str], FieldMetadata(alias="triggerHookName")] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_tool_with_tool_call.py

@@ -0,0 +1,69 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from .make_tool_with_tool_call_messages_item import MakeToolWithToolCallMessagesItem
+from .tool_call import ToolCall
+from .make_tool_metadata import MakeToolMetadata
+from .open_ai_function import OpenAiFunction
+from .server import Server
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MakeToolWithToolCall(UniversalBaseModel):
+    async_: typing_extensions.Annotated[typing.Optional[bool], FieldMetadata(alias="async")] = pydantic.Field(
+        default=None
+    )
+    """
+    This determines if the tool is async.
+    
+    If async, the assistant will move forward without waiting for your server to respond. This is useful if you just want to trigger something on your server.
+    
+    If sync, the assistant will wait for your server to respond. This is useful if want assistant to respond with the result from your server.
+    
+    Defaults to synchronous (`false`).
+    """
+
+    messages: typing.Optional[typing.List[MakeToolWithToolCallMessagesItem]] = pydantic.Field(default=None)
+    """
+    These are the messages that will be spoken to the user as the tool is running.
+    
+    For some tools, this is auto-filled based on special fields like `tool.destinations`. For others like the function tool, these can be custom configured.
+    """
+
+    type: typing.Literal["make"] = pydantic.Field(default="make")
+    """
+    The type of tool. "make" for Make tool.
+    """
+
+    tool_call: typing_extensions.Annotated[ToolCall, FieldMetadata(alias="toolCall")]
+    metadata: MakeToolMetadata
+    function: typing.Optional[OpenAiFunction] = pydantic.Field(default=None)
+    """
+    This is the function definition of the tool.
+    
+    For `endCall`, `transferCall`, and `dtmf` tools, this is auto-filled based on tool-specific fields like `tool.destinations`. But, even in those cases, you can provide a custom function definition for advanced use cases.
+    
+    An example of an advanced use case is if you want to customize the message that's spoken for `endCall` tool. You can specify a function where it returns an argument "reason". Then, in `messages` array, you can have many "request-complete" messages. One of these messages will be triggered if the `messages[].conditions` matches the "reason" argument.
+    """
+
+    server: typing.Optional[Server] = pydantic.Field(default=None)
+    """
+    This is the server that will be hit when this tool is requested by the model.
+    
+    All requests will be sent with the call object among other things. You can find more details in the Server URL documentation.
+    
+    This overrides the serverUrl set on the org and the phoneNumber. Order of precedence: highest tool.server.url, then assistant.serverUrl, then phoneNumber.serverUrl, then org.serverUrl.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/make_tool_with_tool_call_messages_item.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from .tool_message_start import ToolMessageStart
+from .tool_message_complete import ToolMessageComplete
+from .tool_message_failed import ToolMessageFailed
+from .tool_message_delayed import ToolMessageDelayed
+
+MakeToolWithToolCallMessagesItem = typing.Union[
+    ToolMessageStart, ToolMessageComplete, ToolMessageFailed, ToolMessageDelayed
+]

vapi/types/message_plan.py

@@ -0,0 +1,51 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+import typing
+from ..core.serialization import FieldMetadata
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
+
+class MessagePlan(UniversalBaseModel):
+    idle_messages: typing_extensions.Annotated[
+        typing.Optional[typing.List[str]], FieldMetadata(alias="idleMessages")
+    ] = pydantic.Field(default=None)
+    """
+    This are the messages that the assistant will speak when the user hasn't responded for `idleTimeoutSeconds`. Each time the timeout is triggered, a random message will be chosen from this array.
+    
+    Usage:
+    
+    - If user gets distracted and doesn't respond for a while, this can be used to grab their attention.
+    - If the transcriber doesn't pick up what the user said, this can be used to ask the user to repeat themselves. (From the perspective of the assistant, the conversation is idle since it didn't "hear" any user messages.)
+    
+    @default null (no idle message is spoken)
+    """
+
+    idle_message_max_spoken_count: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="idleMessageMaxSpokenCount")
+    ] = pydantic.Field(default=None)
+    """
+    This determines the maximum number of times `idleMessages` can be spoken during the call.
+    
+    @default 3
+    """
+
+    idle_timeout_seconds: typing_extensions.Annotated[
+        typing.Optional[float], FieldMetadata(alias="idleTimeoutSeconds")
+    ] = pydantic.Field(default=None)
+    """
+    This is the timeout in seconds before a message from `idleMessages` is spoken. The clock starts when the assistant finishes speaking and remains active until the user speaks.
+    
+    @default 10
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vapi/types/metrics.py

@@ -0,0 +1,44 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import typing_extensions
+from ..core.serialization import FieldMetadata
+import typing
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import pydantic
+
+
+class Metrics(UniversalBaseModel):
+    org_id: typing_extensions.Annotated[str, FieldMetadata(alias="orgId")]
+    range_start: typing_extensions.Annotated[str, FieldMetadata(alias="rangeStart")]
+    range_end: typing_extensions.Annotated[str, FieldMetadata(alias="rangeEnd")]
+    bill: float
+    bill_within_billing_limit: typing_extensions.Annotated[bool, FieldMetadata(alias="billWithinBillingLimit")]
+    bill_daily_breakdown: typing_extensions.Annotated[
+        typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="billDailyBreakdown")
+    ]
+    call_active: typing_extensions.Annotated[float, FieldMetadata(alias="callActive")]
+    call_active_within_concurrency_limit: typing_extensions.Annotated[
+        bool, FieldMetadata(alias="callActiveWithinConcurrencyLimit")
+    ]
+    call_minutes: typing_extensions.Annotated[float, FieldMetadata(alias="callMinutes")]
+    call_minutes_daily_breakdown: typing_extensions.Annotated[
+        typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="callMinutesDailyBreakdown")
+    ]
+    call_minutes_average: typing_extensions.Annotated[float, FieldMetadata(alias="callMinutesAverage")]
+    call_minutes_average_daily_breakdown: typing_extensions.Annotated[
+        typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="callMinutesAverageDailyBreakdown")
+    ]
+    call_count: typing_extensions.Annotated[float, FieldMetadata(alias="callCount")]
+    call_count_daily_breakdown: typing_extensions.Annotated[
+        typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="callCountDailyBreakdown")
+    ]
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow