cribl-control-plane 0.2.1rc5__py3-none-any.whl → 0.2.1rc7__py3-none-any.whl

cribl_control_plane/models/inputappscope.py

@@ -1,13 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -106,6 +107,24 @@ class InputAppscopePq(BaseModel):
         Optional[InputAppscopePqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputAppscopeMetadatumTypedDict(TypedDict):
     name: str
@@ -197,6 +216,15 @@ class InputAppscopePersistence(BaseModel):
     )
     r"""Path to use to write metrics. Defaults to $CRIBL_HOME/state/appscope"""
 
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeDataCompressionFormat(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputAppscopeAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
@@ -221,6 +249,12 @@ class InputAppscopeMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
     disabled: NotRequired[bool]
+    request_cert: NotRequired[bool]
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+    common_name_regex: NotRequired[str]
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
     certificate_name: NotRequired[str]
     r"""The name of the predefined certificate"""
     priv_key_path: NotRequired[str]
@@ -231,10 +265,6 @@ class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
     r"""Path on server containing certificates to use. PEM format. Can reference $ENV_VARS."""
     ca_path: NotRequired[str]
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
-    request_cert: NotRequired[bool]
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-    reject_unauthorized: NotRequired[Any]
-    common_name_regex: NotRequired[Any]
     min_version: NotRequired[InputAppscopeMinimumTLSVersion]
     max_version: NotRequired[InputAppscopeMaximumTLSVersion]
 
@@ -242,6 +272,19 @@ class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
 class InputAppscopeTLSSettingsServerSide(BaseModel):
     disabled: Optional[bool] = True
 
+    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+
+    common_name_regex: Annotated[
+        Optional[str], pydantic.Field(alias="commonNameRegex")
+    ] = "/.*/"
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
+
     certificate_name: Annotated[
         Optional[str], pydantic.Field(alias="certificateName")
     ] = None
@@ -259,17 +302,6 @@ class InputAppscopeTLSSettingsServerSide(BaseModel):
     ca_path: Annotated[Optional[str], pydantic.Field(alias="caPath")] = None
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
 
-    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-
-    reject_unauthorized: Annotated[
-        Optional[Any], pydantic.Field(alias="rejectUnauthorized")
-    ] = None
-
-    common_name_regex: Annotated[
-        Optional[Any], pydantic.Field(alias="commonNameRegex")
-    ] = None
-
     min_version: Annotated[
         Annotated[
             Optional[InputAppscopeMinimumTLSVersion],
@@ -286,6 +318,24 @@ class InputAppscopeTLSSettingsServerSide(BaseModel):
         pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputAppscopeTypedDict(TypedDict):
     type: InputAppscopeType
@@ -463,3 +513,12 @@ class InputAppscope(BaseModel):
 
     text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
     r"""Select or create a stored text secret"""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAppscopeAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputazureblob.py

@@ -1,11 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
@@ -106,6 +107,24 @@ class InputAzureBlobPq(BaseModel):
         Optional[InputAzureBlobPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAzureBlobMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAzureBlobCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputAzureBlobMetadatumTypedDict(TypedDict):
     name: str
@@ -323,3 +342,12 @@ class InputAzureBlob(BaseModel):
     r"""Select or create a stored text secret"""
 
     certificate: Optional[InputAzureBlobCertificate] = None
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputAzureBlobAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputcollection.py

@@ -1,11 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
@@ -106,6 +107,24 @@ class InputCollectionPq(BaseModel):
         Optional[InputCollectionPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCollectionMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCollectionCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputCollectionPreprocessTypedDict(TypedDict):
     disabled: NotRequired[bool]

cribl_control_plane/models/inputconfluentcloud.py

@@ -1,11 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
@@ -107,6 +108,24 @@ class InputConfluentCloudPq(BaseModel):
         Optional[InputConfluentCloudPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputConfluentCloudMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
@@ -190,6 +209,24 @@ class InputConfluentCloudTLSSettingsClientSide(BaseModel):
         pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputConfluentCloudAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
@@ -296,6 +333,28 @@ class InputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide(BaseModel):
         pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion(
+                    value
+                )
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion(
+                    value
+                )
+            except ValueError:
+                return value
+        return value
+
 
 class InputConfluentCloudKafkaSchemaRegistryAuthenticationTypedDict(TypedDict):
     disabled: NotRequired[bool]
@@ -341,6 +400,13 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     tls: Optional[InputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide] = None
 
 
+class InputConfluentCloudAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Enter credentials directly, or select a stored secret"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
 class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     # PLAIN
     PLAIN = "plain"
@@ -352,13 +418,58 @@ class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     KERBEROS = "kerberos"
 
 
+class InputConfluentCloudOauthParamTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputConfluentCloudOauthParam(BaseModel):
+    name: str
+
+    value: str
+
+
+class InputConfluentCloudSaslExtensionTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputConfluentCloudSaslExtension(BaseModel):
+    name: str
+
+    value: str
+
+
 class InputConfluentCloudAuthenticationTypedDict(TypedDict):
     r"""Authentication parameters to use when connecting to brokers. Using TLS is highly recommended."""
 
     disabled: NotRequired[bool]
+    username: NotRequired[str]
+    password: NotRequired[str]
+    auth_type: NotRequired[InputConfluentCloudAuthenticationMethod]
+    r"""Enter credentials directly, or select a stored secret"""
+    credentials_secret: NotRequired[str]
+    r"""Select or create a secret that references your credentials"""
     mechanism: NotRequired[InputConfluentCloudSASLMechanism]
+    keytab_location: NotRequired[str]
+    r"""Location of keytab file for authentication principal"""
+    principal: NotRequired[str]
+    r"""Authentication principal, such as `kafka_user@example.com`"""
+    broker_service_class: NotRequired[str]
+    r"""Kerberos service class for Kafka brokers, such as `kafka`"""
     oauth_enabled: NotRequired[bool]
     r"""Enable OAuth authentication"""
+    token_url: NotRequired[str]
+    r"""URL of the token endpoint to use for OAuth authentication"""
+    client_id: NotRequired[str]
+    r"""Client ID to use for OAuth authentication"""
+    oauth_secret_type: NotRequired[str]
+    client_text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+    oauth_params: NotRequired[List[InputConfluentCloudOauthParamTypedDict]]
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+    sasl_extensions: NotRequired[List[InputConfluentCloudSaslExtensionTypedDict]]
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
 
 
 class InputConfluentCloudAuthentication(BaseModel):
@@ -366,16 +477,92 @@ class InputConfluentCloudAuthentication(BaseModel):
 
     disabled: Optional[bool] = True
 
+    username: Optional[str] = None
+
+    password: Optional[str] = None
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputConfluentCloudAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputConfluentCloudAuthenticationMethod.MANUAL
+    r"""Enter credentials directly, or select a stored secret"""
+
+    credentials_secret: Annotated[
+        Optional[str], pydantic.Field(alias="credentialsSecret")
+    ] = None
+    r"""Select or create a secret that references your credentials"""
+
     mechanism: Annotated[
         Optional[InputConfluentCloudSASLMechanism],
         PlainValidator(validate_open_enum(False)),
     ] = InputConfluentCloudSASLMechanism.PLAIN
 
+    keytab_location: Annotated[
+        Optional[str], pydantic.Field(alias="keytabLocation")
+    ] = None
+    r"""Location of keytab file for authentication principal"""
+
+    principal: Optional[str] = None
+    r"""Authentication principal, such as `kafka_user@example.com`"""
+
+    broker_service_class: Annotated[
+        Optional[str], pydantic.Field(alias="brokerServiceClass")
+    ] = None
+    r"""Kerberos service class for Kafka brokers, such as `kafka`"""
+
     oauth_enabled: Annotated[Optional[bool], pydantic.Field(alias="oauthEnabled")] = (
         False
     )
     r"""Enable OAuth authentication"""
 
+    token_url: Annotated[Optional[str], pydantic.Field(alias="tokenUrl")] = None
+    r"""URL of the token endpoint to use for OAuth authentication"""
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Client ID to use for OAuth authentication"""
+
+    oauth_secret_type: Annotated[
+        Optional[str], pydantic.Field(alias="oauthSecretType")
+    ] = "secret"
+
+    client_text_secret: Annotated[
+        Optional[str], pydantic.Field(alias="clientTextSecret")
+    ] = None
+    r"""Select or create a stored text secret"""
+
+    oauth_params: Annotated[
+        Optional[List[InputConfluentCloudOauthParam]],
+        pydantic.Field(alias="oauthParams"),
+    ] = None
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+
+    sasl_extensions: Annotated[
+        Optional[List[InputConfluentCloudSaslExtension]],
+        pydantic.Field(alias="saslExtensions"),
+    ] = None
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("mechanism")
+    def serialize_mechanism(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputConfluentCloudSASLMechanism(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputConfluentCloudMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputcribl.py

@@ -1,11 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
@@ -106,6 +107,24 @@ class InputCriblPq(BaseModel):
         Optional[InputCriblPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputCriblMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputcriblhttp.py

@@ -1,13 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -106,6 +107,24 @@ class InputCriblHTTPPq(BaseModel):
         Optional[InputCriblHTTPPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblHTTPMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblHTTPCompression(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputCriblHTTPMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
@@ -123,6 +142,12 @@ class InputCriblHTTPMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputCriblHTTPTLSSettingsServerSideTypedDict(TypedDict):
     disabled: NotRequired[bool]
+    request_cert: NotRequired[bool]
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+    common_name_regex: NotRequired[str]
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
     certificate_name: NotRequired[str]
     r"""The name of the predefined certificate"""
     priv_key_path: NotRequired[str]
@@ -133,10 +158,6 @@ class InputCriblHTTPTLSSettingsServerSideTypedDict(TypedDict):
     r"""Path on server containing certificates to use. PEM format. Can reference $ENV_VARS."""
     ca_path: NotRequired[str]
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
-    request_cert: NotRequired[bool]
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-    reject_unauthorized: NotRequired[Any]
-    common_name_regex: NotRequired[Any]
     min_version: NotRequired[InputCriblHTTPMinimumTLSVersion]
     max_version: NotRequired[InputCriblHTTPMaximumTLSVersion]
 
@@ -144,6 +165,19 @@ class InputCriblHTTPTLSSettingsServerSideTypedDict(TypedDict):
 class InputCriblHTTPTLSSettingsServerSide(BaseModel):
     disabled: Optional[bool] = True
 
+    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+
+    common_name_regex: Annotated[
+        Optional[str], pydantic.Field(alias="commonNameRegex")
+    ] = "/.*/"
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
+
     certificate_name: Annotated[
         Optional[str], pydantic.Field(alias="certificateName")
     ] = None
@@ -161,17 +195,6 @@ class InputCriblHTTPTLSSettingsServerSide(BaseModel):
     ca_path: Annotated[Optional[str], pydantic.Field(alias="caPath")] = None
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
 
-    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-
-    reject_unauthorized: Annotated[
-        Optional[Any], pydantic.Field(alias="rejectUnauthorized")
-    ] = None
-
-    common_name_regex: Annotated[
-        Optional[Any], pydantic.Field(alias="commonNameRegex")
-    ] = None
-
     min_version: Annotated[
         Annotated[
             Optional[InputCriblHTTPMinimumTLSVersion],
@@ -188,6 +211,24 @@ class InputCriblHTTPTLSSettingsServerSide(BaseModel):
         pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblHTTPMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblHTTPMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputCriblHTTPMetadatumTypedDict(TypedDict):
     name: str