syllable-sdk 0.44.1__py3-none-any.whl → 0.44.12__py3-none-any.whl

syllable_sdk/models/bridgephrasesconfig.py

@@ -1,10 +1,6 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .schemas_cortex_v1_bridge_phrases_dictionarymetadata import (
-    SchemasCortexV1BridgePhrasesDictionaryMetadata,
-    SchemasCortexV1BridgePhrasesDictionaryMetadataTypedDict,
-)
 from syllable_sdk.types import BaseModel
 from typing import List, Optional
 from typing_extensions import NotRequired, TypedDict
@@ -19,8 +15,6 @@ class BridgePhrasesConfigTypedDict(TypedDict):
     r"""Messages to say when the agent is significantly delayed."""
     tool_responses: NotRequired[List[str]]
     r"""Messages to say when a tool call is in progress."""
-    metadata: NotRequired[SchemasCortexV1BridgePhrasesDictionaryMetadataTypedDict]
-    r"""Metadata for the bridge phrases dictionary."""
 
 
 class BridgePhrasesConfig(BaseModel):
@@ -34,6 +28,3 @@ class BridgePhrasesConfig(BaseModel):
 
     tool_responses: Optional[List[str]] = None
     r"""Messages to say when a tool call is in progress."""
-
-    metadata: Optional[SchemasCortexV1BridgePhrasesDictionaryMetadata] = None
-    r"""Metadata for the bridge phrases dictionary."""

syllable_sdk/models/{schemas_tts_v1_pronunciations_dictionarymetadata.py → dictionarymetadata.py}

@@ -6,7 +6,7 @@ from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-class SchemasTtsV1PronunciationsDictionaryMetadataTypedDict(TypedDict):
+class DictionaryMetadataTypedDict(TypedDict):
     r"""Audit metadata associated with a dictionary."""
 
     entries: int
@@ -14,7 +14,7 @@ class SchemasTtsV1PronunciationsDictionaryMetadataTypedDict(TypedDict):
     source: NotRequired[str]
 
 
-class SchemasTtsV1PronunciationsDictionaryMetadata(BaseModel):
+class DictionaryMetadata(BaseModel):
     r"""Audit metadata associated with a dictionary."""
 
     entries: int

syllable_sdk/models/directory_member_createop.py

@@ -0,0 +1,28 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .directorymembercreate import DirectoryMemberCreate, DirectoryMemberCreateTypedDict
+from .directoryresponseformat import DirectoryResponseFormat
+from syllable_sdk.types import BaseModel
+from syllable_sdk.utils import FieldMetadata, QueryParamMetadata, RequestMetadata
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class DirectoryMemberCreateRequestTypedDict(TypedDict):
+    directory_member_create: DirectoryMemberCreateTypedDict
+    response_format: NotRequired[DirectoryResponseFormat]
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
+
+
+class DirectoryMemberCreateRequest(BaseModel):
+    directory_member_create: Annotated[
+        DirectoryMemberCreate,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]
+
+    response_format: Annotated[
+        Optional[DirectoryResponseFormat],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""

syllable_sdk/models/directory_member_downloadop.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .directoryresponseformat import DirectoryResponseFormat
+from syllable_sdk.types import BaseModel
+from syllable_sdk.utils import FieldMetadata, QueryParamMetadata
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class DirectoryMemberDownloadRequestTypedDict(TypedDict):
+    response_format: NotRequired[DirectoryResponseFormat]
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
+
+
+class DirectoryMemberDownloadRequest(BaseModel):
+    response_format: Annotated[
+        Optional[DirectoryResponseFormat],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""

syllable_sdk/models/directory_member_get_by_idop.py

@@ -1,16 +1,26 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .directoryresponseformat import DirectoryResponseFormat
 from syllable_sdk.types import BaseModel
-from syllable_sdk.utils import FieldMetadata, PathParamMetadata
-from typing_extensions import Annotated, TypedDict
+from syllable_sdk.utils import FieldMetadata, PathParamMetadata, QueryParamMetadata
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class DirectoryMemberGetByIDRequestTypedDict(TypedDict):
     member_id: int
+    response_format: NotRequired[DirectoryResponseFormat]
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
 
 
 class DirectoryMemberGetByIDRequest(BaseModel):
     member_id: Annotated[
         int, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
     ]
+
+    response_format: Annotated[
+        Optional[DirectoryResponseFormat],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""

syllable_sdk/models/directory_member_listop.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .directorymemberproperties import DirectoryMemberProperties
+from .directoryresponseformat import DirectoryResponseFormat
 from .orderbydirection import OrderByDirection
 from pydantic import model_serializer
 from syllable_sdk.types import (
@@ -17,84 +18,93 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class DirectoryMemberListRequestTypedDict(TypedDict):
+    response_format: NotRequired[DirectoryResponseFormat]
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
     page: NotRequired[Nullable[int]]
-    r"""The page number from which to start (0-based)"""
+    r"""Page number (0-based)"""
     limit: NotRequired[int]
-    r"""The maximum number of items to return"""
+    r"""Items per page"""
     search_fields: NotRequired[List[DirectoryMemberProperties]]
-    r"""String names of fields to search. Correspond by index to search field values"""
+    r"""Fields to search; aligns with search_field_values"""
     search_field_values: NotRequired[List[str]]
-    r"""Values of fields to search. Correspond by index to search fields. Unless field name contains \"list\", an individual search field value cannot be a list"""
+    r"""Values for search_fields in matching order"""
     order_by: NotRequired[Nullable[DirectoryMemberProperties]]
-    r"""The field whose value should be used to order the results"""
+    r"""Field to order results by"""
     order_by_direction: NotRequired[Nullable[OrderByDirection]]
-    r"""The direction in which to order the results"""
+    r"""Direction to order results"""
     fields: NotRequired[Nullable[List[DirectoryMemberProperties]]]
-    r"""The fields to include in the response"""
+    r"""Fields to include in response"""
     start_datetime: NotRequired[Nullable[str]]
-    r"""The start datetime for filtering results"""
+    r"""Start datetime for filtering results"""
     end_datetime: NotRequired[Nullable[str]]
-    r"""The end datetime for filtering results"""
+    r"""End datetime for filtering results"""
 
 
 class DirectoryMemberListRequest(BaseModel):
+    response_format: Annotated[
+        Optional[DirectoryResponseFormat],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
+
     page: Annotated[
         OptionalNullable[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The page number from which to start (0-based)"""
+    r"""Page number (0-based)"""
 
     limit: Annotated[
         Optional[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = 25
-    r"""The maximum number of items to return"""
+    r"""Items per page"""
 
     search_fields: Annotated[
         Optional[List[DirectoryMemberProperties]],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""String names of fields to search. Correspond by index to search field values"""
+    r"""Fields to search; aligns with search_field_values"""
 
     search_field_values: Annotated[
         Optional[List[str]],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
-    r"""Values of fields to search. Correspond by index to search fields. Unless field name contains \"list\", an individual search field value cannot be a list"""
+    r"""Values for search_fields in matching order"""
 
     order_by: Annotated[
         OptionalNullable[DirectoryMemberProperties],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The field whose value should be used to order the results"""
+    r"""Field to order results by"""
 
     order_by_direction: Annotated[
         OptionalNullable[OrderByDirection],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The direction in which to order the results"""
+    r"""Direction to order results"""
 
     fields: Annotated[
         OptionalNullable[List[DirectoryMemberProperties]],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The fields to include in the response"""
+    r"""Fields to include in response"""
 
     start_datetime: Annotated[
         OptionalNullable[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The start datetime for filtering results"""
+    r"""Start datetime for filtering results"""
 
     end_datetime: Annotated[
         OptionalNullable[str],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = UNSET
-    r"""The end datetime for filtering results"""
+    r"""End datetime for filtering results"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
+            "response_format",
             "page",
             "limit",
             "search_fields",

syllable_sdk/models/directory_member_test_extensionop.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 from .languagecode import LanguageCode
-from datetime import datetime
 from pydantic import model_serializer
 from syllable_sdk.types import (
     BaseModel,
@@ -17,8 +16,8 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class DirectoryMemberTestExtensionRequestTypedDict(TypedDict):
     member_id: int
-    timestamp: datetime
-    r"""Timestamp for test"""
+    timestamp: str
+    r"""Timestamp for test in ISO 8601 format (e.g., 2025-12-04T14:29:39)"""
     language_code: NotRequired[Nullable[LanguageCode]]
     r"""Optional language code for test"""
 
@@ -29,9 +28,9 @@ class DirectoryMemberTestExtensionRequest(BaseModel):
     ]
 
     timestamp: Annotated[
-        datetime, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
     ]
-    r"""Timestamp for test"""
+    r"""Timestamp for test in ISO 8601 format (e.g., 2025-12-04T14:29:39)"""
 
     language_code: Annotated[
         OptionalNullable[LanguageCode],

syllable_sdk/models/directory_member_updateop.py

@@ -2,14 +2,23 @@
 
 from __future__ import annotations
 from .directorymemberupdate import DirectoryMemberUpdate, DirectoryMemberUpdateTypedDict
+from .directoryresponseformat import DirectoryResponseFormat
 from syllable_sdk.types import BaseModel
-from syllable_sdk.utils import FieldMetadata, PathParamMetadata, RequestMetadata
-from typing_extensions import Annotated, TypedDict
+from syllable_sdk.utils import (
+    FieldMetadata,
+    PathParamMetadata,
+    QueryParamMetadata,
+    RequestMetadata,
+)
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class DirectoryMemberUpdateRequestTypedDict(TypedDict):
     member_id: int
     directory_member_update: DirectoryMemberUpdateTypedDict
+    response_format: NotRequired[DirectoryResponseFormat]
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""
 
 
 class DirectoryMemberUpdateRequest(BaseModel):
@@ -21,3 +30,9 @@ class DirectoryMemberUpdateRequest(BaseModel):
         DirectoryMemberUpdate,
         FieldMetadata(request=RequestMetadata(media_type="application/json")),
     ]
+
+    response_format: Annotated[
+        Optional[DirectoryResponseFormat],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""Directory response format: normalized (default) strips @hours and formats times; raw returns stored @hours values."""

syllable_sdk/models/directorymembertestresponse.py

@@ -14,17 +14,22 @@ from typing_extensions import NotRequired, TypedDict
 
 class DirectoryMemberTestResponseTypedDict(TypedDict):
     extension: NotRequired[Nullable[str]]
-    r"""Extension to which the user will be transferred if they call at the provided timestamp in the given language"""
+    r"""Extension to which the user will be transferred if they call at the provided timestamp in the given language, or a status message if no rules match"""
+    status: NotRequired[Nullable[str]]
+    r"""Status message if no rules match"""
 
 
 class DirectoryMemberTestResponse(BaseModel):
     extension: OptionalNullable[str] = UNSET
-    r"""Extension to which the user will be transferred if they call at the provided timestamp in the given language"""
+    r"""Extension to which the user will be transferred if they call at the provided timestamp in the given language, or a status message if no rules match"""
+
+    status: OptionalNullable[str] = UNSET
+    r"""Status message if no rules match"""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["extension"]
-        nullable_fields = ["extension"]
+        optional_fields = ["extension", "status"]
+        nullable_fields = ["extension", "status"]
         null_default_fields = []
 
         serialized = handler(self)

syllable_sdk/models/directoryresponseformat.py

@@ -0,0 +1,11 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class DirectoryResponseFormat(str, Enum):
+    r"""Response shape selector for directory member APIs."""
+
+    NORMALIZED = "normalized"
+    RAW = "raw"

syllable_sdk/models/eventtaskevents.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 from .callaction import CallAction, CallActionTypedDict
 from .incrementaction import IncrementAction, IncrementActionTypedDict
-from .saveaction import SaveAction, SaveActionTypedDict
 from .sayaction import SayAction, SayActionTypedDict
 from .setvalueaction import SetValueAction, SetValueActionTypedDict
 from pydantic import Discriminator, Tag, model_serializer
@@ -22,9 +21,8 @@ from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 EventTaskEventsStartTypedDict = TypeAliasType(
     "EventTaskEventsStartTypedDict",
     Union[
-        SayActionTypedDict,
-        SaveActionTypedDict,
         IncrementActionTypedDict,
+        SayActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
     ],
@@ -35,7 +33,6 @@ EventTaskEventsStart = Annotated[
     Union[
         Annotated[CallAction, Tag("call")],
         Annotated[IncrementAction, Tag("inc")],
-        Annotated[SaveAction, Tag("save")],
         Annotated[SayAction, Tag("say")],
         Annotated[SetValueAction, Tag("set")],
     ],

syllable_sdk/models/expressiontask.py

@@ -60,7 +60,7 @@ class ExpressionTaskTypedDict(TypedDict):
     expression: NotRequired[Nullable[Expression2TypedDict]]
     output: NotRequired[Nullable[Any]]
     on: NotRequired[ExpressionTaskEventsTypedDict]
-    r"""Actions to perform when events occur (enter, submit)."""
+    r"""Actions to perform when events occur (start, submit)."""
 
 
 class ExpressionTask(BaseModel):
@@ -97,7 +97,7 @@ class ExpressionTask(BaseModel):
     output: OptionalNullable[Any] = UNSET
 
     on: Optional[ExpressionTaskEvents] = None
-    r"""Actions to perform when events occur (enter, submit)."""
+    r"""Actions to perform when events occur (start, submit)."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):

syllable_sdk/models/expressiontaskevents.py

@@ -22,9 +22,8 @@ from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 ExpressionTaskEventsStartTypedDict = TypeAliasType(
     "ExpressionTaskEventsStartTypedDict",
     Union[
-        SayActionTypedDict,
-        SaveActionTypedDict,
         IncrementActionTypedDict,
+        SayActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
     ],
@@ -35,7 +34,6 @@ ExpressionTaskEventsStart = Annotated[
     Union[
         Annotated[CallAction, Tag("call")],
         Annotated[IncrementAction, Tag("inc")],
-        Annotated[SaveAction, Tag("save")],
         Annotated[SayAction, Tag("say")],
         Annotated[SetValueAction, Tag("set")],
     ],
@@ -47,8 +45,8 @@ ExpressionTaskEventsSubmitTypedDict = TypeAliasType(
     "ExpressionTaskEventsSubmitTypedDict",
     Union[
         IncrementActionTypedDict,
-        SayActionTypedDict,
         SaveActionTypedDict,
+        SayActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
     ],
@@ -68,7 +66,7 @@ ExpressionTaskEventsSubmit = Annotated[
 
 
 class ExpressionTaskEventsTypedDict(TypedDict):
-    r"""Actions to perform when events occur (enter, submit)."""
+    r"""Actions to perform when events occur (start, submit)."""
 
     start: NotRequired[Nullable[List[ExpressionTaskEventsStartTypedDict]]]
     r"""Actions to execute on the first input from the user."""
@@ -77,7 +75,7 @@ class ExpressionTaskEventsTypedDict(TypedDict):
 
 
 class ExpressionTaskEvents(BaseModel):
-    r"""Actions to perform when events occur (enter, submit)."""
+    r"""Actions to perform when events occur (start, submit)."""
 
     start: OptionalNullable[List[ExpressionTaskEventsStart]] = UNSET
     r"""Actions to execute on the first input from the user."""

syllable_sdk/models/getvalueaction.py

@@ -0,0 +1,151 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+from enum import Enum
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator
+from typing import Any, List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+GetValueActionValueFrom1TypedDict = TypeAliasType(
+    "GetValueActionValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+GetValueActionValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetValueActionValueFrom2TypedDict = TypeAliasType(
+    "GetValueActionValueFrom2TypedDict",
+    Union[CaseExpressionTypedDict, GetValueActionValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+GetValueActionValueFrom2 = TypeAliasType(
+    "GetValueActionValueFrom2", Union[CaseExpression, GetValueActionValueFrom1, str]
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+GetValueActionIf1TypedDict = TypeAliasType(
+    "GetValueActionIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+GetValueActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetValueActionIf2TypedDict = TypeAliasType(
+    "GetValueActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, GetValueActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+GetValueActionIf2 = TypeAliasType(
+    "GetValueActionIf2", Union[CaseExpression, GetValueActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class GetValueActionAction(str, Enum):
+    r"""Populate default input values."""
+
+    GET = "get"
+    LOAD = "load"
+
+
+class GetValueActionTypedDict(TypedDict):
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[GetValueActionValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    if_: NotRequired[Nullable[GetValueActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: NotRequired[GetValueActionAction]
+    r"""Populate default input values."""
+    inputs: NotRequired[Nullable[List[str]]]
+    r"""Input field names to populate; None populates all step inputs."""
+    overwrite: NotRequired[bool]
+    r"""If False (default), only populate empty inputs. If True, always overwrite."""
+
+
+class GetValueAction(BaseModel):
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[GetValueActionValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    if_: Annotated[OptionalNullable[GetValueActionIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    action: Optional[GetValueActionAction] = GetValueActionAction.GET
+    r"""Populate default input values."""
+
+    inputs: OptionalNullable[List[str]] = UNSET
+    r"""Input field names to populate; None populates all step inputs."""
+
+    overwrite: Optional[bool] = False
+    r"""If False (default), only populate empty inputs. If True, always overwrite."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["value", "value_from", "if", "action", "inputs", "overwrite"]
+        nullable_fields = ["value", "value_from", "if", "inputs"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/pronunciationoverridesdictionary.py

@@ -1,11 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .dictionarymetadata import DictionaryMetadata, DictionaryMetadataTypedDict
 from .pronunciationoverride import PronunciationOverride, PronunciationOverrideTypedDict
-from .schemas_tts_v1_pronunciations_dictionarymetadata import (
-    SchemasTtsV1PronunciationsDictionaryMetadata,
-    SchemasTtsV1PronunciationsDictionaryMetadataTypedDict,
-)
 from .voicedisplayinfo import VoiceDisplayInfo, VoiceDisplayInfoTypedDict
 from syllable_sdk.types import BaseModel
 from typing import Dict, List, Optional
@@ -35,7 +32,7 @@ class PronunciationOverridesDictionaryTypedDict(TypedDict):
     """
 
     pronunciations: List[PronunciationOverrideTypedDict]
-    metadata: SchemasTtsV1PronunciationsDictionaryMetadataTypedDict
+    metadata: DictionaryMetadataTypedDict
     r"""Audit metadata associated with a dictionary."""
     type: NotRequired[str]
     voices: NotRequired[Dict[str, VoiceDisplayInfoTypedDict]]
@@ -65,7 +62,7 @@ class PronunciationOverridesDictionary(BaseModel):
 
     pronunciations: List[PronunciationOverride]
 
-    metadata: SchemasTtsV1PronunciationsDictionaryMetadata
+    metadata: DictionaryMetadata
     r"""Audit metadata associated with a dictionary."""
 
     type: Optional[str] = "pronunciations_v1"