cribl-control-plane 0.0.15__py3-none-any.whl → 0.0.17__py3-none-any.whl

cribl_control_plane/models/outputelasticcloud.py

@@ -1,17 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from cribl_control_plane import utils
 from cribl_control_plane.types import BaseModel
-from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
-from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class OutputElasticCloudType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudType(str, Enum):
     ELASTIC_CLOUD = "elastic_cloud"
 
 
@@ -26,9 +23,7 @@ class OutputElasticCloudExtraHTTPHeader(BaseModel):
     name: Optional[str] = None
 
 
-class OutputElasticCloudFailedRequestLoggingMode(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputElasticCloudFailedRequestLoggingMode(str, Enum):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
     PAYLOAD = "payload"
@@ -47,7 +42,7 @@ class OutputElasticCloudExtraParam(BaseModel):
     value: str
 
 
-class OutputElasticCloudAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudAuthenticationMethod(str, Enum):
     r"""Enter credentials directly, or select a stored secret"""
 
     MANUAL = "manual"
@@ -66,10 +61,7 @@ class OutputElasticCloudAuth(BaseModel):
     disabled: Optional[bool] = False
 
     auth_type: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudAuthenticationMethod],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputElasticCloudAuthenticationMethod],
         pydantic.Field(alias="authType"),
     ] = OutputElasticCloudAuthenticationMethod.MANUAL
     r"""Enter credentials directly, or select a stored secret"""
@@ -129,7 +121,7 @@ class OutputElasticCloudTimeoutRetrySettings(BaseModel):
     r"""The maximum backoff interval, in milliseconds, Cribl Stream should apply. Default (and minimum) is 10,000 ms (10 seconds); maximum is 180,000 ms (180 seconds)."""
 
 
-class OutputElasticCloudBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -137,21 +129,21 @@ class OutputElasticCloudBackpressureBehavior(str, Enum, metaclass=utils.OpenEnum
     QUEUE = "queue"
 
 
-class OutputElasticCloudCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputElasticCloudQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudQueueFullBehavior(str, Enum):
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputElasticCloudMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputElasticCloudMode(str, Enum):
     r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
 
     ERROR = "error"
@@ -248,9 +240,7 @@ class OutputElasticCloud(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputElasticCloudType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputElasticCloudType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -305,10 +295,7 @@ class OutputElasticCloud(BaseModel):
     r"""Headers to add to all events"""
 
     failed_request_logging_mode: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudFailedRequestLoggingMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputElasticCloudFailedRequestLoggingMode],
         pydantic.Field(alias="failedRequestLoggingMode"),
     ] = OutputElasticCloudFailedRequestLoggingMode.NONE
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
@@ -353,10 +340,7 @@ class OutputElasticCloud(BaseModel):
     r"""Honor any Retry-After header that specifies a delay (in seconds) no longer than 180 seconds after the retry request. @{product} limits the delay to 180 seconds, even if the Retry-After header specifies a longer delay. When enabled, takes precedence over user-configured retry options. When disabled, all Retry-After headers are ignored."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputElasticCloudBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputElasticCloudBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -377,28 +361,18 @@ class OutputElasticCloud(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputElasticCloudCompression], pydantic.Field(alias="pqCompress")
     ] = OutputElasticCloudCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputElasticCloudQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputElasticCloudQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
     pq_mode: Annotated[
-        Annotated[
-            Optional[OutputElasticCloudMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputElasticCloudMode], pydantic.Field(alias="pqMode")
     ] = OutputElasticCloudMode.ERROR
     r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
 

cribl_control_plane/models/outputexabeam.py

@@ -1,28 +1,25 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-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.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class OutputExabeamType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamType(str, Enum):
     EXABEAM = "exabeam"
 
 
-class OutputExabeamSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamSignatureVersion(str, Enum):
     r"""Signature version to use for signing Google Cloud Storage requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputExabeamObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamObjectACL(str, Enum):
     r"""Object ACL to assign to uploaded objects"""
 
     PRIVATE = "private"
@@ -33,7 +30,7 @@ class OutputExabeamObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
     PUBLIC_READ = "public-read"
 
 
-class OutputExabeamStorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamStorageClass(str, Enum):
     r"""Storage class to select for uploaded objects"""
 
     STANDARD = "STANDARD"
@@ -42,14 +39,14 @@ class OutputExabeamStorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
     ARCHIVE = "ARCHIVE"
 
 
-class OutputExabeamBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputExabeamDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputExabeamDiskSpaceProtection(str, Enum):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
     BLOCK = "block"
@@ -143,9 +140,7 @@ class OutputExabeam(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputExabeamType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputExabeamType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -170,28 +165,18 @@ class OutputExabeam(BaseModel):
     r"""Google Cloud Storage service endpoint"""
 
     signature_version: Annotated[
-        Annotated[
-            Optional[OutputExabeamSignatureVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputExabeamSignatureVersion],
         pydantic.Field(alias="signatureVersion"),
     ] = OutputExabeamSignatureVersion.V4
     r"""Signature version to use for signing Google Cloud Storage requests"""
 
     object_acl: Annotated[
-        Annotated[
-            Optional[OutputExabeamObjectACL], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="objectACL"),
+        Optional[OutputExabeamObjectACL], pydantic.Field(alias="objectACL")
     ] = OutputExabeamObjectACL.PRIVATE
     r"""Object ACL to assign to uploaded objects"""
 
     storage_class: Annotated[
-        Annotated[
-            Optional[OutputExabeamStorageClass],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="storageClass"),
+        Optional[OutputExabeamStorageClass], pydantic.Field(alias="storageClass")
     ] = None
     r"""Storage class to select for uploaded objects"""
 
@@ -231,10 +216,7 @@ class OutputExabeam(BaseModel):
     r"""Maximum number of files to keep open concurrently. When exceeded, @{product} will close the oldest open files and move them to the final output location."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputExabeamBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputExabeamBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputExabeamBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -245,10 +227,7 @@ class OutputExabeam(BaseModel):
     r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
 
     on_disk_full_backpressure: Annotated[
-        Annotated[
-            Optional[OutputExabeamDiskSpaceProtection],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputExabeamDiskSpaceProtection],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputExabeamDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""

cribl_control_plane/models/outputfilesystem.py

@@ -1,21 +1,18 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-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.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class OutputFilesystemType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemType(str, Enum):
     FILESYSTEM = "filesystem"
 
 
-class OutputFilesystemDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemDataFormat(str, Enum):
     r"""Format of the output data"""
 
     JSON = "json"
@@ -23,28 +20,28 @@ class OutputFilesystemDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     PARQUET = "parquet"
 
 
-class OutputFilesystemBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputFilesystemDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemDiskSpaceProtection(str, Enum):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputFilesystemCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemCompression(str, Enum):
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputFilesystemCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemCompressionLevel(str, Enum):
     r"""Compression level to apply before moving files to final destination"""
 
     BEST_SPEED = "best_speed"
@@ -52,7 +49,7 @@ class OutputFilesystemCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
     BEST_COMPRESSION = "best_compression"
 
 
-class OutputFilesystemParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemParquetVersion(str, Enum):
     r"""Determines which data types are supported and how they are represented"""
 
     PARQUET_1_0 = "PARQUET_1_0"
@@ -60,7 +57,7 @@ class OutputFilesystemParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     PARQUET_2_6 = "PARQUET_2_6"
 
 
-class OutputFilesystemDataPageVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputFilesystemDataPageVersion(str, Enum):
     r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
 
     DATA_PAGE_V1 = "DATA_PAGE_V1"
@@ -158,7 +155,7 @@ class OutputFilesystemTypedDict(TypedDict):
 
 
 class OutputFilesystem(BaseModel):
-    type: Annotated[OutputFilesystemType, PlainValidator(validate_open_enum(False))]
+    type: OutputFilesystemType
 
     dest_path: Annotated[str, pydantic.Field(alias="destPath")]
     r"""Final destination for the output files"""
@@ -199,11 +196,7 @@ class OutputFilesystem(BaseModel):
     r"""JavaScript expression defining how files are partitioned and organized. Default is date-based. If blank, Stream will fall back to the event's __partition field value – if present – otherwise to each location's root directory."""
 
     format_: Annotated[
-        Annotated[
-            Optional[OutputFilesystemDataFormat],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="format"),
+        Optional[OutputFilesystemDataFormat], pydantic.Field(alias="format")
     ] = OutputFilesystemDataFormat.JSON
     r"""Format of the output data"""
 
@@ -246,10 +239,7 @@ class OutputFilesystem(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputFilesystemBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputFilesystemBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputFilesystemBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -260,26 +250,18 @@ class OutputFilesystem(BaseModel):
     r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
 
     on_disk_full_backpressure: Annotated[
-        Annotated[
-            Optional[OutputFilesystemDiskSpaceProtection],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputFilesystemDiskSpaceProtection],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputFilesystemDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
     description: Optional[str] = None
 
-    compress: Annotated[
-        Optional[OutputFilesystemCompression], PlainValidator(validate_open_enum(False))
-    ] = OutputFilesystemCompression.GZIP
+    compress: Optional[OutputFilesystemCompression] = OutputFilesystemCompression.GZIP
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     compression_level: Annotated[
-        Annotated[
-            Optional[OutputFilesystemCompressionLevel],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputFilesystemCompressionLevel],
         pydantic.Field(alias="compressionLevel"),
     ] = OutputFilesystemCompressionLevel.BEST_SPEED
     r"""Compression level to apply before moving files to final destination"""
@@ -290,19 +272,12 @@ class OutputFilesystem(BaseModel):
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
 
     parquet_version: Annotated[
-        Annotated[
-            Optional[OutputFilesystemParquetVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="parquetVersion"),
+        Optional[OutputFilesystemParquetVersion], pydantic.Field(alias="parquetVersion")
     ] = OutputFilesystemParquetVersion.PARQUET_2_6
     r"""Determines which data types are supported and how they are represented"""
 
     parquet_data_page_version: Annotated[
-        Annotated[
-            Optional[OutputFilesystemDataPageVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputFilesystemDataPageVersion],
         pydantic.Field(alias="parquetDataPageVersion"),
     ] = OutputFilesystemDataPageVersion.DATA_PAGE_V2
     r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""

cribl_control_plane/models/outputgooglechronicle.py

@@ -1,28 +1,23 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-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.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class OutputGoogleChronicleType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputGoogleChronicleType(str, Enum):
     GOOGLE_CHRONICLE = "google_chronicle"
 
 
-class OutputGoogleChronicleAPIVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputGoogleChronicleAPIVersion(str, Enum):
     V1 = "v1"
     V2 = "v2"
 
 
-class OutputGoogleChronicleAuthenticationMethod(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputGoogleChronicleAuthenticationMethod(str, Enum):
     MANUAL = "manual"
     SECRET = "secret"
     SERVICE_ACCOUNT = "serviceAccount"
@@ -83,7 +78,7 @@ class OutputGoogleChronicleTimeoutRetrySettings(BaseModel):
     r"""The maximum backoff interval, in milliseconds, Cribl Stream should apply. Default (and minimum) is 10,000 ms (10 seconds); maximum is 180,000 ms (180 seconds)."""
 
 
-class SendEventsAs(str, Enum, metaclass=utils.OpenEnumMeta):
+class SendEventsAs(str, Enum):
     UNSTRUCTURED = "unstructured"
     UDM = "udm"
 
@@ -99,9 +94,7 @@ class OutputGoogleChronicleExtraHTTPHeader(BaseModel):
     name: Optional[str] = None
 
 
-class OutputGoogleChronicleFailedRequestLoggingMode(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputGoogleChronicleFailedRequestLoggingMode(str, Enum):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
     PAYLOAD = "payload"
@@ -109,9 +102,7 @@ class OutputGoogleChronicleFailedRequestLoggingMode(
     NONE = "none"
 
 
-class OutputGoogleChronicleBackpressureBehavior(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputGoogleChronicleBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -141,21 +132,21 @@ class CustomLabel(BaseModel):
     value: str
 
 
-class OutputGoogleChronicleCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputGoogleChronicleCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputGoogleChronicleQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputGoogleChronicleQueueFullBehavior(str, Enum):
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputGoogleChronicleMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputGoogleChronicleMode(str, Enum):
     r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
 
     ERROR = "error"
@@ -265,9 +256,7 @@ class OutputGoogleChronicleTypedDict(TypedDict):
 
 
 class OutputGoogleChronicle(BaseModel):
-    type: Annotated[
-        OutputGoogleChronicleType, PlainValidator(validate_open_enum(False))
-    ]
+    type: OutputGoogleChronicleType
 
     id: Optional[str] = None
     r"""Unique ID for this output"""
@@ -287,18 +276,11 @@ class OutputGoogleChronicle(BaseModel):
     r"""Tags for filtering and grouping in @{product}"""
 
     api_version: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleAPIVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="apiVersion"),
+        Optional[OutputGoogleChronicleAPIVersion], pydantic.Field(alias="apiVersion")
     ] = OutputGoogleChronicleAPIVersion.V1
 
     authentication_method: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleAuthenticationMethod],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputGoogleChronicleAuthenticationMethod],
         pydantic.Field(alias="authenticationMethod"),
     ] = OutputGoogleChronicleAuthenticationMethod.SERVICE_ACCOUNT
 
@@ -319,8 +301,7 @@ class OutputGoogleChronicle(BaseModel):
     r"""Honor any Retry-After header that specifies a delay (in seconds) no longer than 180 seconds after the retry request. @{product} limits the delay to 180 seconds, even if the Retry-After header specifies a longer delay. When enabled, takes precedence over user-configured retry options. When disabled, all Retry-After headers are ignored."""
 
     log_format_type: Annotated[
-        Annotated[Optional[SendEventsAs], PlainValidator(validate_open_enum(False))],
-        pydantic.Field(alias="logFormatType"),
+        Optional[SendEventsAs], pydantic.Field(alias="logFormatType")
     ] = SendEventsAs.UNSTRUCTURED
 
     region: Optional[str] = None
@@ -365,10 +346,7 @@ class OutputGoogleChronicle(BaseModel):
     r"""Headers to add to all events"""
 
     failed_request_logging_mode: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleFailedRequestLoggingMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputGoogleChronicleFailedRequestLoggingMode],
         pydantic.Field(alias="failedRequestLoggingMode"),
     ] = OutputGoogleChronicleFailedRequestLoggingMode.NONE
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
@@ -384,10 +362,7 @@ class OutputGoogleChronicle(BaseModel):
     r"""Enable round-robin DNS lookup. When a DNS server returns multiple addresses, @{product} will cycle through them in the order returned."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputGoogleChronicleBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputGoogleChronicleBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -455,29 +430,18 @@ class OutputGoogleChronicle(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputGoogleChronicleCompression], pydantic.Field(alias="pqCompress")
     ] = OutputGoogleChronicleCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputGoogleChronicleQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputGoogleChronicleQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
     pq_mode: Annotated[
-        Annotated[
-            Optional[OutputGoogleChronicleMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputGoogleChronicleMode], pydantic.Field(alias="pqMode")
     ] = OutputGoogleChronicleMode.ERROR
     r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""