diff --git a/.stats.yml b/.stats.yml
index e335795..163ba63 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
 configured_endpoints: 9
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/lmnt-kaikato-aryp6r%2Flmnt-com-cd6e35232b72c91b7c58a77e81bc12247f69f118ebfe24ee5b6bad5d59683ff6.yml
-openapi_spec_hash: 657b7065d43bc0c630785b37195ff1e6
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/lmnt-kaikato-aryp6r%2Flmnt-com-e9b6dfacea7ad119a76705441211d3c25bbcc7c900f74685cd679a3bd84dac72.yml
+openapi_spec_hash: 3b34a0865020e8a6dcbc02e2bfc6c638
 config_hash: ad76a808facacf5f53e58d591653bac6
diff --git a/.sync_state b/.sync_state
index af94a4b..a966d36 100644
--- a/.sync_state
+++ b/.sync_state
@@ -1 +1 @@
-19a70f2d3733fb0c101046c37e116227f6f594f0
+9d6fd10cc3b0950f089efff59f40acfbd04378f6
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d561979..fe07cfd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Changelog
 
+## v2.3.0 (2025-09-03)
+
+Full Changelog: [v2.2.1...v2.3.0](https://github.com/lmnt-com/lmnt-python/compare/v2.2.1...v2.3.0)
+
+- replace ava with leah ([47bb854](https://github.com/lmnt-com/lmnt-python/commit/47bb854e04529deb4b29f5b816bbc20c0abe9a3e))
+- avoid newer type syntax ([773b08e](https://github.com/lmnt-com/lmnt-python/commit/773b08ee4f4b1456d21fe17cc09fe99789e663e4))
+- chore(internal): update pyright exclude list ([8c1bd1d](https://github.com/lmnt-com/lmnt-python/commit/8c1bd1deda2b735d001b52ca1458938bd10bca77))
+- feat(api): api update ([7820c00](https://github.com/lmnt-com/lmnt-python/commit/7820c00ae0e8e9ad867b23f35a16a9e6d51fba4c))
+- chore(internal): add Sequence related utils ([f1f239b](https://github.com/lmnt-com/lmnt-python/commit/f1f239b20585a2519c7477dcc84e7a7a4fac4d95))
+
+
 ## v2.2.1 (2025-08-21)
 
 Full Changelog: [v2.2.0...v2.2.1](https://github.com/lmnt-com/lmnt-python/compare/v2.2.0...v2.2.1)
diff --git a/mypy.ini b/mypy.ini
deleted file mode 100644
index ba9a000..0000000
--- a/mypy.ini
+++ /dev/null
@@ -1,50 +0,0 @@
-[mypy]
-pretty = True
-show_error_codes = True
-
-# Exclude _files.py because mypy isn't smart enough to apply
-# the correct type narrowing and as this is an internal module
-# it's fine to just use Pyright.
-#
-# We also exclude our `tests` as mypy doesn't always infer
-# types correctly and Pyright will still catch any type errors.
-exclude = ^(src/lmnt/_files\.py|_dev/.*\.py|tests/.*)$
-
-strict_equality = True
-implicit_reexport = True
-check_untyped_defs = True
-no_implicit_optional = True
-
-warn_return_any = True
-warn_unreachable = True
-warn_unused_configs = True
-
-# Turn these options off as it could cause conflicts
-# with the Pyright options.
-warn_unused_ignores = False
-warn_redundant_casts = False
-
-disallow_any_generics = True
-disallow_untyped_defs = True
-disallow_untyped_calls = True
-disallow_subclassing_any = True
-disallow_incomplete_defs = True
-disallow_untyped_decorators = True
-cache_fine_grained = True
-
-# By default, mypy reports an error if you assign a value to the result
-# of a function call that doesn't return anything. We do this in our test
-# cases:
-# ```
-# result = ...
-# assert result is None
-# ```
-# Changing this codegen to make mypy happy would increase complexity
-# and would not be worth it.
-disable_error_code = func-returns-value,overload-cannot-match
-
-# https://github.com/python/mypy/issues/12162
-[mypy.overrides]
-module = "black.files.*"
-ignore_errors = true
-ignore_missing_imports = true
diff --git a/pyproject.toml b/pyproject.toml
index bf132b9..7ec1c93 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "lmnt"
-version = "2.2.1"
+version = "2.3.0"
 description = "The official Python library for the LMNT API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -57,7 +57,6 @@ dev-dependencies = [
     "dirty-equals>=0.6.0",
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
-    "nest_asyncio==1.6.0",
     "pytest-xdist>=3.6.1",
 ]
 
@@ -149,6 +148,7 @@ exclude = [
     "_dev",
     ".venv",
     ".nox",
+    ".git",
 ]
 
 reportImplicitOverride = true
@@ -157,6 +157,58 @@ reportOverlappingOverload = false
 reportImportCycles = false
 reportPrivateUsage = false
 
+[tool.mypy]
+pretty = true
+show_error_codes = true
+
+# Exclude _files.py because mypy isn't smart enough to apply
+# the correct type narrowing and as this is an internal module
+# it's fine to just use Pyright.
+#
+# We also exclude our `tests` as mypy doesn't always infer
+# types correctly and Pyright will still catch any type errors.
+exclude = ['src/lmnt/_files.py', '_dev/.*.py', 'tests/.*']
+
+strict_equality = true
+implicit_reexport = true
+check_untyped_defs = true
+no_implicit_optional = true
+
+warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+
+# Turn these options off as it could cause conflicts
+# with the Pyright options.
+warn_unused_ignores = false
+warn_redundant_casts = false
+
+disallow_any_generics = true
+disallow_untyped_defs = true
+disallow_untyped_calls = true
+disallow_subclassing_any = true
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+cache_fine_grained = true
+
+# By default, mypy reports an error if you assign a value to the result
+# of a function call that doesn't return anything. We do this in our test
+# cases:
+# ```
+# result = ...
+# assert result is None
+# ```
+# Changing this codegen to make mypy happy would increase complexity
+# and would not be worth it.
+disable_error_code = "func-returns-value,overload-cannot-match"
+
+# https://github.com/python/mypy/issues/12162
+[[tool.mypy.overrides]]
+module = "black.files.*"
+ignore_errors = true
+ignore_missing_imports = true
+
+
 [tool.ruff]
 line-length = 120
 output-format = "grouped"
diff --git a/requirements-dev.lock b/requirements-dev.lock
index 2854519..8460e60 100644
--- a/requirements-dev.lock
+++ b/requirements-dev.lock
@@ -75,7 +75,6 @@ multidict==6.4.4
 mypy==1.14.1
 mypy-extensions==1.0.0
     # via mypy
-nest-asyncio==1.6.0
 nodeenv==1.8.0
     # via pyright
 nox==2023.4.22
diff --git a/src/lmnt/_base_client.py b/src/lmnt/_base_client.py
index 8dc1eb6..94c1b4d 100644
--- a/src/lmnt/_base_client.py
+++ b/src/lmnt/_base_client.py
@@ -59,7 +59,7 @@
     ModelBuilderProtocol,
 )
 from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping
-from ._compat import PYDANTIC_V2, model_copy, model_dump
+from ._compat import PYDANTIC_V1, model_copy, model_dump
 from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type
 from ._response import (
     APIResponse,
@@ -232,7 +232,7 @@ def _set_private_attributes(
         model: Type[_T],
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
@@ -320,7 +320,7 @@ def _set_private_attributes(
         client: AsyncAPIClient,
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
diff --git a/src/lmnt/_compat.py b/src/lmnt/_compat.py
index 92d9ee6..bdef67f 100644
--- a/src/lmnt/_compat.py
+++ b/src/lmnt/_compat.py
@@ -12,14 +12,13 @@
 _T = TypeVar("_T")
 _ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel)
 
-# --------------- Pydantic v2 compatibility ---------------
+# --------------- Pydantic v2, v3 compatibility ---------------
 
 # Pyright incorrectly reports some of our functions as overriding a method when they don't
 # pyright: reportIncompatibleMethodOverride=false
 
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 
-# v1 re-exports
 if TYPE_CHECKING:
 
     def parse_date(value: date | StrBytesIntFloat) -> date:  # noqa: ARG001
@@ -44,90 +43,92 @@ def is_typeddict(type_: type[Any]) -> bool:  # noqa: ARG001
         ...
 
 else:
-    if PYDANTIC_V2:
-        from pydantic.v1.typing import (
+    # v1 re-exports
+    if PYDANTIC_V1:
+        from pydantic.typing import (
             get_args as get_args,
             is_union as is_union,
             get_origin as get_origin,
             is_typeddict as is_typeddict,
             is_literal_type as is_literal_type,
         )
-        from pydantic.v1.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
+        from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
     else:
-        from pydantic.typing import (
+        from ._utils import (
             get_args as get_args,
             is_union as is_union,
             get_origin as get_origin,
+            parse_date as parse_date,
             is_typeddict as is_typeddict,
+            parse_datetime as parse_datetime,
             is_literal_type as is_literal_type,
         )
-        from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
 
 
 # refactored config
 if TYPE_CHECKING:
     from pydantic import ConfigDict as ConfigDict
 else:
-    if PYDANTIC_V2:
-        from pydantic import ConfigDict
-    else:
+    if PYDANTIC_V1:
         # TODO: provide an error message here?
         ConfigDict = None
+    else:
+        from pydantic import ConfigDict as ConfigDict
 
 
 # renamed methods / properties
 def parse_obj(model: type[_ModelT], value: object) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(value)
-    else:
+    if PYDANTIC_V1:
         return cast(_ModelT, model.parse_obj(value))  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+    else:
+        return model.model_validate(value)
 
 
 def field_is_required(field: FieldInfo) -> bool:
-    if PYDANTIC_V2:
-        return field.is_required()
-    return field.required  # type: ignore
+    if PYDANTIC_V1:
+        return field.required  # type: ignore
+    return field.is_required()
 
 
 def field_get_default(field: FieldInfo) -> Any:
     value = field.get_default()
-    if PYDANTIC_V2:
-        from pydantic_core import PydanticUndefined
-
-        if value == PydanticUndefined:
-            return None
+    if PYDANTIC_V1:
         return value
+    from pydantic_core import PydanticUndefined
+
+    if value == PydanticUndefined:
+        return None
     return value
 
 
 def field_outer_type(field: FieldInfo) -> Any:
-    if PYDANTIC_V2:
-        return field.annotation
-    return field.outer_type_  # type: ignore
+    if PYDANTIC_V1:
+        return field.outer_type_  # type: ignore
+    return field.annotation
 
 
 def get_model_config(model: type[pydantic.BaseModel]) -> Any:
-    if PYDANTIC_V2:
-        return model.model_config
-    return model.__config__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__config__  # type: ignore
+    return model.model_config
 
 
 def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V2:
-        return model.model_fields
-    return model.__fields__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__fields__  # type: ignore
+    return model.model_fields
 
 
 def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_copy(deep=deep)
-    return model.copy(deep=deep)  # type: ignore
+    if PYDANTIC_V1:
+        return model.copy(deep=deep)  # type: ignore
+    return model.model_copy(deep=deep)
 
 
 def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
-    if PYDANTIC_V2:
-        return model.model_dump_json(indent=indent)
-    return model.json(indent=indent)  # type: ignore
+    if PYDANTIC_V1:
+        return model.json(indent=indent)  # type: ignore
+    return model.model_dump_json(indent=indent)
 
 
 def model_dump(
@@ -139,14 +140,14 @@ def model_dump(
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
 ) -> dict[str, Any]:
-    if PYDANTIC_V2 or hasattr(model, "model_dump"):
+    if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
             mode=mode,
             exclude=exclude,
             exclude_unset=exclude_unset,
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
-            warnings=warnings if PYDANTIC_V2 else True,
+            warnings=True if PYDANTIC_V1 else warnings,
         )
     return cast(
         "dict[str, Any]",
@@ -159,9 +160,9 @@ def model_dump(
 
 
 def model_parse(model: type[_ModelT], data: Any) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(data)
-    return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    if PYDANTIC_V1:
+        return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate(data)
 
 
 # generic models
@@ -170,17 +171,16 @@ def model_parse(model: type[_ModelT], data: Any) -> _ModelT:
     class GenericModel(pydantic.BaseModel): ...
 
 else:
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        import pydantic.generics
+
+        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
+    else:
         # there no longer needs to be a distinction in v2 but
         # we still have to create our own subclass to avoid
         # inconsistent MRO ordering errors
         class GenericModel(pydantic.BaseModel): ...
 
-    else:
-        import pydantic.generics
-
-        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
-
 
 # cached properties
 if TYPE_CHECKING:
diff --git a/src/lmnt/_models.py b/src/lmnt/_models.py
index b8387ce..3a6017e 100644
--- a/src/lmnt/_models.py
+++ b/src/lmnt/_models.py
@@ -50,7 +50,7 @@
     strip_annotated_type,
 )
 from ._compat import (
-    PYDANTIC_V2,
+    PYDANTIC_V1,
     ConfigDict,
     GenericModel as BaseGenericModel,
     get_args,
@@ -81,11 +81,7 @@ class _ConfigProtocol(Protocol):
 
 
 class BaseModel(pydantic.BaseModel):
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(
-            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
-        )
-    else:
+    if PYDANTIC_V1:
 
         @property
         @override
@@ -95,6 +91,10 @@ def model_fields_set(self) -> set[str]:
 
         class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
             extra: Any = pydantic.Extra.allow  # type: ignore
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(
+            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
+        )
 
     def to_dict(
         self,
@@ -215,25 +215,25 @@ def construct(  # pyright: ignore[reportIncompatibleMethodOverride]
             if key not in model_fields:
                 parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
 
-                if PYDANTIC_V2:
-                    _extra[key] = parsed
-                else:
+                if PYDANTIC_V1:
                     _fields_set.add(key)
                     fields_values[key] = parsed
+                else:
+                    _extra[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
-        if PYDANTIC_V2:
-            # these properties are copied from Pydantic's `model_construct()` method
-            object.__setattr__(m, "__pydantic_private__", None)
-            object.__setattr__(m, "__pydantic_extra__", _extra)
-            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
-        else:
+        if PYDANTIC_V1:
             # init_private_attributes() does not exist in v2
             m._init_private_attributes()  # type: ignore
 
             # copied from Pydantic v1's `construct()` method
             object.__setattr__(m, "__fields_set__", _fields_set)
+        else:
+            # these properties are copied from Pydantic's `model_construct()` method
+            object.__setattr__(m, "__pydantic_private__", None)
+            object.__setattr__(m, "__pydantic_extra__", _extra)
+            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
 
         return m
 
@@ -243,7 +243,7 @@ def construct(  # pyright: ignore[reportIncompatibleMethodOverride]
         # although not in practice
         model_construct = construct
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         # we define aliases for some of the new pydantic v2 methods so
         # that we can just document these methods without having to specify
         # a specific pydantic version as some users may not know which
@@ -304,7 +304,7 @@ def model_dump(
                 exclude_none=exclude_none,
             )
 
-            return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped
+            return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped
 
         @override
         def model_dump_json(
@@ -363,10 +363,10 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if value is None:
         return field_get_default(field)
 
-    if PYDANTIC_V2:
-        type_ = field.annotation
-    else:
+    if PYDANTIC_V1:
         type_ = cast(type, field.outer_type_)  # type: ignore
+    else:
+        type_ = field.annotation  # type: ignore
 
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
@@ -375,7 +375,7 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
 
 
 def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         # TODO
         return None
 
@@ -628,30 +628,30 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
     for variant in get_args(union):
         variant = strip_annotated_type(variant)
         if is_basemodel_type(variant):
-            if PYDANTIC_V2:
-                field = _extract_field_schema_pv2(variant, discriminator_field_name)
-                if not field:
+            if PYDANTIC_V1:
+                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+                if not field_info:
                     continue
 
                 # Note: if one variant defines an alias then they all should
-                discriminator_alias = field.get("serialization_alias")
-
-                field_schema = field["schema"]
+                discriminator_alias = field_info.alias
 
-                if field_schema["type"] == "literal":
-                    for entry in cast("LiteralSchema", field_schema)["expected"]:
+                if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation):
+                    for entry in get_args(annotation):
                         if isinstance(entry, str):
                             mapping[entry] = variant
             else:
-                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-                if not field_info:
+                field = _extract_field_schema_pv2(variant, discriminator_field_name)
+                if not field:
                     continue
 
                 # Note: if one variant defines an alias then they all should
-                discriminator_alias = field_info.alias
+                discriminator_alias = field.get("serialization_alias")
 
-                if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation):
-                    for entry in get_args(annotation):
+                field_schema = field["schema"]
+
+                if field_schema["type"] == "literal":
+                    for entry in cast("LiteralSchema", field_schema)["expected"]:
                         if isinstance(entry, str):
                             mapping[entry] = variant
 
@@ -714,7 +714,7 @@ class GenericModel(BaseGenericModel, BaseModel):
         pass
 
 
-if PYDANTIC_V2:
+if not PYDANTIC_V1:
     from pydantic import TypeAdapter as _TypeAdapter
 
     _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter))
@@ -782,12 +782,12 @@ class FinalRequestOptions(pydantic.BaseModel):
     json_data: Union[Body, None] = None
     extra_json: Union[AnyMapping, None] = None
 
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
-    else:
+    if PYDANTIC_V1:
 
         class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
             arbitrary_types_allowed: bool = True
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
 
     def get_max_retries(self, max_retries: int) -> int:
         if isinstance(self.max_retries, NotGiven):
@@ -820,9 +820,9 @@ def construct(  # type: ignore
             key: strip_not_given(value)
             for key, value in values.items()
         }
-        if PYDANTIC_V2:
-            return super().model_construct(_fields_set, **kwargs)
-        return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        if PYDANTIC_V1:
+            return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        return super().model_construct(_fields_set, **kwargs)
 
     if not TYPE_CHECKING:
         # type checkers incorrectly complain about this assignment
diff --git a/src/lmnt/_types.py b/src/lmnt/_types.py
index f789ccd..8ca055d 100644
--- a/src/lmnt/_types.py
+++ b/src/lmnt/_types.py
@@ -13,10 +13,21 @@
     Mapping,
     TypeVar,
     Callable,
+    Iterator,
     Optional,
     Sequence,
 )
-from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable
+from typing_extensions import (
+    Set,
+    Literal,
+    Protocol,
+    TypeAlias,
+    TypedDict,
+    SupportsIndex,
+    overload,
+    override,
+    runtime_checkable,
+)
 
 import httpx
 import pydantic
@@ -217,3 +228,26 @@ class _GenericAlias(Protocol):
 class HttpxSendArgs(TypedDict, total=False):
     auth: httpx.Auth
     follow_redirects: bool
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+
+if TYPE_CHECKING:
+    # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
+    # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    class SequenceNotStr(Protocol[_T_co]):
+        @overload
+        def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
+        @overload
+        def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ...
+        def __contains__(self, value: object, /) -> bool: ...
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[_T_co]: ...
+        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
+        def count(self, value: Any, /) -> int: ...
+        def __reversed__(self) -> Iterator[_T_co]: ...
+else:
+    # just point this to a normal `Sequence` at runtime to avoid having to special case
+    # deserializing our custom sequence type
+    SequenceNotStr = Sequence
diff --git a/src/lmnt/_utils/__init__.py b/src/lmnt/_utils/__init__.py
index d4fda26..dc64e29 100644
--- a/src/lmnt/_utils/__init__.py
+++ b/src/lmnt/_utils/__init__.py
@@ -10,7 +10,6 @@
     lru_cache as lru_cache,
     is_mapping as is_mapping,
     is_tuple_t as is_tuple_t,
-    parse_date as parse_date,
     is_iterable as is_iterable,
     is_sequence as is_sequence,
     coerce_float as coerce_float,
@@ -23,7 +22,6 @@
     coerce_boolean as coerce_boolean,
     coerce_integer as coerce_integer,
     file_from_path as file_from_path,
-    parse_datetime as parse_datetime,
     strip_not_given as strip_not_given,
     deepcopy_minimal as deepcopy_minimal,
     get_async_library as get_async_library,
@@ -32,12 +30,20 @@
     maybe_coerce_boolean as maybe_coerce_boolean,
     maybe_coerce_integer as maybe_coerce_integer,
 )
+from ._compat import (
+    get_args as get_args,
+    is_union as is_union,
+    get_origin as get_origin,
+    is_typeddict as is_typeddict,
+    is_literal_type as is_literal_type,
+)
 from ._typing import (
     is_list_type as is_list_type,
     is_union_type as is_union_type,
     extract_type_arg as extract_type_arg,
     is_iterable_type as is_iterable_type,
     is_required_type as is_required_type,
+    is_sequence_type as is_sequence_type,
     is_annotated_type as is_annotated_type,
     is_type_alias_type as is_type_alias_type,
     strip_annotated_type as strip_annotated_type,
@@ -55,3 +61,4 @@
     function_has_argument as function_has_argument,
     assert_signatures_in_sync as assert_signatures_in_sync,
 )
+from ._datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
diff --git a/src/lmnt/_utils/_compat.py b/src/lmnt/_utils/_compat.py
new file mode 100644
index 0000000..dd70323
--- /dev/null
+++ b/src/lmnt/_utils/_compat.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import sys
+import typing_extensions
+from typing import Any, Type, Union, Literal, Optional
+from datetime import date, datetime
+from typing_extensions import get_args as _get_args, get_origin as _get_origin
+
+from .._types import StrBytesIntFloat
+from ._datetime_parse import parse_date as _parse_date, parse_datetime as _parse_datetime
+
+_LITERAL_TYPES = {Literal, typing_extensions.Literal}
+
+
+def get_args(tp: type[Any]) -> tuple[Any, ...]:
+    return _get_args(tp)
+
+
+def get_origin(tp: type[Any]) -> type[Any] | None:
+    return _get_origin(tp)
+
+
+def is_union(tp: Optional[Type[Any]]) -> bool:
+    if sys.version_info < (3, 10):
+        return tp is Union  # type: ignore[comparison-overlap]
+    else:
+        import types
+
+        return tp is Union or tp is types.UnionType
+
+
+def is_typeddict(tp: Type[Any]) -> bool:
+    return typing_extensions.is_typeddict(tp)
+
+
+def is_literal_type(tp: Type[Any]) -> bool:
+    return get_origin(tp) in _LITERAL_TYPES
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    return _parse_date(value)
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    return _parse_datetime(value)
diff --git a/src/lmnt/_utils/_datetime_parse.py b/src/lmnt/_utils/_datetime_parse.py
new file mode 100644
index 0000000..7cb9d9e
--- /dev/null
+++ b/src/lmnt/_utils/_datetime_parse.py
@@ -0,0 +1,136 @@
+"""
+This file contains code from https://github.com/pydantic/pydantic/blob/main/pydantic/v1/datetime_parse.py
+without the Pydantic v1 specific errors.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, Union, Optional
+from datetime import date, datetime, timezone, timedelta
+
+from .._types import StrBytesIntFloat
+
+date_expr = r"(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})"
+time_expr = (
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{1,2})"
+    r"(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?"
+    r"(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$"
+)
+
+date_re = re.compile(f"{date_expr}$")
+datetime_re = re.compile(f"{date_expr}[T ]{time_expr}")
+
+
+EPOCH = datetime(1970, 1, 1)
+# if greater than this, the number is in ms, if less than or equal it's in seconds
+# (in seconds this is 11th October 2603, in ms it's 20th August 1970)
+MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
+
+
+def _get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]:
+    if isinstance(value, (int, float)):
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return None
+    except TypeError:
+        raise TypeError(f"invalid type; expected {native_expected_type}, string, bytes, int or float") from None
+
+
+def _from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
+    while abs(seconds) > MS_WATERSHED:
+        seconds /= 1000
+    dt = EPOCH + timedelta(seconds=seconds)
+    return dt.replace(tzinfo=timezone.utc)
+
+
+def _parse_timezone(value: Optional[str]) -> Union[None, int, timezone]:
+    if value == "Z":
+        return timezone.utc
+    elif value is not None:
+        offset_mins = int(value[-2:]) if len(value) > 3 else 0
+        offset = 60 * int(value[1:3]) + offset_mins
+        if value[0] == "-":
+            offset = -offset
+        return timezone(timedelta(minutes=offset))
+    else:
+        return None
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    """
+    Parse a datetime/int/float/string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, datetime):
+        return value
+
+    number = _get_numeric(value, "datetime")
+    if number is not None:
+        return _from_unix_seconds(number)
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+
+    match = datetime_re.match(value)
+    if match is None:
+        raise ValueError("invalid datetime format")
+
+    kw = match.groupdict()
+    if kw["microsecond"]:
+        kw["microsecond"] = kw["microsecond"].ljust(6, "0")
+
+    tzinfo = _parse_timezone(kw.pop("tzinfo"))
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_["tzinfo"] = tzinfo
+
+    return datetime(**kw_)  # type: ignore
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    """
+    Parse a date/int/float/string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, date):
+        if isinstance(value, datetime):
+            return value.date()
+        else:
+            return value
+
+    number = _get_numeric(value, "date")
+    if number is not None:
+        return _from_unix_seconds(number).date()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+    match = date_re.match(value)
+    if match is None:
+        raise ValueError("invalid date format")
+
+    kw = {k: int(v) for k, v in match.groupdict().items()}
+
+    try:
+        return date(**kw)
+    except ValueError:
+        raise ValueError("invalid date format") from None
diff --git a/src/lmnt/_utils/_transform.py b/src/lmnt/_utils/_transform.py
index b0cc20a..c19124f 100644
--- a/src/lmnt/_utils/_transform.py
+++ b/src/lmnt/_utils/_transform.py
@@ -16,18 +16,20 @@
     lru_cache,
     is_mapping,
     is_iterable,
+    is_sequence,
 )
 from .._files import is_base64_file_input
+from ._compat import get_origin, is_typeddict
 from ._typing import (
     is_list_type,
     is_union_type,
     extract_type_arg,
     is_iterable_type,
     is_required_type,
+    is_sequence_type,
     is_annotated_type,
     strip_annotated_type,
 )
-from .._compat import get_origin, model_dump, is_typeddict
 
 _T = TypeVar("_T")
 
@@ -167,6 +169,8 @@ def _transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -184,6 +188,8 @@ def _transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -329,6 +335,8 @@ async def _async_transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -346,6 +354,8 @@ async def _async_transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
diff --git a/src/lmnt/_utils/_typing.py b/src/lmnt/_utils/_typing.py
index 1bac954..193109f 100644
--- a/src/lmnt/_utils/_typing.py
+++ b/src/lmnt/_utils/_typing.py
@@ -15,7 +15,7 @@
 
 from ._utils import lru_cache
 from .._types import InheritsGeneric
-from .._compat import is_union as _is_union
+from ._compat import is_union as _is_union
 
 
 def is_annotated_type(typ: type) -> bool:
@@ -26,6 +26,11 @@ def is_list_type(typ: type) -> bool:
     return (get_origin(typ) or typ) == list
 
 
+def is_sequence_type(typ: type) -> bool:
+    origin = get_origin(typ) or typ
+    return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence
+
+
 def is_iterable_type(typ: type) -> bool:
     """If the given type is `typing.Iterable[T]`"""
     origin = get_origin(typ) or typ
diff --git a/src/lmnt/_utils/_utils.py b/src/lmnt/_utils/_utils.py
index ea3cf3f..f081859 100644
--- a/src/lmnt/_utils/_utils.py
+++ b/src/lmnt/_utils/_utils.py
@@ -22,7 +22,6 @@
 import sniffio
 
 from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike
-from .._compat import parse_date as parse_date, parse_datetime as parse_datetime
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])
diff --git a/src/lmnt/resources/speech.py b/src/lmnt/resources/speech.py
index 9fe3927..5105a44 100644
--- a/src/lmnt/resources/speech.py
+++ b/src/lmnt/resources/speech.py
@@ -58,7 +58,7 @@ def convert(
         *,
         audio: FileTypes,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -110,9 +110,10 @@ def convert(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
@@ -162,7 +163,7 @@ def generate(
         *,
         text: str,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -222,9 +223,10 @@ def generate(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
@@ -287,7 +289,7 @@ def generate_detailed(
         *,
         text: str,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -346,9 +348,10 @@ def generate_detailed(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
@@ -438,7 +441,7 @@ async def convert(
         *,
         audio: FileTypes,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -490,9 +493,10 @@ async def convert(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
@@ -542,7 +546,7 @@ async def generate(
         *,
         text: str,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -602,9 +606,10 @@ async def generate(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
@@ -667,7 +672,7 @@ async def generate_detailed(
         *,
         text: str,
         voice: str,
-        format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"] | NotGiven = NOT_GIVEN,
+        format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"] | NotGiven = NOT_GIVEN,
         language: Literal[
             "auto",
             "ar",
@@ -726,9 +731,10 @@ async def generate_detailed(
               Streamable formats:
 
               - `mp3`: 96kbps MP3 audio.
-              - `raw`: 32-bit floating point raw audio.
               - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
               - `webm`: WebM format with Opus audio codec.
+              - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+              - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
               Non-streamable formats:
 
diff --git a/src/lmnt/resources/voices.py b/src/lmnt/resources/voices.py
index dcd55f3..0eb0f45 100644
--- a/src/lmnt/resources/voices.py
+++ b/src/lmnt/resources/voices.py
@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List, Mapping, cast
+from typing import Mapping, cast
 
 import httpx
 
 from ..types import voice_list_params, voice_create_params, voice_update_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes, SequenceNotStr
 from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
@@ -50,7 +50,7 @@ def create(
         self,
         *,
         enhance: bool,
-        files: List[FileTypes],
+        files: SequenceNotStr[FileTypes],
         name: str,
         description: str | NotGiven = NOT_GIVEN,
         gender: str | NotGiven = NOT_GIVEN,
@@ -309,7 +309,7 @@ async def create(
         self,
         *,
         enhance: bool,
-        files: List[FileTypes],
+        files: SequenceNotStr[FileTypes],
         name: str,
         description: str | NotGiven = NOT_GIVEN,
         gender: str | NotGiven = NOT_GIVEN,
diff --git a/src/lmnt/types/speech_convert_params.py b/src/lmnt/types/speech_convert_params.py
index 7626934..4709fd5 100644
--- a/src/lmnt/types/speech_convert_params.py
+++ b/src/lmnt/types/speech_convert_params.py
@@ -23,7 +23,7 @@ class SpeechConvertParams(TypedDict, total=False):
     Voice ids can be retrieved by calls to `List voices` or `Voice info`.
     """
 
-    format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"]
+    format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"]
     """The desired output format of the audio.
 
     If you are using a streaming endpoint, you'll generate audio faster by selecting
@@ -34,9 +34,10 @@ class SpeechConvertParams(TypedDict, total=False):
     Streamable formats:
 
     - `mp3`: 96kbps MP3 audio.
-    - `raw`: 32-bit floating point raw audio.
     - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
     - `webm`: WebM format with Opus audio codec.
+    - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+    - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
     Non-streamable formats:
 
diff --git a/src/lmnt/types/speech_generate_detailed_params.py b/src/lmnt/types/speech_generate_detailed_params.py
index 6bb9047..f7420b5 100644
--- a/src/lmnt/types/speech_generate_detailed_params.py
+++ b/src/lmnt/types/speech_generate_detailed_params.py
@@ -17,7 +17,7 @@ class SpeechGenerateDetailedParams(TypedDict, total=False):
     `List voices` or `Voice info`.
     """
 
-    format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"]
+    format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"]
     """The desired output format of the audio.
 
     If you are using a streaming endpoint, you'll generate audio faster by selecting
@@ -28,9 +28,10 @@ class SpeechGenerateDetailedParams(TypedDict, total=False):
     Streamable formats:
 
     - `mp3`: 96kbps MP3 audio.
-    - `raw`: 32-bit floating point raw audio.
     - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
     - `webm`: WebM format with Opus audio codec.
+    - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+    - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
     Non-streamable formats:
 
diff --git a/src/lmnt/types/speech_generate_params.py b/src/lmnt/types/speech_generate_params.py
index 71c9ee1..ef3cdbd 100644
--- a/src/lmnt/types/speech_generate_params.py
+++ b/src/lmnt/types/speech_generate_params.py
@@ -17,7 +17,7 @@ class SpeechGenerateParams(TypedDict, total=False):
     `List voices` or `Voice info`.
     """
 
-    format: Literal["aac", "mp3", "raw", "ulaw", "wav", "webm"]
+    format: Literal["aac", "mp3", "ulaw", "wav", "webm", "pcm_s16le", "pcm_f32le"]
     """The desired output format of the audio.
 
     If you are using a streaming endpoint, you'll generate audio faster by selecting
@@ -28,9 +28,10 @@ class SpeechGenerateParams(TypedDict, total=False):
     Streamable formats:
 
     - `mp3`: 96kbps MP3 audio.
-    - `raw`: 32-bit floating point raw audio.
     - `ulaw`: 8-bit G711 µ-law audio with a WAV header.
     - `webm`: WebM format with Opus audio codec.
+    - `pcm_s16le`: PCM signed 16-bit little-endian audio.
+    - `pcm_f32le`: PCM 32-bit floating-point little-endian audio.
 
     Non-streamable formats:
 
diff --git a/src/lmnt/types/voice_create_params.py b/src/lmnt/types/voice_create_params.py
index efcc749..1b69cd0 100644
--- a/src/lmnt/types/voice_create_params.py
+++ b/src/lmnt/types/voice_create_params.py
@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
-from .._types import FileTypes
+from .._types import FileTypes, SequenceNotStr
 
 __all__ = ["VoiceCreateParams"]
 
@@ -18,7 +17,7 @@ class VoiceCreateParams(TypedDict, total=False):
     circumstances.
     """
 
-    files: Required[List[FileTypes]]
+    files: Required[SequenceNotStr[FileTypes]]
     """
     One or more input audio files to train the voice in the form of binary `wav`,
     `mp3`, `mp4`, `m4a`, or `webm` attachments.
diff --git a/tests/api_resources/test_speech.py b/tests/api_resources/test_speech.py
index 5227364..a92eaba 100644
--- a/tests/api_resources/test_speech.py
+++ b/tests/api_resources/test_speech.py
@@ -33,7 +33,7 @@ def test_method_convert(self, client: Lmnt, respx_mock: MockRouter) -> None:
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = client.speech.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         )
         assert speech.is_closed
         assert speech.json() == {"foo": "bar"}
@@ -46,7 +46,7 @@ def test_method_convert_with_all_params(self, client: Lmnt, respx_mock: MockRout
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = client.speech.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             sample_rate=8000,
@@ -63,7 +63,7 @@ def test_raw_response_convert(self, client: Lmnt, respx_mock: MockRouter) -> Non
 
         speech = client.speech.with_raw_response.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         )
 
         assert speech.is_closed is True
@@ -77,7 +77,7 @@ def test_streaming_response_convert(self, client: Lmnt, respx_mock: MockRouter)
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         with client.speech.with_streaming_response.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         ) as speech:
             assert not speech.is_closed
             assert speech.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -94,7 +94,7 @@ def test_method_generate(self, client: Lmnt, respx_mock: MockRouter) -> None:
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = client.speech.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
         assert speech.is_closed
         assert speech.json() == {"foo": "bar"}
@@ -107,7 +107,7 @@ def test_method_generate_with_all_params(self, client: Lmnt, respx_mock: MockRou
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = client.speech.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             model="blizzard",
@@ -128,7 +128,7 @@ def test_raw_response_generate(self, client: Lmnt, respx_mock: MockRouter) -> No
 
         speech = client.speech.with_raw_response.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
 
         assert speech.is_closed is True
@@ -142,7 +142,7 @@ def test_streaming_response_generate(self, client: Lmnt, respx_mock: MockRouter)
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         with client.speech.with_streaming_response.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         ) as speech:
             assert not speech.is_closed
             assert speech.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -157,7 +157,7 @@ def test_streaming_response_generate(self, client: Lmnt, respx_mock: MockRouter)
     def test_method_generate_detailed(self, client: Lmnt) -> None:
         speech = client.speech.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
         assert_matches_type(SpeechGenerateDetailedResponse, speech, path=["response"])
 
@@ -165,7 +165,7 @@ def test_method_generate_detailed(self, client: Lmnt) -> None:
     def test_method_generate_detailed_with_all_params(self, client: Lmnt) -> None:
         speech = client.speech.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             model="blizzard",
@@ -181,7 +181,7 @@ def test_method_generate_detailed_with_all_params(self, client: Lmnt) -> None:
     def test_raw_response_generate_detailed(self, client: Lmnt) -> None:
         response = client.speech.with_raw_response.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
 
         assert response.is_closed is True
@@ -193,7 +193,7 @@ def test_raw_response_generate_detailed(self, client: Lmnt) -> None:
     def test_streaming_response_generate_detailed(self, client: Lmnt) -> None:
         with client.speech.with_streaming_response.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -215,7 +215,7 @@ async def test_method_convert(self, async_client: AsyncLmnt, respx_mock: MockRou
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = await async_client.speech.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         )
         assert speech.is_closed
         assert await speech.json() == {"foo": "bar"}
@@ -228,7 +228,7 @@ async def test_method_convert_with_all_params(self, async_client: AsyncLmnt, res
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = await async_client.speech.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             sample_rate=8000,
@@ -245,7 +245,7 @@ async def test_raw_response_convert(self, async_client: AsyncLmnt, respx_mock: M
 
         speech = await async_client.speech.with_raw_response.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         )
 
         assert speech.is_closed is True
@@ -259,7 +259,7 @@ async def test_streaming_response_convert(self, async_client: AsyncLmnt, respx_m
         respx_mock.post("/v1/ai/speech/convert").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         async with async_client.speech.with_streaming_response.convert(
             audio=b"raw file contents",
-            voice="ava",
+            voice="leah",
         ) as speech:
             assert not speech.is_closed
             assert speech.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -276,7 +276,7 @@ async def test_method_generate(self, async_client: AsyncLmnt, respx_mock: MockRo
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = await async_client.speech.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
         assert speech.is_closed
         assert await speech.json() == {"foo": "bar"}
@@ -289,7 +289,7 @@ async def test_method_generate_with_all_params(self, async_client: AsyncLmnt, re
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         speech = await async_client.speech.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             model="blizzard",
@@ -310,7 +310,7 @@ async def test_raw_response_generate(self, async_client: AsyncLmnt, respx_mock:
 
         speech = await async_client.speech.with_raw_response.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
 
         assert speech.is_closed is True
@@ -324,7 +324,7 @@ async def test_streaming_response_generate(self, async_client: AsyncLmnt, respx_
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(200, json={"foo": "bar"}))
         async with async_client.speech.with_streaming_response.generate(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         ) as speech:
             assert not speech.is_closed
             assert speech.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -339,7 +339,7 @@ async def test_streaming_response_generate(self, async_client: AsyncLmnt, respx_
     async def test_method_generate_detailed(self, async_client: AsyncLmnt) -> None:
         speech = await async_client.speech.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
         assert_matches_type(SpeechGenerateDetailedResponse, speech, path=["response"])
 
@@ -347,7 +347,7 @@ async def test_method_generate_detailed(self, async_client: AsyncLmnt) -> None:
     async def test_method_generate_detailed_with_all_params(self, async_client: AsyncLmnt) -> None:
         speech = await async_client.speech.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
             format="aac",
             language="auto",
             model="blizzard",
@@ -363,7 +363,7 @@ async def test_method_generate_detailed_with_all_params(self, async_client: Asyn
     async def test_raw_response_generate_detailed(self, async_client: AsyncLmnt) -> None:
         response = await async_client.speech.with_raw_response.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         )
 
         assert response.is_closed is True
@@ -375,7 +375,7 @@ async def test_raw_response_generate_detailed(self, async_client: AsyncLmnt) ->
     async def test_streaming_response_generate_detailed(self, async_client: AsyncLmnt) -> None:
         async with async_client.speech.with_streaming_response.generate_detailed(
             text="hello world.",
-            voice="ava",
+            voice="leah",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
diff --git a/tests/test_client.py b/tests/test_client.py
index de66e57..0c7ce38 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -6,13 +6,10 @@
 import os
 import sys
 import json
-import time
 import asyncio
 import inspect
-import subprocess
 import tracemalloc
 from typing import Any, Union, cast
-from textwrap import dedent
 from unittest import mock
 from typing_extensions import Literal
 
@@ -23,14 +20,17 @@
 
 from lmnt import Lmnt, AsyncLmnt, APIResponseValidationError
 from lmnt._types import Omit
+from lmnt._utils import asyncify
 from lmnt._models import BaseModel, FinalRequestOptions
 from lmnt._exceptions import APIStatusError, APITimeoutError, APIResponseValidationError
 from lmnt._base_client import (
     DEFAULT_TIMEOUT,
     HTTPX_DEFAULT_TIMEOUT,
     BaseClient,
+    OtherPlatform,
     DefaultHttpxClient,
     DefaultAsyncHttpxClient,
+    get_platform,
     make_request_options,
 )
 
@@ -699,7 +699,7 @@ def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, clien
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            client.speech.with_streaming_response.generate(text="hello world.", voice="ava").__enter__()
+            client.speech.with_streaming_response.generate(text="hello world.", voice="leah").__enter__()
 
         assert _get_open_connections(self.client) == 0
 
@@ -709,7 +709,7 @@ def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            client.speech.with_streaming_response.generate(text="hello world.", voice="ava").__enter__()
+            client.speech.with_streaming_response.generate(text="hello world.", voice="leah").__enter__()
         assert _get_open_connections(self.client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
@@ -738,7 +738,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
 
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
-        response = client.speech.with_raw_response.generate(text="hello world.", voice="ava")
+        response = client.speech.with_raw_response.generate(text="hello world.", voice="leah")
 
         assert response.retries_taken == failures_before_success
         assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
@@ -761,7 +761,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
         response = client.speech.with_raw_response.generate(
-            text="hello world.", voice="ava", extra_headers={"x-stainless-retry-count": Omit()}
+            text="hello world.", voice="leah", extra_headers={"x-stainless-retry-count": Omit()}
         )
 
         assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0
@@ -786,7 +786,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
         response = client.speech.with_raw_response.generate(
-            text="hello world.", voice="ava", extra_headers={"x-stainless-retry-count": "42"}
+            text="hello world.", voice="leah", extra_headers={"x-stainless-retry-count": "42"}
         )
 
         assert response.http_request.headers.get("x-stainless-retry-count") == "42"
@@ -1496,7 +1496,7 @@ async def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter,
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=httpx.TimeoutException("Test timeout error"))
 
         with pytest.raises(APITimeoutError):
-            await async_client.speech.with_streaming_response.generate(text="hello world.", voice="ava").__aenter__()
+            await async_client.speech.with_streaming_response.generate(text="hello world.", voice="leah").__aenter__()
 
         assert _get_open_connections(self.client) == 0
 
@@ -1506,7 +1506,7 @@ async def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter,
         respx_mock.post("/v1/ai/speech/bytes").mock(return_value=httpx.Response(500))
 
         with pytest.raises(APIStatusError):
-            await async_client.speech.with_streaming_response.generate(text="hello world.", voice="ava").__aenter__()
+            await async_client.speech.with_streaming_response.generate(text="hello world.", voice="leah").__aenter__()
         assert _get_open_connections(self.client) == 0
 
     @pytest.mark.parametrize("failures_before_success", [0, 2, 4])
@@ -1536,7 +1536,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
 
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
-        response = await client.speech.with_raw_response.generate(text="hello world.", voice="ava")
+        response = await client.speech.with_raw_response.generate(text="hello world.", voice="leah")
 
         assert response.retries_taken == failures_before_success
         assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success
@@ -1562,7 +1562,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
         response = await client.speech.with_raw_response.generate(
-            text="hello world.", voice="ava", extra_headers={"x-stainless-retry-count": Omit()}
+            text="hello world.", voice="leah", extra_headers={"x-stainless-retry-count": Omit()}
         )
 
         assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0
@@ -1588,55 +1588,14 @@ def retry_handler(_request: httpx.Request) -> httpx.Response:
         respx_mock.post("/v1/ai/speech/bytes").mock(side_effect=retry_handler)
 
         response = await client.speech.with_raw_response.generate(
-            text="hello world.", voice="ava", extra_headers={"x-stainless-retry-count": "42"}
+            text="hello world.", voice="leah", extra_headers={"x-stainless-retry-count": "42"}
         )
 
         assert response.http_request.headers.get("x-stainless-retry-count") == "42"
 
-    def test_get_platform(self) -> None:
-        # A previous implementation of asyncify could leave threads unterminated when
-        # used with nest_asyncio.
-        #
-        # Since nest_asyncio.apply() is global and cannot be un-applied, this
-        # test is run in a separate process to avoid affecting other tests.
-        test_code = dedent("""
-        import asyncio
-        import nest_asyncio
-        import threading
-
-        from lmnt._utils import asyncify
-        from lmnt._base_client import get_platform
-
-        async def test_main() -> None:
-            result = await asyncify(get_platform)()
-            print(result)
-            for thread in threading.enumerate():
-                print(thread.name)
-
-        nest_asyncio.apply()
-        asyncio.run(test_main())
-        """)
-        with subprocess.Popen(
-            [sys.executable, "-c", test_code],
-            text=True,
-        ) as process:
-            timeout = 10  # seconds
-
-            start_time = time.monotonic()
-            while True:
-                return_code = process.poll()
-                if return_code is not None:
-                    if return_code != 0:
-                        raise AssertionError("calling get_platform using asyncify resulted in a non-zero exit code")
-
-                    # success
-                    break
-
-                if time.monotonic() - start_time > timeout:
-                    process.kill()
-                    raise AssertionError("calling get_platform using asyncify resulted in a hung process")
-
-                time.sleep(0.1)
+    async def test_get_platform(self) -> None:
+        platform = await asyncify(get_platform)()
+        assert isinstance(platform, (str, OtherPlatform))
 
     async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None:
         # Test that the proxy environment variables are set correctly
diff --git a/tests/test_models.py b/tests/test_models.py
index e5f1915..6b79ffc 100644
--- a/tests/test_models.py
+++ b/tests/test_models.py
@@ -8,7 +8,7 @@
 from pydantic import Field
 
 from lmnt._utils import PropertyInfo
-from lmnt._compat import PYDANTIC_V2, parse_obj, model_dump, model_json
+from lmnt._compat import PYDANTIC_V1, parse_obj, model_dump, model_json
 from lmnt._models import BaseModel, construct_type
 
 
@@ -294,12 +294,12 @@ class Model(BaseModel):
     assert cast(bool, m.foo) is True
 
     m = Model.construct(foo={"name": 3})
-    if PYDANTIC_V2:
-        assert isinstance(m.foo, Submodel1)
-        assert m.foo.name == 3  # type: ignore
-    else:
+    if PYDANTIC_V1:
         assert isinstance(m.foo, Submodel2)
         assert m.foo.name == "3"
+    else:
+        assert isinstance(m.foo, Submodel1)
+        assert m.foo.name == 3  # type: ignore
 
 
 def test_list_of_unions() -> None:
@@ -426,10 +426,10 @@ class Model(BaseModel):
 
     expected = datetime(2019, 12, 27, 18, 11, 19, 117000, tzinfo=timezone.utc)
 
-    if PYDANTIC_V2:
-        expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}'
-    else:
+    if PYDANTIC_V1:
         expected_json = '{"created_at": "2019-12-27T18:11:19.117000+00:00"}'
+    else:
+        expected_json = '{"created_at":"2019-12-27T18:11:19.117000Z"}'
 
     model = Model.construct(created_at="2019-12-27T18:11:19.117Z")
     assert model.created_at == expected
@@ -531,7 +531,7 @@ class Model2(BaseModel):
     assert m4.to_dict(mode="python") == {"created_at": datetime.fromisoformat(time_str)}
     assert m4.to_dict(mode="json") == {"created_at": time_str}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"):
             m.to_dict(warnings=False)
 
@@ -556,7 +556,7 @@ class Model(BaseModel):
     assert m3.model_dump() == {"foo": None}
     assert m3.model_dump(exclude_none=True) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"):
             m.model_dump(round_trip=True)
 
@@ -580,10 +580,10 @@ class Model(BaseModel):
     assert json.loads(m.to_json()) == {"FOO": "hello"}
     assert json.loads(m.to_json(use_api_names=False)) == {"foo": "hello"}
 
-    if PYDANTIC_V2:
-        assert m.to_json(indent=None) == '{"FOO":"hello"}'
-    else:
+    if PYDANTIC_V1:
         assert m.to_json(indent=None) == '{"FOO": "hello"}'
+    else:
+        assert m.to_json(indent=None) == '{"FOO":"hello"}'
 
     m2 = Model()
     assert json.loads(m2.to_json()) == {}
@@ -595,7 +595,7 @@ class Model(BaseModel):
     assert json.loads(m3.to_json()) == {"FOO": None}
     assert json.loads(m3.to_json(exclude_none=True)) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="warnings is only supported in Pydantic v2"):
             m.to_json(warnings=False)
 
@@ -622,7 +622,7 @@ class Model(BaseModel):
     assert json.loads(m3.model_dump_json()) == {"foo": None}
     assert json.loads(m3.model_dump_json(exclude_none=True)) == {}
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         with pytest.raises(ValueError, match="round_trip is only supported in Pydantic v2"):
             m.model_dump_json(round_trip=True)
 
@@ -679,12 +679,12 @@ class B(BaseModel):
     )
     assert isinstance(m, A)
     assert m.type == "a"
-    if PYDANTIC_V2:
-        assert m.data == 100  # type: ignore[comparison-overlap]
-    else:
+    if PYDANTIC_V1:
         # pydantic v1 automatically converts inputs to strings
         # if the expected type is a str
         assert m.data == "100"
+    else:
+        assert m.data == 100  # type: ignore[comparison-overlap]
 
 
 def test_discriminated_unions_unknown_variant() -> None:
@@ -768,12 +768,12 @@ class B(BaseModel):
     )
     assert isinstance(m, A)
     assert m.foo_type == "a"
-    if PYDANTIC_V2:
-        assert m.data == 100  # type: ignore[comparison-overlap]
-    else:
+    if PYDANTIC_V1:
         # pydantic v1 automatically converts inputs to strings
         # if the expected type is a str
         assert m.data == "100"
+    else:
+        assert m.data == 100  # type: ignore[comparison-overlap]
 
 
 def test_discriminated_unions_overlapping_discriminators_invalid_data() -> None:
@@ -833,7 +833,7 @@ class B(BaseModel):
     assert UnionType.__discriminator__ is discriminator
 
 
-@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1")
+@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1")
 def test_type_alias_type() -> None:
     Alias = TypeAliasType("Alias", str)  # pyright: ignore
 
@@ -849,7 +849,7 @@ class Model(BaseModel):
     assert m.union == "bar"
 
 
-@pytest.mark.skipif(not PYDANTIC_V2, reason="TypeAliasType is not supported in Pydantic v1")
+@pytest.mark.skipif(PYDANTIC_V1, reason="TypeAliasType is not supported in Pydantic v1")
 def test_field_named_cls() -> None:
     class Model(BaseModel):
         cls: str
@@ -936,7 +936,7 @@ class Type2(BaseModel):
     assert isinstance(model.value, InnerType2)
 
 
-@pytest.mark.skipif(not PYDANTIC_V2, reason="this is only supported in pydantic v2 for now")
+@pytest.mark.skipif(PYDANTIC_V1, reason="this is only supported in pydantic v2 for now")
 def test_extra_properties() -> None:
     class Item(BaseModel):
         prop: int
diff --git a/tests/test_transform.py b/tests/test_transform.py
index 5548673..16b92c7 100644
--- a/tests/test_transform.py
+++ b/tests/test_transform.py
@@ -15,7 +15,7 @@
     parse_datetime,
     async_transform as _async_transform,
 )
-from lmnt._compat import PYDANTIC_V2
+from lmnt._compat import PYDANTIC_V1
 from lmnt._models import BaseModel
 
 _T = TypeVar("_T")
@@ -189,7 +189,7 @@ class DateModel(BaseModel):
 @pytest.mark.asyncio
 async def test_iso8601_format(use_async: bool) -> None:
     dt = datetime.fromisoformat("2023-02-23T14:16:36.337692+00:00")
-    tz = "Z" if PYDANTIC_V2 else "+00:00"
+    tz = "+00:00" if PYDANTIC_V1 else "Z"
     assert await transform({"foo": dt}, DatetimeDict, use_async) == {"foo": "2023-02-23T14:16:36.337692+00:00"}  # type: ignore[comparison-overlap]
     assert await transform(DatetimeModel(foo=dt), Any, use_async) == {"foo": "2023-02-23T14:16:36.337692" + tz}  # type: ignore[comparison-overlap]
 
@@ -297,11 +297,11 @@ async def test_pydantic_unknown_field(use_async: bool) -> None:
 @pytest.mark.asyncio
 async def test_pydantic_mismatched_types(use_async: bool) -> None:
     model = MyModel.construct(foo=True)
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        params = await transform(model, Any, use_async)
+    else:
         with pytest.warns(UserWarning):
             params = await transform(model, Any, use_async)
-    else:
-        params = await transform(model, Any, use_async)
     assert cast(Any, params) == {"foo": True}
 
 
@@ -309,11 +309,11 @@ async def test_pydantic_mismatched_types(use_async: bool) -> None:
 @pytest.mark.asyncio
 async def test_pydantic_mismatched_object_type(use_async: bool) -> None:
     model = MyModel.construct(foo=MyModel.construct(hello="world"))
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        params = await transform(model, Any, use_async)
+    else:
         with pytest.warns(UserWarning):
             params = await transform(model, Any, use_async)
-    else:
-        params = await transform(model, Any, use_async)
     assert cast(Any, params) == {"foo": {"hello": "world"}}
 
 
diff --git a/tests/test_utils/test_datetime_parse.py b/tests/test_utils/test_datetime_parse.py
new file mode 100644
index 0000000..7a2a050
--- /dev/null
+++ b/tests/test_utils/test_datetime_parse.py
@@ -0,0 +1,110 @@
+"""
+Copied from https://github.com/pydantic/pydantic/blob/v1.10.22/tests/test_datetime_parse.py
+with modifications so it works without pydantic v1 imports.
+"""
+
+from typing import Type, Union
+from datetime import date, datetime, timezone, timedelta
+
+import pytest
+
+from lmnt._utils import parse_date, parse_datetime
+
+
+def create_tz(minutes: int) -> timezone:
+    return timezone(timedelta(minutes=minutes))
+
+
+@pytest.mark.parametrize(
+    "value,result",
+    [
+        # Valid inputs
+        ("1494012444.883309", date(2017, 5, 5)),
+        (b"1494012444.883309", date(2017, 5, 5)),
+        (1_494_012_444.883_309, date(2017, 5, 5)),
+        ("1494012444", date(2017, 5, 5)),
+        (1_494_012_444, date(2017, 5, 5)),
+        (0, date(1970, 1, 1)),
+        ("2012-04-23", date(2012, 4, 23)),
+        (b"2012-04-23", date(2012, 4, 23)),
+        ("2012-4-9", date(2012, 4, 9)),
+        (date(2012, 4, 9), date(2012, 4, 9)),
+        (datetime(2012, 4, 9, 12, 15), date(2012, 4, 9)),
+        # Invalid inputs
+        ("x20120423", ValueError),
+        ("2012-04-56", ValueError),
+        (19_999_999_999, date(2603, 10, 11)),  # just before watershed
+        (20_000_000_001, date(1970, 8, 20)),  # just after watershed
+        (1_549_316_052, date(2019, 2, 4)),  # nowish in s
+        (1_549_316_052_104, date(2019, 2, 4)),  # nowish in ms
+        (1_549_316_052_104_324, date(2019, 2, 4)),  # nowish in μs
+        (1_549_316_052_104_324_096, date(2019, 2, 4)),  # nowish in ns
+        ("infinity", date(9999, 12, 31)),
+        ("inf", date(9999, 12, 31)),
+        (float("inf"), date(9999, 12, 31)),
+        ("infinity ", date(9999, 12, 31)),
+        (int("1" + "0" * 100), date(9999, 12, 31)),
+        (1e1000, date(9999, 12, 31)),
+        ("-infinity", date(1, 1, 1)),
+        ("-inf", date(1, 1, 1)),
+        ("nan", ValueError),
+    ],
+)
+def test_date_parsing(value: Union[str, bytes, int, float], result: Union[date, Type[Exception]]) -> None:
+    if type(result) == type and issubclass(result, Exception):  # pyright: ignore[reportUnnecessaryIsInstance]
+        with pytest.raises(result):
+            parse_date(value)
+    else:
+        assert parse_date(value) == result
+
+
+@pytest.mark.parametrize(
+    "value,result",
+    [
+        # Valid inputs
+        # values in seconds
+        ("1494012444.883309", datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)),
+        (1_494_012_444.883_309, datetime(2017, 5, 5, 19, 27, 24, 883_309, tzinfo=timezone.utc)),
+        ("1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        (b"1494012444", datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        (1_494_012_444, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        # values in ms
+        ("1494012444000.883309", datetime(2017, 5, 5, 19, 27, 24, 883, tzinfo=timezone.utc)),
+        ("-1494012444000.883309", datetime(1922, 8, 29, 4, 32, 35, 999117, tzinfo=timezone.utc)),
+        (1_494_012_444_000, datetime(2017, 5, 5, 19, 27, 24, tzinfo=timezone.utc)),
+        ("2012-04-23T09:15:00", datetime(2012, 4, 23, 9, 15)),
+        ("2012-4-9 4:8:16", datetime(2012, 4, 9, 4, 8, 16)),
+        ("2012-04-23T09:15:00Z", datetime(2012, 4, 23, 9, 15, 0, 0, timezone.utc)),
+        ("2012-4-9 4:8:16-0320", datetime(2012, 4, 9, 4, 8, 16, 0, create_tz(-200))),
+        ("2012-04-23T10:20:30.400+02:30", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(150))),
+        ("2012-04-23T10:20:30.400+02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(120))),
+        ("2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))),
+        (b"2012-04-23T10:20:30.400-02", datetime(2012, 4, 23, 10, 20, 30, 400_000, create_tz(-120))),
+        (datetime(2017, 5, 5), datetime(2017, 5, 5)),
+        (0, datetime(1970, 1, 1, 0, 0, 0, tzinfo=timezone.utc)),
+        # Invalid inputs
+        ("x20120423091500", ValueError),
+        ("2012-04-56T09:15:90", ValueError),
+        ("2012-04-23T11:05:00-25:00", ValueError),
+        (19_999_999_999, datetime(2603, 10, 11, 11, 33, 19, tzinfo=timezone.utc)),  # just before watershed
+        (20_000_000_001, datetime(1970, 8, 20, 11, 33, 20, 1000, tzinfo=timezone.utc)),  # just after watershed
+        (1_549_316_052, datetime(2019, 2, 4, 21, 34, 12, 0, tzinfo=timezone.utc)),  # nowish in s
+        (1_549_316_052_104, datetime(2019, 2, 4, 21, 34, 12, 104_000, tzinfo=timezone.utc)),  # nowish in ms
+        (1_549_316_052_104_324, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)),  # nowish in μs
+        (1_549_316_052_104_324_096, datetime(2019, 2, 4, 21, 34, 12, 104_324, tzinfo=timezone.utc)),  # nowish in ns
+        ("infinity", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("inf", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("inf ", datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        (1e50, datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        (float("inf"), datetime(9999, 12, 31, 23, 59, 59, 999999)),
+        ("-infinity", datetime(1, 1, 1, 0, 0)),
+        ("-inf", datetime(1, 1, 1, 0, 0)),
+        ("nan", ValueError),
+    ],
+)
+def test_datetime_parsing(value: Union[str, bytes, int, float], result: Union[datetime, Type[Exception]]) -> None:
+    if type(result) == type and issubclass(result, Exception):  # pyright: ignore[reportUnnecessaryIsInstance]
+        with pytest.raises(result):
+            parse_datetime(value)
+    else:
+        assert parse_datetime(value) == result
diff --git a/tests/utils.py b/tests/utils.py
index 6bc6195..498eddc 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -4,7 +4,7 @@
 import inspect
 import traceback
 import contextlib
-from typing import Any, TypeVar, Iterator, cast
+from typing import Any, TypeVar, Iterator, Sequence, cast
 from datetime import date, datetime
 from typing_extensions import Literal, get_args, get_origin, assert_type
 
@@ -15,10 +15,11 @@
     is_list_type,
     is_union_type,
     extract_type_arg,
+    is_sequence_type,
     is_annotated_type,
     is_type_alias_type,
 )
-from lmnt._compat import PYDANTIC_V2, field_outer_type, get_model_fields
+from lmnt._compat import PYDANTIC_V1, field_outer_type, get_model_fields
 from lmnt._models import BaseModel
 
 BaseModelT = TypeVar("BaseModelT", bound=BaseModel)
@@ -27,12 +28,12 @@
 def assert_matches_model(model: type[BaseModelT], value: BaseModelT, *, path: list[str]) -> bool:
     for name, field in get_model_fields(model).items():
         field_value = getattr(value, name)
-        if PYDANTIC_V2:
-            allow_none = False
-        else:
+        if PYDANTIC_V1:
             # in v1 nullability was structured differently
             # https://docs.pydantic.dev/2.0/migration/#required-optional-and-nullable-fields
             allow_none = getattr(field, "allow_none", False)
+        else:
+            allow_none = False
 
         assert_matches_type(
             field_outer_type(field),
@@ -71,6 +72,13 @@ def assert_matches_type(
     if is_list_type(type_):
         return _assert_list_type(type_, value)
 
+    if is_sequence_type(type_):
+        assert isinstance(value, Sequence)
+        inner_type = get_args(type_)[0]
+        for entry in value:  # type: ignore
+            assert_type(inner_type, entry)  # type: ignore
+        return
+
     if origin == str:
         assert isinstance(value, str)
     elif origin == int: