cribl-control-plane 0.0.39__py3-none-any.whl → 0.4.0b23__py3-none-any.whl

cribl_control_plane/models/inputelastic.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 InputElasticConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputElasticMode(str, Enum):
+class InputElasticMode(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 InputElasticCompression(str, Enum):
+class InputElasticCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputElasticPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputElasticPqControls(BaseModel):
+    pass
+
+
 class InputElasticPqTypedDict(TypedDict):
     mode: NotRequired[InputElasticMode]
     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 InputElasticPqTypedDict(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[InputElasticCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputElasticPqControlsTypedDict]
 
 
 class InputElasticPq(BaseModel):
-    mode: Optional[InputElasticMode] = InputElasticMode.ALWAYS
+    mode: Annotated[
+        Optional[InputElasticMode], PlainValidator(validate_open_enum(False))
+    ] = InputElasticMode.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 InputElasticPq(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[InputElasticCompression] = InputElasticCompression.NONE
+    compress: Annotated[
+        Optional[InputElasticCompression], PlainValidator(validate_open_enum(False))
+    ] = InputElasticCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputElasticPqControls], pydantic.Field(alias="pqControls")
+    ] = None
 
-class InputElasticMinimumTLSVersion(str, Enum):
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputElasticMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputElasticMaximumTLSVersion(str, Enum):
+class InputElasticMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -99,6 +142,12 @@ class InputElasticMaximumTLSVersion(str, Enum):
 
 class InputElasticTLSSettingsServerSideTypedDict(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 InputElasticTLSSettingsServerSideTypedDict(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[InputElasticMinimumTLSVersion]
     max_version: NotRequired[InputElasticMaximumTLSVersion]
 
@@ -120,6 +165,19 @@ class InputElasticTLSSettingsServerSideTypedDict(TypedDict):
 class InputElasticTLSSettingsServerSide(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,38 +195,60 @@ class InputElasticTLSSettingsServerSide(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[InputElasticMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputElasticMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputElasticMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputElasticMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
-
-class InputElasticAuthenticationType(str, Enum):
+    @field_serializer("min_version")
+    def serialize_min_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticMinimumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("max_version")
+    def serialize_max_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticMaximumTLSVersion(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputElasticAuthenticationType(str, Enum, metaclass=utils.OpenEnumMeta):
+    # None
     NONE = "none"
+    # Basic
     BASIC = "basic"
+    # Basic (credentials secret)
     CREDENTIALS_SECRET = "credentialsSecret"
+    # Auth Tokens
     AUTH_TOKENS = "authTokens"
 
 
-class InputElasticAPIVersion(str, Enum):
+class InputElasticAPIVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""The API version to use for communicating with the server"""
 
+    # 6.8.4
     SIX_DOT_8_DOT_4 = "6.8.4"
+    # 8.3.2
     EIGHT_DOT_3_DOT_2 = "8.3.2"
+    # Custom
     CUSTOM = "custom"
 
 
@@ -196,7 +276,7 @@ class InputElasticMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
-class InputElasticAuthenticationMethod(str, Enum):
+class InputElasticAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Enter credentials directly, or select a stored secret"""
 
     NONE = "none"
@@ -207,6 +287,12 @@ class InputElasticAuthenticationMethod(str, Enum):
 class InputElasticProxyModeTypedDict(TypedDict):
     enabled: NotRequired[bool]
     r"""Enable proxying of non-bulk API requests to an external Elastic server. Enable this only if you understand the implications. See [Cribl Docs](https://docs.cribl.io/stream/sources-elastic/#proxy-mode) for more details."""
+    auth_type: NotRequired[InputElasticAuthenticationMethod]
+    r"""Enter credentials directly, or select a stored secret"""
+    username: NotRequired[str]
+    password: NotRequired[str]
+    credentials_secret: NotRequired[str]
+    r"""Select or create a secret that references your credentials"""
     url: NotRequired[str]
     r"""URL of the Elastic server to proxy non-bulk requests to, such as http://elastic:9200"""
     reject_unauthorized: NotRequired[bool]
@@ -215,14 +301,30 @@ class InputElasticProxyModeTypedDict(TypedDict):
     r"""List of headers to remove from the request to proxy"""
     timeout_sec: NotRequired[float]
     r"""Amount of time, in seconds, to wait for a proxy request to complete before canceling it"""
-    auth_type: NotRequired[InputElasticAuthenticationMethod]
-    r"""Enter credentials directly, or select a stored secret"""
 
 
 class InputElasticProxyMode(BaseModel):
     enabled: Optional[bool] = False
     r"""Enable proxying of non-bulk API requests to an external Elastic server. Enable this only if you understand the implications. See [Cribl Docs](https://docs.cribl.io/stream/sources-elastic/#proxy-mode) for more details."""
 
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputElasticAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputElasticAuthenticationMethod.NONE
+    r"""Enter credentials directly, or select a stored secret"""
+
+    username: Optional[str] = None
+
+    password: Optional[str] = None
+
+    credentials_secret: Annotated[
+        Optional[str], pydantic.Field(alias="credentialsSecret")
+    ] = None
+    r"""Select or create a secret that references your credentials"""
+
     url: Optional[str] = None
     r"""URL of the Elastic server to proxy non-bulk requests to, such as http://elastic:9200"""
 
@@ -239,10 +341,14 @@ class InputElasticProxyMode(BaseModel):
     timeout_sec: Annotated[Optional[float], pydantic.Field(alias="timeoutSec")] = 60
     r"""Amount of time, in seconds, to wait for a proxy request to complete before canceling it"""
 
-    auth_type: Annotated[
-        Optional[InputElasticAuthenticationMethod], pydantic.Field(alias="authType")
-    ] = InputElasticAuthenticationMethod.NONE
-    r"""Enter credentials directly, or select a stored secret"""
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
 
 
 class InputElasticTypedDict(TypedDict):
@@ -408,11 +514,18 @@ class InputElastic(BaseModel):
     r"""Absolute path on which to listen for Elasticsearch API requests. Defaults to /. _bulk will be appended automatically. For example, /myPath becomes /myPath/_bulk. Requests can then be made to either /myPath/_bulk or /myPath/<myIndexName>/_bulk. Other entries are faked as success."""
 
     auth_type: Annotated[
-        Optional[InputElasticAuthenticationType], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[InputElasticAuthenticationType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = InputElasticAuthenticationType.NONE
 
     api_version: Annotated[
-        Optional[InputElasticAPIVersion], pydantic.Field(alias="apiVersion")
+        Annotated[
+            Optional[InputElasticAPIVersion], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="apiVersion"),
     ] = InputElasticAPIVersion.EIGHT_DOT_3_DOT_2
     r"""The API version to use for communicating with the server"""
 
@@ -466,3 +579,21 @@ class InputElastic(BaseModel):
         "}"
     )
     r"""Custom version information to respond to requests"""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticAuthenticationType(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("api_version")
+    def serialize_api_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputElasticAPIVersion(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/inputeventhub.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 InputEventhubConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputEventhubMode(str, Enum):
+class InputEventhubMode(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 InputEventhubCompression(str, Enum):
+class InputEventhubCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
+class InputEventhubPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputEventhubPqControls(BaseModel):
+    pass
+
+
 class InputEventhubPqTypedDict(TypedDict):
     mode: NotRequired[InputEventhubMode]
     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 InputEventhubPqTypedDict(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[InputEventhubCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputEventhubPqControlsTypedDict]
 
 
 class InputEventhubPq(BaseModel):
-    mode: Optional[InputEventhubMode] = InputEventhubMode.ALWAYS
+    mode: Annotated[
+        Optional[InputEventhubMode], PlainValidator(validate_open_enum(False))
+    ] = InputEventhubMode.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,20 +98,101 @@ class InputEventhubPq(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[InputEventhubCompression] = InputEventhubCompression.NONE
+    compress: Annotated[
+        Optional[InputEventhubCompression], PlainValidator(validate_open_enum(False))
+    ] = InputEventhubCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputEventhubPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
+    @field_serializer("mode")
+    def serialize_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubCompression(value)
+            except ValueError:
+                return value
+        return value
+
+
+class InputEventhubAuthTypeAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Enter password directly, or select a stored secret"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
 
-class InputEventhubSASLMechanism(str, Enum):
+
+class InputEventhubSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
+    # PLAIN
     PLAIN = "plain"
+    # OAUTHBEARER
     OAUTHBEARER = "oauthbearer"
 
 
+class InputEventhubClientSecretAuthTypeAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    MANUAL = "manual"
+    SECRET = "secret"
+    CERTIFICATE = "certificate"
+
+
+class InputEventhubMicrosoftEntraIDAuthenticationEndpoint(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Endpoint used to acquire authentication tokens from Azure"""
+
+    HTTPS_LOGIN_MICROSOFTONLINE_COM = "https://login.microsoftonline.com"
+    HTTPS_LOGIN_MICROSOFTONLINE_US = "https://login.microsoftonline.us"
+    HTTPS_LOGIN_PARTNER_MICROSOFTONLINE_CN = "https://login.partner.microsoftonline.cn"
+
+
 class InputEventhubAuthenticationTypedDict(TypedDict):
     r"""Authentication parameters to use when connecting to brokers. Using TLS is highly recommended."""
 
     disabled: NotRequired[bool]
+    auth_type: NotRequired[InputEventhubAuthTypeAuthenticationMethod]
+    r"""Enter password directly, or select a stored secret"""
+    password: NotRequired[str]
+    r"""Connection-string primary key, or connection-string secondary key, from the Event Hubs workspace"""
+    text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
     mechanism: NotRequired[InputEventhubSASLMechanism]
+    username: NotRequired[str]
+    r"""The username for authentication. For Event Hubs, this should always be $ConnectionString."""
+    client_secret_auth_type: NotRequired[
+        InputEventhubClientSecretAuthTypeAuthenticationMethod
+    ]
+    client_secret: NotRequired[str]
+    r"""client_secret to pass in the OAuth request parameter"""
+    client_text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+    certificate_name: NotRequired[str]
+    r"""Select or create a stored certificate"""
+    cert_path: NotRequired[str]
+    priv_key_path: NotRequired[str]
+    passphrase: NotRequired[str]
+    oauth_endpoint: NotRequired[InputEventhubMicrosoftEntraIDAuthenticationEndpoint]
+    r"""Endpoint used to acquire authentication tokens from Azure"""
+    client_id: NotRequired[str]
+    r"""client_id to pass in the OAuth request parameter"""
+    tenant_id: NotRequired[str]
+    r"""Directory ID (tenant identifier) in Azure Active Directory"""
+    scope: NotRequired[str]
+    r"""Scope to pass in the OAuth request parameter"""
 
 
 class InputEventhubAuthentication(BaseModel):
@@ -100,7 +200,110 @@ class InputEventhubAuthentication(BaseModel):
 
     disabled: Optional[bool] = False
 
-    mechanism: Optional[InputEventhubSASLMechanism] = InputEventhubSASLMechanism.PLAIN
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputEventhubAuthTypeAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputEventhubAuthTypeAuthenticationMethod.MANUAL
+    r"""Enter password directly, or select a stored secret"""
+
+    password: Optional[str] = None
+    r"""Connection-string primary key, or connection-string secondary key, from the Event Hubs workspace"""
+
+    text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
+    r"""Select or create a stored text secret"""
+
+    mechanism: Annotated[
+        Optional[InputEventhubSASLMechanism], PlainValidator(validate_open_enum(False))
+    ] = InputEventhubSASLMechanism.PLAIN
+
+    username: Optional[str] = "$ConnectionString"
+    r"""The username for authentication. For Event Hubs, this should always be $ConnectionString."""
+
+    client_secret_auth_type: Annotated[
+        Annotated[
+            Optional[InputEventhubClientSecretAuthTypeAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="clientSecretAuthType"),
+    ] = InputEventhubClientSecretAuthTypeAuthenticationMethod.MANUAL
+
+    client_secret: Annotated[Optional[str], pydantic.Field(alias="clientSecret")] = None
+    r"""client_secret to pass in the OAuth request parameter"""
+
+    client_text_secret: Annotated[
+        Optional[str], pydantic.Field(alias="clientTextSecret")
+    ] = None
+    r"""Select or create a stored text secret"""
+
+    certificate_name: Annotated[
+        Optional[str], pydantic.Field(alias="certificateName")
+    ] = None
+    r"""Select or create a stored certificate"""
+
+    cert_path: Annotated[Optional[str], pydantic.Field(alias="certPath")] = None
+
+    priv_key_path: Annotated[Optional[str], pydantic.Field(alias="privKeyPath")] = None
+
+    passphrase: Optional[str] = None
+
+    oauth_endpoint: Annotated[
+        Annotated[
+            Optional[InputEventhubMicrosoftEntraIDAuthenticationEndpoint],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="oauthEndpoint"),
+    ] = InputEventhubMicrosoftEntraIDAuthenticationEndpoint.HTTPS_LOGIN_MICROSOFTONLINE_COM
+    r"""Endpoint used to acquire authentication tokens from Azure"""
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""client_id to pass in the OAuth request parameter"""
+
+    tenant_id: Annotated[Optional[str], pydantic.Field(alias="tenantId")] = None
+    r"""Directory ID (tenant identifier) in Azure Active Directory"""
+
+    scope: Optional[str] = None
+    r"""Scope to pass in the OAuth request parameter"""
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubAuthTypeAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("mechanism")
+    def serialize_mechanism(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubSASLMechanism(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("client_secret_auth_type")
+    def serialize_client_secret_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubClientSecretAuthTypeAuthenticationMethod(
+                    value
+                )
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("oauth_endpoint")
+    def serialize_oauth_endpoint(self, value):
+        if isinstance(value, str):
+            try:
+                return models.InputEventhubMicrosoftEntraIDAuthenticationEndpoint(value)
+            except ValueError:
+                return value
+        return value
 
 
 class InputEventhubTLSSettingsClientSideTypedDict(TypedDict):