cribl-control-plane 0.0.39__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

cribl_control_plane/models/inputcribltcp.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+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 typing import Any, List, Optional
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -23,20 +27,32 @@ class InputCriblTCPConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputCriblTCPMode(str, Enum):
+class InputCriblTCPMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputCriblTCPCompression(str, Enum):
+class InputCriblTCPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputCriblTCPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblTCPPqControls(BaseModel):
+    pass
+
+
 class InputCriblTCPPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblTCPMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputCriblTCPPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblTCPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblTCPPqControlsTypedDict]
 
 
 class InputCriblTCPPq(BaseModel):
-    mode: Optional[InputCriblTCPMode] = InputCriblTCPMode.ALWAYS
+    mode: Annotated[
+        Optional[InputCriblTCPMode], PlainValidator(validate_open_enum(False))
+    ] = InputCriblTCPMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,18 +98,42 @@ class InputCriblTCPPq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputCriblTCPCompression] = InputCriblTCPCompression.NONE
+    compress: Annotated[
+        Optional[InputCriblTCPCompression], PlainValidator(validate_open_enum(False))
+    ] = InputCriblTCPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblTCPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputCriblTCPMinimumTLSVersion(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblTCPMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblTCPCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputCriblTCPMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputCriblTCPMaximumTLSVersion(str, Enum):
+class InputCriblTCPMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -99,6 +142,12 @@ class InputCriblTCPMaximumTLSVersion(str, Enum):
 
 class InputCriblTCPTLSSettingsServerSideTypedDict(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]
@@ -109,10 +158,6 @@ class InputCriblTCPTLSSettingsServerSideTypedDict(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[InputCriblTCPMinimumTLSVersion]
     max_version: NotRequired[InputCriblTCPMaximumTLSVersion]
 
@@ -120,6 +165,19 @@ class InputCriblTCPTLSSettingsServerSideTypedDict(TypedDict):
 class InputCriblTCPTLSSettingsServerSide(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
@@ -137,25 +195,40 @@ class InputCriblTCPTLSSettingsServerSide(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[
-        Optional[InputCriblTCPMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputCriblTCPMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputCriblTCPMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputCriblTCPMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblTCPMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCriblTCPMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputCriblTCPMetadatumTypedDict(TypedDict):
     name: str
@@ -170,6 +243,24 @@ class InputCriblTCPMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
+class InputCriblTCPAuthTokenTypedDict(TypedDict):
+    token_secret: str
+    r"""Select or create a stored text secret"""
+    enabled: NotRequired[bool]
+    description: NotRequired[str]
+    r"""Optional token description"""
+
+
+class InputCriblTCPAuthToken(BaseModel):
+    token_secret: Annotated[str, pydantic.Field(alias="tokenSecret")]
+    r"""Select or create a stored text secret"""
+
+    enabled: Optional[bool] = True
+
+    description: Optional[str] = None
+    r"""Optional token description"""
+
+
 class InputCriblTCPTypedDict(TypedDict):
     type: InputCriblTCPType
     port: float
@@ -207,6 +298,8 @@ class InputCriblTCPTypedDict(TypedDict):
     r"""Fields to add to events from this input"""
     enable_load_balancing: NotRequired[bool]
     r"""Load balance traffic across all Worker Processes"""
+    auth_tokens: NotRequired[List[InputCriblTCPAuthTokenTypedDict]]
+    r"""Shared secrets to be used by connected environments to authorize connections. These tokens should be installed in Cribl TCP destinations in connected environments."""
     description: NotRequired[str]
 
 
@@ -281,4 +374,9 @@ class InputCriblTCP(BaseModel):
     ] = False
     r"""Load balance traffic across all Worker Processes"""
 
+    auth_tokens: Annotated[
+        Optional[List[InputCriblTCPAuthToken]], pydantic.Field(alias="authTokens")
+    ] = None
+    r"""Shared secrets to be used by connected environments to authorize connections. These tokens should be installed in Cribl TCP destinations in connected environments."""
+
     description: Optional[str] = None

cribl_control_plane/models/inputcrowdstrike.py

@@ -1,9 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+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
 
@@ -23,20 +27,32 @@ class InputCrowdstrikeConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputCrowdstrikeMode(str, Enum):
+class InputCrowdstrikeMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputCrowdstrikeCompression(str, Enum):
+class InputCrowdstrikeCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputCrowdstrikePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCrowdstrikePqControls(BaseModel):
+    pass
+
+
 class InputCrowdstrikePqTypedDict(TypedDict):
     mode: NotRequired[InputCrowdstrikeMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputCrowdstrikePqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCrowdstrikeCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCrowdstrikePqControlsTypedDict]
 
 
 class InputCrowdstrikePq(BaseModel):
-    mode: Optional[InputCrowdstrikeMode] = InputCrowdstrikeMode.ALWAYS
+    mode: Annotated[
+        Optional[InputCrowdstrikeMode], PlainValidator(validate_open_enum(False))
+    ] = InputCrowdstrikeMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,19 +98,46 @@ class InputCrowdstrikePq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputCrowdstrikeCompression] = InputCrowdstrikeCompression.NONE
+    compress: Annotated[
+        Optional[InputCrowdstrikeCompression], PlainValidator(validate_open_enum(False))
+    ] = InputCrowdstrikeCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCrowdstrikePqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputCrowdstrikeAuthenticationMethod(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCrowdstrikeMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCrowdstrikeCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputCrowdstrikeAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
+    # Auto
     AUTO = "auto"
+    # Manual
     MANUAL = "manual"
+    # Secret Key pair
     SECRET = "secret"
 
 
-class InputCrowdstrikeSignatureVersion(str, Enum):
+class InputCrowdstrikeSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Signature version to use for signing S3 requests"""
 
     V2 = "v2"
@@ -144,7 +190,7 @@ class InputCrowdstrikeCheckpointing(BaseModel):
     r"""The number of times to retry processing when a processing error occurs. If Skip file on error is enabled, this setting is ignored."""
 
 
-class InputCrowdstrikeTagAfterProcessing(str, Enum):
+class InputCrowdstrikeTagAfterProcessing(str, Enum, metaclass=utils.OpenEnumMeta):
     FALSE = "false"
     TRUE = "true"
 
@@ -273,7 +319,10 @@ class InputCrowdstrike(BaseModel):
     r"""SQS queue owner's AWS account ID. Leave empty if SQS queue is in same AWS account."""
 
     aws_authentication_method: Annotated[
-        Optional[InputCrowdstrikeAuthenticationMethod],
+        Annotated[
+            Optional[InputCrowdstrikeAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = InputCrowdstrikeAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -289,7 +338,10 @@ class InputCrowdstrike(BaseModel):
     r"""S3 service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to S3-compatible endpoint."""
 
     signature_version: Annotated[
-        Optional[InputCrowdstrikeSignatureVersion],
+        Annotated[
+            Optional[InputCrowdstrikeSignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="signatureVersion"),
     ] = InputCrowdstrikeSignatureVersion.V4
     r"""Signature version to use for signing S3 requests"""
@@ -386,7 +438,10 @@ class InputCrowdstrike(BaseModel):
     r"""Select or create a stored secret that references your access key and secret key"""
 
     tag_after_processing: Annotated[
-        Optional[InputCrowdstrikeTagAfterProcessing],
+        Annotated[
+            Optional[InputCrowdstrikeTagAfterProcessing],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="tagAfterProcessing"),
     ] = None
 
@@ -399,3 +454,30 @@ class InputCrowdstrike(BaseModel):
         Optional[str], pydantic.Field(alias="processedTagValue")
     ] = None
     r"""The value for the S3 object tag applied after processing. This field accepts an expression for dynamic generation."""
+
+    @field_serializer("aws_authentication_method")
+    def serialize_aws_authentication_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCrowdstrikeAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("signature_version")
+    def serialize_signature_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCrowdstrikeSignatureVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("tag_after_processing")
+    def serialize_tag_after_processing(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputCrowdstrikeTagAfterProcessing(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputdatadogagent.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+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 typing import Any, List, Optional
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -23,20 +27,32 @@ class InputDatadogAgentConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputDatadogAgentMode(str, Enum):
+class InputDatadogAgentMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
+    # Smart
     SMART = "smart"
+    # Always On
     ALWAYS = "always"
 
 
-class InputDatadogAgentCompression(str, Enum):
+class InputDatadogAgentCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputDatadogAgentPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputDatadogAgentPqControls(BaseModel):
+    pass
+
+
 class InputDatadogAgentPqTypedDict(TypedDict):
     mode: NotRequired[InputDatadogAgentMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,10 +68,13 @@ class InputDatadogAgentPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputDatadogAgentCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputDatadogAgentPqControlsTypedDict]
 
 
 class InputDatadogAgentPq(BaseModel):
-    mode: Optional[InputDatadogAgentMode] = InputDatadogAgentMode.ALWAYS
+    mode: Annotated[
+        Optional[InputDatadogAgentMode], PlainValidator(validate_open_enum(False))
+    ] = InputDatadogAgentMode.ALWAYS
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
     max_buffer_size: Annotated[
@@ -79,18 +98,43 @@ class InputDatadogAgentPq(BaseModel):
     path: Optional[str] = "$CRIBL_HOME/state/queues"
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
 
-    compress: Optional[InputDatadogAgentCompression] = InputDatadogAgentCompression.NONE
+    compress: Annotated[
+        Optional[InputDatadogAgentCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputDatadogAgentCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputDatadogAgentPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputDatadogAgentMinimumTLSVersion(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputDatadogAgentMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputDatadogAgentCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputDatadogAgentMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputDatadogAgentMaximumTLSVersion(str, Enum):
+class InputDatadogAgentMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -99,6 +143,12 @@ class InputDatadogAgentMaximumTLSVersion(str, Enum):
 
 class InputDatadogAgentTLSSettingsServerSideTypedDict(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]
@@ -109,10 +159,6 @@ class InputDatadogAgentTLSSettingsServerSideTypedDict(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[InputDatadogAgentMinimumTLSVersion]
     max_version: NotRequired[InputDatadogAgentMaximumTLSVersion]
 
@@ -120,6 +166,19 @@ class InputDatadogAgentTLSSettingsServerSideTypedDict(TypedDict):
 class InputDatadogAgentTLSSettingsServerSide(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
@@ -137,25 +196,40 @@ class InputDatadogAgentTLSSettingsServerSide(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[
-        Optional[InputDatadogAgentMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputDatadogAgentMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputDatadogAgentMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputDatadogAgentMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputDatadogAgentMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputDatadogAgentMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
 
 class InputDatadogAgentMetadatumTypedDict(TypedDict):
     name: str