cribl-control-plane 0.2.1rc7__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

cribl_control_plane/models/inputeventhub.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -30,18 +29,14 @@ class InputEventhubConnection(BaseModel):
 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, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -107,92 +102,17 @@ class InputEventhubPq(BaseModel):
         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, 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):
@@ -200,111 +120,10 @@ class InputEventhubAuthentication(BaseModel):
 
     disabled: Optional[bool] = False
 
-    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):
     disabled: NotRequired[bool]

cribl_control_plane/models/inputexec.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -30,18 +29,14 @@ class InputExecConnection(BaseModel):
 class InputExecMode(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 InputExecCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -107,24 +102,6 @@ class InputExecPq(BaseModel):
         Optional[InputExecPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputExecMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputExecCompression(value)
-            except ValueError:
-                return value
-        return value
-
 
 class ScheduleType(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Select a schedule type; either an interval (in seconds) or a cron-style schedule."""
@@ -247,12 +224,3 @@ class InputExec(BaseModel):
         "* * * * *"
     )
     r"""Cron schedule to execute the command on."""
-
-    @field_serializer("schedule_type")
-    def serialize_schedule_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.ScheduleType(value)
-            except ValueError:
-                return value
-        return value

cribl_control_plane/models/inputfile.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -30,18 +29,14 @@ class InputFileConnection(BaseModel):
 class InputFilePqMode(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 InputFileCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -107,31 +102,11 @@ class InputFilePq(BaseModel):
         Optional[InputFilePqControls], pydantic.Field(alias="pqControls")
     ] = None
 
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFilePqMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFileCompression(value)
-            except ValueError:
-                return value
-        return value
-
 
 class InputFileMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Choose how to discover files to monitor"""
 
-    # Auto
     AUTO = "auto"
-    # Manual
     MANUAL = "manual"
 
 
@@ -176,10 +151,8 @@ class InputFileTypedDict(TypedDict):
     r"""Read only new entries at the end of all files discovered at next startup. @{product} will then read newly discovered files from the head. Disable this to resume reading all files from head."""
     idle_timeout: NotRequired[float]
     r"""Time, in seconds, before an idle file is closed"""
-    min_age_dur: NotRequired[str]
-    r"""The minimum age of files to monitor. Format examples: 30s, 15m, 1h. Age is relative to file modification time. Leave empty to apply no age filters."""
     max_age_dur: NotRequired[str]
-    r"""The maximum age of event timestamps to collect. Format examples: 60s, 4h, 3d, 1w. Can be used in conjuction with \"Check file modification times\". Leave empty to apply no age filters."""
+    r"""The maximum age of files to monitor. Format examples: 60s, 4h, 3d, 1w. Age is relative to file modification time. Leave empty to apply no age filters."""
     check_file_mod_time: NotRequired[bool]
     r"""Skip files with modification times earlier than the maximum age duration"""
     force_text: NotRequired[bool]
@@ -251,11 +224,8 @@ class InputFile(BaseModel):
     idle_timeout: Annotated[Optional[float], pydantic.Field(alias="idleTimeout")] = 300
     r"""Time, in seconds, before an idle file is closed"""
 
-    min_age_dur: Annotated[Optional[str], pydantic.Field(alias="minAgeDur")] = None
-    r"""The minimum age of files to monitor. Format examples: 30s, 15m, 1h. Age is relative to file modification time. Leave empty to apply no age filters."""
-
     max_age_dur: Annotated[Optional[str], pydantic.Field(alias="maxAgeDur")] = None
-    r"""The maximum age of event timestamps to collect. Format examples: 60s, 4h, 3d, 1w. Can be used in conjuction with \"Check file modification times\". Leave empty to apply no age filters."""
+    r"""The maximum age of files to monitor. Format examples: 60s, 4h, 3d, 1w. Age is relative to file modification time. Leave empty to apply no age filters."""
 
     check_file_mod_time: Annotated[
         Optional[bool], pydantic.Field(alias="checkFileModTime")
@@ -300,12 +270,3 @@ class InputFile(BaseModel):
         Optional[bool], pydantic.Field(alias="includeUnidentifiableBinary")
     ] = False
     r"""Stream binary files as Base64-encoded chunks."""
-
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFileMode(value)
-            except ValueError:
-                return value
-        return value

cribl_control_plane/models/inputfirehose.py

@@ -1,14 +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 import 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 import Any, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -30,18 +29,14 @@ class InputFirehoseConnection(BaseModel):
 class InputFirehoseMode(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 InputFirehoseCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -107,24 +102,6 @@ class InputFirehosePq(BaseModel):
         Optional[InputFirehosePqControls], pydantic.Field(alias="pqControls")
     ] = None
 
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFirehoseMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFirehoseCompression(value)
-            except ValueError:
-                return value
-        return value
-
 
 class InputFirehoseMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
@@ -142,12 +119,6 @@ class InputFirehoseMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputFirehoseTLSSettingsServerSideTypedDict(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]
@@ -158,6 +129,10 @@ class InputFirehoseTLSSettingsServerSideTypedDict(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[InputFirehoseMinimumTLSVersion]
     max_version: NotRequired[InputFirehoseMaximumTLSVersion]
 
@@ -165,19 +140,6 @@ class InputFirehoseTLSSettingsServerSideTypedDict(TypedDict):
 class InputFirehoseTLSSettingsServerSide(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
@@ -195,6 +157,17 @@ class InputFirehoseTLSSettingsServerSide(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[InputFirehoseMinimumTLSVersion],
@@ -211,24 +184,6 @@ class InputFirehoseTLSSettingsServerSide(BaseModel):
         pydantic.Field(alias="maxVersion"),
     ] = None
 
-    @field_serializer("min_version")
-    def serialize_min_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFirehoseMinimumTLSVersion(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("max_version")
-    def serialize_max_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputFirehoseMaximumTLSVersion(value)
-            except ValueError:
-                return value
-        return value
-
 
 class InputFirehoseMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputgooglepubsub.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -30,18 +29,14 @@ class InputGooglePubsubConnection(BaseModel):
 class InputGooglePubsubMode(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 InputGooglePubsubCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -108,35 +103,14 @@ class InputGooglePubsubPq(BaseModel):
         Optional[InputGooglePubsubPqControls], pydantic.Field(alias="pqControls")
     ] = None
 
-    @field_serializer("mode")
-    def serialize_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputGooglePubsubMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputGooglePubsubCompression(value)
-            except ValueError:
-                return value
-        return value
-
 
 class InputGooglePubsubGoogleAuthenticationMethod(
     str, Enum, metaclass=utils.OpenEnumMeta
 ):
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
 
-    # Auto
     AUTO = "auto"
-    # Manual
     MANUAL = "manual"
-    # Secret
     SECRET = "secret"
 
 
@@ -291,12 +265,3 @@ class InputGooglePubsub(BaseModel):
         Optional[bool], pydantic.Field(alias="orderedDelivery")
     ] = False
     r"""Receive events in the order they were added to the queue. The process sending events must have ordering enabled."""
-
-    @field_serializer("google_auth_method")
-    def serialize_google_auth_method(self, value):
-        if isinstance(value, str):
-            try:
-                return models.InputGooglePubsubGoogleAuthenticationMethod(value)
-            except ValueError:
-                return value
-        return value