cribl-control-plane 0.0.50rc2__py3-none-any.whl → 0.0.52__py3-none-any.whl

cribl_control_plane/models/outputkinesis.py

@@ -1,12 +1,9 @@
 """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
 
@@ -15,7 +12,7 @@ class OutputKinesisType(str, Enum):
     KINESIS = "kinesis"
 
 
-class OutputKinesisAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
     AUTO = "auto"
@@ -23,21 +20,21 @@ class OutputKinesisAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta)
     SECRET = "secret"
 
 
-class OutputKinesisSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisSignatureVersion(str, Enum):
     r"""Signature version to use for signing Kinesis stream requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputKinesisCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisCompression(str, Enum):
     r"""Compression type to use for records"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputKinesisBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -45,21 +42,21 @@ class OutputKinesisBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta)
     QUEUE = "queue"
 
 
-class OutputKinesisPqCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisPqCompressCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputKinesisQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisQueueFullBehavior(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 OutputKinesisMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputKinesisMode(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"
@@ -170,10 +167,7 @@ class OutputKinesis(BaseModel):
     r"""Tags for filtering and grouping in @{product}"""
 
     aws_authentication_method: Annotated[
-        Annotated[
-            Optional[OutputKinesisAuthenticationMethod],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputKinesisAuthenticationMethod],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputKinesisAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -186,10 +180,7 @@ class OutputKinesis(BaseModel):
     r"""Kinesis stream service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to Kinesis stream-compatible endpoint."""
 
     signature_version: Annotated[
-        Annotated[
-            Optional[OutputKinesisSignatureVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputKinesisSignatureVersion],
         pydantic.Field(alias="signatureVersion"),
     ] = OutputKinesisSignatureVersion.V4
     r"""Signature version to use for signing Kinesis stream requests"""
@@ -237,9 +228,7 @@ class OutputKinesis(BaseModel):
     ] = 1
     r"""Maximum time between requests. Small values could cause the payload size to be smaller than the configured Max record size."""
 
-    compression: Annotated[
-        Optional[OutputKinesisCompression], PlainValidator(validate_open_enum(False))
-    ] = OutputKinesisCompression.GZIP
+    compression: Optional[OutputKinesisCompression] = OutputKinesisCompression.GZIP
     r"""Compression type to use for records"""
 
     use_list_shards: Annotated[
@@ -251,10 +240,7 @@ class OutputKinesis(BaseModel):
     r"""Batch events into a single record as NDJSON"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputKinesisBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputKinesisBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputKinesisBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -280,29 +266,19 @@ class OutputKinesis(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[OutputKinesisPqCompressCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputKinesisPqCompressCompression], pydantic.Field(alias="pqCompress")
     ] = OutputKinesisPqCompressCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputKinesisQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputKinesisQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputKinesisQueueFullBehavior.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[OutputKinesisMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputKinesisMode.ERROR
+    pq_mode: Annotated[Optional[OutputKinesisMode], pydantic.Field(alias="pqMode")] = (
+        OutputKinesisMode.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."""
 
     pq_controls: Annotated[

cribl_control_plane/models/outputloki.py

@@ -1,12 +1,9 @@
 """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
 
@@ -15,7 +12,7 @@ class OutputLokiType(str, Enum):
     LOKI = "loki"
 
 
-class OutputLokiMessageFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiMessageFormat(str, Enum):
     r"""Format to use when sending logs to Loki (Protobuf or JSON)"""
 
     PROTOBUF = "protobuf"
@@ -33,7 +30,7 @@ class OutputLokiLabel(BaseModel):
     name: Optional[str] = ""
 
 
-class OutputLokiAuthenticationType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiAuthenticationType(str, Enum):
     NONE = "none"
     TOKEN = "token"
     TEXT_SECRET = "textSecret"
@@ -52,7 +49,7 @@ class OutputLokiExtraHTTPHeader(BaseModel):
     name: Optional[str] = None
 
 
-class OutputLokiFailedRequestLoggingMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiFailedRequestLoggingMode(str, Enum):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
     PAYLOAD = "payload"
@@ -114,7 +111,7 @@ class OutputLokiTimeoutRetrySettings(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 OutputLokiBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -122,21 +119,21 @@ class OutputLokiBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     QUEUE = "queue"
 
 
-class OutputLokiCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputLokiQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiQueueFullBehavior(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 OutputLokiMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputLokiMode(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"
@@ -262,10 +259,7 @@ class OutputLoki(BaseModel):
     r"""Name of the event field that contains the message to send. If not specified, Stream sends a JSON representation of the whole event."""
 
     message_format: Annotated[
-        Annotated[
-            Optional[OutputLokiMessageFormat], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="messageFormat"),
+        Optional[OutputLokiMessageFormat], pydantic.Field(alias="messageFormat")
     ] = OutputLokiMessageFormat.PROTOBUF
     r"""Format to use when sending logs to Loki (Protobuf or JSON)"""
 
@@ -273,11 +267,7 @@ class OutputLoki(BaseModel):
     r"""List of labels to send with logs. Labels define Loki streams, so use static labels to avoid proliferating label value combinations and streams. Can be merged and/or overridden by the event's __labels field. Example: '__labels: {host: \"cribl.io\", level: \"error\"}'"""
 
     auth_type: Annotated[
-        Annotated[
-            Optional[OutputLokiAuthenticationType],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="authType"),
+        Optional[OutputLokiAuthenticationType], pydantic.Field(alias="authType")
     ] = OutputLokiAuthenticationType.NONE
 
     concurrency: Optional[float] = 1
@@ -321,10 +311,7 @@ class OutputLoki(BaseModel):
     r"""Enable round-robin DNS lookup. When a DNS server returns multiple addresses, @{product} will cycle through them in the order returned. For optimal performance, consider enabling this setting for non-load balanced destinations."""
 
     failed_request_logging_mode: Annotated[
-        Annotated[
-            Optional[OutputLokiFailedRequestLoggingMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputLokiFailedRequestLoggingMode],
         pydantic.Field(alias="failedRequestLoggingMode"),
     ] = OutputLokiFailedRequestLoggingMode.NONE
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
@@ -356,11 +343,7 @@ class OutputLoki(BaseModel):
     r"""Add per-event HTTP headers from the __headers field to outgoing requests. Events with different headers are batched and sent separately."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputLokiBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="onBackpressure"),
+        Optional[OutputLokiBackpressureBehavior], pydantic.Field(alias="onBackpressure")
     ] = OutputLokiBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -405,26 +388,18 @@ class OutputLoki(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[OutputLokiCompression], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputLokiCompression], pydantic.Field(alias="pqCompress")
     ] = OutputLokiCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputLokiQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqOnBackpressure"),
+        Optional[OutputLokiQueueFullBehavior], pydantic.Field(alias="pqOnBackpressure")
     ] = OutputLokiQueueFullBehavior.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[OutputLokiMode], PlainValidator(validate_open_enum(False))],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputLokiMode.ERROR
+    pq_mode: Annotated[Optional[OutputLokiMode], pydantic.Field(alias="pqMode")] = (
+        OutputLokiMode.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."""
 
     pq_controls: Annotated[

cribl_control_plane/models/outputminio.py

@@ -1,12 +1,9 @@
 """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
 
@@ -15,7 +12,7 @@ class OutputMinioType(str, Enum):
     MINIO = "minio"
 
 
-class OutputMinioAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
     AUTO = "auto"
@@ -23,14 +20,14 @@ class OutputMinioAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     SECRET = "secret"
 
 
-class OutputMinioSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioSignatureVersion(str, Enum):
     r"""Signature version to use for signing MinIO requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputMinioObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioObjectACL(str, Enum):
     r"""Object ACL to assign to uploaded objects"""
 
     PRIVATE = "private"
@@ -42,20 +39,20 @@ class OutputMinioObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
     BUCKET_OWNER_FULL_CONTROL = "bucket-owner-full-control"
 
 
-class OutputMinioStorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioStorageClass(str, Enum):
     r"""Storage class to select for uploaded objects"""
 
     STANDARD = "STANDARD"
     REDUCED_REDUNDANCY = "REDUCED_REDUNDANCY"
 
 
-class ServerSideEncryption(str, Enum, metaclass=utils.OpenEnumMeta):
+class ServerSideEncryption(str, Enum):
     r"""Server-side encryption for uploaded objects"""
 
     AES256 = "AES256"
 
 
-class OutputMinioDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioDataFormat(str, Enum):
     r"""Format of the output data"""
 
     JSON = "json"
@@ -63,28 +60,28 @@ class OutputMinioDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     PARQUET = "parquet"
 
 
-class OutputMinioBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputMinioDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioDiskSpaceProtection(str, Enum):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputMinioCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioCompression(str, Enum):
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputMinioCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioCompressionLevel(str, Enum):
     r"""Compression level to apply before moving files to final destination"""
 
     BEST_SPEED = "best_speed"
@@ -92,7 +89,7 @@ class OutputMinioCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
     BEST_COMPRESSION = "best_compression"
 
 
-class OutputMinioParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioParquetVersion(str, Enum):
     r"""Determines which data types are supported and how they are represented"""
 
     PARQUET_1_0 = "PARQUET_1_0"
@@ -100,7 +97,7 @@ class OutputMinioParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     PARQUET_2_6 = "PARQUET_2_6"
 
 
-class OutputMinioDataPageVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputMinioDataPageVersion(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"
@@ -254,10 +251,7 @@ class OutputMinio(BaseModel):
     r"""Tags for filtering and grouping in @{product}"""
 
     aws_authentication_method: Annotated[
-        Annotated[
-            Optional[OutputMinioAuthenticationMethod],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputMinioAuthenticationMethod],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputMinioAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -284,35 +278,22 @@ class OutputMinio(BaseModel):
     r"""Root directory to prepend to path before uploading. Enter a constant, or a JavaScript expression enclosed in quotes or backticks."""
 
     signature_version: Annotated[
-        Annotated[
-            Optional[OutputMinioSignatureVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="signatureVersion"),
+        Optional[OutputMinioSignatureVersion], pydantic.Field(alias="signatureVersion")
     ] = OutputMinioSignatureVersion.V4
     r"""Signature version to use for signing MinIO requests"""
 
     object_acl: Annotated[
-        Annotated[
-            Optional[OutputMinioObjectACL], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="objectACL"),
+        Optional[OutputMinioObjectACL], pydantic.Field(alias="objectACL")
     ] = OutputMinioObjectACL.PRIVATE
     r"""Object ACL to assign to uploaded objects"""
 
     storage_class: Annotated[
-        Annotated[
-            Optional[OutputMinioStorageClass], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="storageClass"),
+        Optional[OutputMinioStorageClass], pydantic.Field(alias="storageClass")
     ] = None
     r"""Storage class to select for uploaded objects"""
 
     server_side_encryption: Annotated[
-        Annotated[
-            Optional[ServerSideEncryption], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="serverSideEncryption"),
+        Optional[ServerSideEncryption], pydantic.Field(alias="serverSideEncryption")
     ] = None
     r"""Server-side encryption for uploaded objects"""
 
@@ -342,10 +323,7 @@ class OutputMinio(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[OutputMinioDataFormat], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="format"),
+        Optional[OutputMinioDataFormat], pydantic.Field(alias="format")
     ] = OutputMinioDataFormat.JSON
     r"""Format of the output data"""
 
@@ -378,10 +356,7 @@ class OutputMinio(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputMinioBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputMinioBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputMinioBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -392,10 +367,7 @@ class OutputMinio(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[OutputMinioDiskSpaceProtection],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputMinioDiskSpaceProtection],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputMinioDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
@@ -423,17 +395,11 @@ class OutputMinio(BaseModel):
     aws_secret: Annotated[Optional[str], pydantic.Field(alias="awsSecret")] = None
     r"""Select or create a stored secret that references your access key and secret key"""
 
-    compress: Annotated[
-        Optional[OutputMinioCompression], PlainValidator(validate_open_enum(False))
-    ] = OutputMinioCompression.GZIP
+    compress: Optional[OutputMinioCompression] = OutputMinioCompression.GZIP
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     compression_level: Annotated[
-        Annotated[
-            Optional[OutputMinioCompressionLevel],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="compressionLevel"),
+        Optional[OutputMinioCompressionLevel], pydantic.Field(alias="compressionLevel")
     ] = OutputMinioCompressionLevel.BEST_SPEED
     r"""Compression level to apply before moving files to final destination"""
 
@@ -443,19 +409,12 @@ class OutputMinio(BaseModel):
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
 
     parquet_version: Annotated[
-        Annotated[
-            Optional[OutputMinioParquetVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="parquetVersion"),
+        Optional[OutputMinioParquetVersion], pydantic.Field(alias="parquetVersion")
     ] = OutputMinioParquetVersion.PARQUET_2_6
     r"""Determines which data types are supported and how they are represented"""
 
     parquet_data_page_version: Annotated[
-        Annotated[
-            Optional[OutputMinioDataPageVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputMinioDataPageVersion],
         pydantic.Field(alias="parquetDataPageVersion"),
     ] = OutputMinioDataPageVersion.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."""