cribl-control-plane 0.2.1rc3__py3-none-any.whl → 0.2.1rc4__py3-none-any.whl

cribl_control_plane/models/inputhttp.py

@@ -7,7 +7,7 @@ from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -123,6 +123,12 @@ class InputHTTPMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputHTTPTLSSettingsServerSideTypedDict(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 +139,6 @@ class InputHTTPTLSSettingsServerSideTypedDict(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[InputHTTPMinimumTLSVersion]
     max_version: NotRequired[InputHTTPMaximumTLSVersion]
 
@@ -144,6 +146,19 @@ class InputHTTPTLSSettingsServerSideTypedDict(TypedDict):
 class InputHTTPTLSSettingsServerSide(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 +176,6 @@ class InputHTTPTLSSettingsServerSide(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[InputHTTPMinimumTLSVersion],

cribl_control_plane/models/inputhttpraw.py

@@ -7,7 +7,7 @@ from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -123,6 +123,12 @@ class InputHTTPRawMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputHTTPRawTLSSettingsServerSideTypedDict(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 +139,6 @@ class InputHTTPRawTLSSettingsServerSideTypedDict(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[InputHTTPRawMinimumTLSVersion]
     max_version: NotRequired[InputHTTPRawMaximumTLSVersion]
 
@@ -144,6 +146,19 @@ class InputHTTPRawTLSSettingsServerSideTypedDict(TypedDict):
 class InputHTTPRawTLSSettingsServerSide(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 +176,6 @@ class InputHTTPRawTLSSettingsServerSide(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[InputHTTPRawMinimumTLSVersion],

cribl_control_plane/models/inputkafka.py

@@ -255,6 +255,13 @@ class InputKafkaKafkaSchemaRegistryAuthentication(BaseModel):
     tls: Optional[InputKafkaKafkaSchemaRegistryTLSSettingsClientSide] = None
 
 
+class InputKafkaAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Enter credentials directly, or select a stored secret"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
 class InputKafkaSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     # PLAIN
     PLAIN = "plain"
@@ -266,13 +273,58 @@ class InputKafkaSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     KERBEROS = "kerberos"
 
 
+class InputKafkaOauthParamTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputKafkaOauthParam(BaseModel):
+    name: str
+
+    value: str
+
+
+class InputKafkaSaslExtensionTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputKafkaSaslExtension(BaseModel):
+    name: str
+
+    value: str
+
+
 class InputKafkaAuthenticationTypedDict(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[InputKafkaAuthenticationMethod]
+    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[InputKafkaSASLMechanism]
+    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[InputKafkaOauthParamTypedDict]]
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+    sasl_extensions: NotRequired[List[InputKafkaSaslExtensionTypedDict]]
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
 
 
 class InputKafkaAuthentication(BaseModel):
@@ -280,15 +332,71 @@ class InputKafkaAuthentication(BaseModel):
 
     disabled: Optional[bool] = True
 
+    username: Optional[str] = None
+
+    password: Optional[str] = None
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputKafkaAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputKafkaAuthenticationMethod.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[InputKafkaSASLMechanism], PlainValidator(validate_open_enum(False))
     ] = InputKafkaSASLMechanism.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[InputKafkaOauthParam]], pydantic.Field(alias="oauthParams")
+    ] = None
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+
+    sasl_extensions: Annotated[
+        Optional[List[InputKafkaSaslExtension]], pydantic.Field(alias="saslExtensions")
+    ] = None
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
+
 
 class InputKafkaMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputloki.py

@@ -7,7 +7,7 @@ from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -123,6 +123,12 @@ class InputLokiMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputLokiTLSSettingsServerSideTypedDict(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 +139,6 @@ class InputLokiTLSSettingsServerSideTypedDict(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[InputLokiMinimumTLSVersion]
     max_version: NotRequired[InputLokiMaximumTLSVersion]
 
@@ -144,6 +146,19 @@ class InputLokiTLSSettingsServerSideTypedDict(TypedDict):
 class InputLokiTLSSettingsServerSide(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 +176,6 @@ class InputLokiTLSSettingsServerSide(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[InputLokiMinimumTLSVersion],

cribl_control_plane/models/inputmetrics.py

@@ -7,7 +7,7 @@ from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -123,6 +123,12 @@ class InputMetricsMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputMetricsTLSSettingsServerSideTypedDict(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 +139,6 @@ class InputMetricsTLSSettingsServerSideTypedDict(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[InputMetricsMinimumTLSVersion]
     max_version: NotRequired[InputMetricsMaximumTLSVersion]
 
@@ -144,6 +146,19 @@ class InputMetricsTLSSettingsServerSideTypedDict(TypedDict):
 class InputMetricsTLSSettingsServerSide(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 +176,6 @@ class InputMetricsTLSSettingsServerSide(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[InputMetricsMinimumTLSVersion],

cribl_control_plane/models/inputmodeldriventelemetry.py

@@ -7,7 +7,7 @@ from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Any, List, Optional
+from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -130,6 +130,12 @@ class InputModelDrivenTelemetryMaximumTLSVersion(
 
 class InputModelDrivenTelemetryTLSSettingsServerSideTypedDict(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]
@@ -140,10 +146,6 @@ class InputModelDrivenTelemetryTLSSettingsServerSideTypedDict(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[InputModelDrivenTelemetryMinimumTLSVersion]
     max_version: NotRequired[InputModelDrivenTelemetryMaximumTLSVersion]
 
@@ -151,6 +153,19 @@ class InputModelDrivenTelemetryTLSSettingsServerSideTypedDict(TypedDict):
 class InputModelDrivenTelemetryTLSSettingsServerSide(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
@@ -168,17 +183,6 @@ class InputModelDrivenTelemetryTLSSettingsServerSide(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[InputModelDrivenTelemetryMinimumTLSVersion],

cribl_control_plane/models/inputopentelemetry.py

@@ -124,6 +124,12 @@ class InputOpenTelemetryMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMet
 
 class InputOpenTelemetryTLSSettingsServerSideTypedDict(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]
@@ -134,10 +140,6 @@ class InputOpenTelemetryTLSSettingsServerSideTypedDict(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[InputOpenTelemetryMinimumTLSVersion]
     max_version: NotRequired[InputOpenTelemetryMaximumTLSVersion]
 
@@ -145,6 +147,19 @@ class InputOpenTelemetryTLSSettingsServerSideTypedDict(TypedDict):
 class InputOpenTelemetryTLSSettingsServerSide(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
@@ -162,17 +177,6 @@ class InputOpenTelemetryTLSSettingsServerSide(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[InputOpenTelemetryMinimumTLSVersion],