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

cribl_control_plane/models/outputconfluentcloud.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 OutputConfluentCloudType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudType(str, Enum):
     CONFLUENT_CLOUD = "confluent_cloud"
 
 
-class OutputConfluentCloudMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class OutputConfluentCloudMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudMaximumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -82,23 +79,17 @@ class OutputConfluentCloudTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudMinimumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudMinimumTLSVersion],
         pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudMaximumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudMaximumTLSVersion],
         pydantic.Field(alias="maxVersion"),
     ] = None
 
 
-class OutputConfluentCloudAcknowledgments(int, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudAcknowledgments(int, Enum):
     r"""Control the number of required acknowledgments."""
 
     ONE = 1
@@ -106,7 +97,7 @@ class OutputConfluentCloudAcknowledgments(int, Enum, metaclass=utils.OpenEnumMet
     MINUS_1 = -1
 
 
-class OutputConfluentCloudRecordDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudRecordDataFormat(str, Enum):
     r"""Format to use to serialize events before writing to Kafka."""
 
     JSON = "json"
@@ -114,7 +105,7 @@ class OutputConfluentCloudRecordDataFormat(str, Enum, metaclass=utils.OpenEnumMe
     PROTOBUF = "protobuf"
 
 
-class OutputConfluentCloudCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudCompression(str, Enum):
     r"""Codec to use to compress the data before sending to Kafka"""
 
     NONE = "none"
@@ -142,18 +133,14 @@ class OutputConfluentCloudAuth(BaseModel):
     r"""Select or create a secret that references your credentials"""
 
 
-class OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -213,18 +200,12 @@ class OutputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion],
         pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion],
         pydantic.Field(alias="maxVersion"),
     ] = None
 
@@ -287,7 +268,7 @@ class OutputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     r"""Used when __valueSchemaIdOut is not present, to transform _raw, leave blank if value transformation is not required by default."""
 
 
-class OutputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudSASLMechanism(str, Enum):
     PLAIN = "plain"
     SCRAM_SHA_256 = "scram-sha-256"
     SCRAM_SHA_512 = "scram-sha-512"
@@ -306,13 +287,12 @@ class OutputConfluentCloudAuthentication(BaseModel):
 
     disabled: Optional[bool] = True
 
-    mechanism: Annotated[
-        Optional[OutputConfluentCloudSASLMechanism],
-        PlainValidator(validate_open_enum(False)),
-    ] = OutputConfluentCloudSASLMechanism.PLAIN
+    mechanism: Optional[OutputConfluentCloudSASLMechanism] = (
+        OutputConfluentCloudSASLMechanism.PLAIN
+    )
 
 
-class OutputConfluentCloudBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -320,23 +300,21 @@ class OutputConfluentCloudBackpressureBehavior(str, Enum, metaclass=utils.OpenEn
     QUEUE = "queue"
 
 
-class OutputConfluentCloudPqCompressCompression(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputConfluentCloudPqCompressCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputConfluentCloudQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudQueueFullBehavior(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 OutputConfluentCloudMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputConfluentCloudMode(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"
@@ -432,9 +410,7 @@ class OutputConfluentCloud(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputConfluentCloudType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputConfluentCloudType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -452,25 +428,19 @@ class OutputConfluentCloud(BaseModel):
 
     tls: Optional[OutputConfluentCloudTLSSettingsClientSide] = None
 
-    ack: Annotated[
-        Optional[OutputConfluentCloudAcknowledgments],
-        PlainValidator(validate_open_enum(True)),
-    ] = OutputConfluentCloudAcknowledgments.ONE
+    ack: Optional[OutputConfluentCloudAcknowledgments] = (
+        OutputConfluentCloudAcknowledgments.ONE
+    )
     r"""Control the number of required acknowledgments."""
 
     format_: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudRecordDataFormat],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="format"),
+        Optional[OutputConfluentCloudRecordDataFormat], pydantic.Field(alias="format")
     ] = OutputConfluentCloudRecordDataFormat.JSON
     r"""Format to use to serialize events before writing to Kafka."""
 
-    compression: Annotated[
-        Optional[OutputConfluentCloudCompression],
-        PlainValidator(validate_open_enum(False)),
-    ] = OutputConfluentCloudCompression.GZIP
+    compression: Optional[OutputConfluentCloudCompression] = (
+        OutputConfluentCloudCompression.GZIP
+    )
     r"""Codec to use to compress the data before sending to Kafka"""
 
     max_record_size_kb: Annotated[
@@ -531,10 +501,7 @@ class OutputConfluentCloud(BaseModel):
     r"""Authentication parameters to use when connecting to brokers. Using TLS is highly recommended."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputConfluentCloudBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -560,29 +527,19 @@ class OutputConfluentCloud(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[OutputConfluentCloudPqCompressCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudPqCompressCompression],
         pydantic.Field(alias="pqCompress"),
     ] = OutputConfluentCloudPqCompressCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputConfluentCloudQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputConfluentCloudQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputConfluentCloudQueueFullBehavior.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[OutputConfluentCloudMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputConfluentCloudMode], pydantic.Field(alias="pqMode")
     ] = OutputConfluentCloudMode.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/outputcriblhttp.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 OutputCriblHTTPType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPType(str, Enum):
     CRIBL_HTTP = "cribl_http"
 
 
-class OutputCriblHTTPMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class OutputCriblHTTPMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPMaximumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -82,23 +79,15 @@ class OutputCriblHTTPTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Annotated[
-            Optional[OutputCriblHTTPMinimumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="minVersion"),
+        Optional[OutputCriblHTTPMinimumTLSVersion], pydantic.Field(alias="minVersion")
     ] = None
 
     max_version: Annotated[
-        Annotated[
-            Optional[OutputCriblHTTPMaximumTLSVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="maxVersion"),
+        Optional[OutputCriblHTTPMaximumTLSVersion], pydantic.Field(alias="maxVersion")
     ] = None
 
 
-class OutputCriblHTTPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPCompression(str, Enum):
     r"""Codec to use to compress the data before sending"""
 
     NONE = "none"
@@ -116,7 +105,7 @@ class OutputCriblHTTPExtraHTTPHeader(BaseModel):
     name: Optional[str] = None
 
 
-class OutputCriblHTTPFailedRequestLoggingMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPFailedRequestLoggingMode(str, Enum):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
     PAYLOAD = "payload"
@@ -178,7 +167,7 @@ class OutputCriblHTTPTimeoutRetrySettings(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 OutputCriblHTTPBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -201,21 +190,21 @@ class OutputCriblHTTPURL(BaseModel):
     r"""Assign a weight (>0) to each endpoint to indicate its traffic-handling capability"""
 
 
-class OutputCriblHTTPPqCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPPqCompressCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputCriblHTTPQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPQueueFullBehavior(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 OutputCriblHTTPMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblHTTPMode(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"
@@ -313,7 +302,7 @@ class OutputCriblHTTP(BaseModel):
     id: str
     r"""Unique ID for this output"""
 
-    type: Annotated[OutputCriblHTTPType, PlainValidator(validate_open_enum(False))]
+    type: OutputCriblHTTPType
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -346,9 +335,7 @@ class OutputCriblHTTP(BaseModel):
     ] = None
     r"""Fields to exclude from the event. By default, all internal fields except `__output` are sent. Example: `cribl_pipe`, `c*`. Wildcards supported."""
 
-    compression: Annotated[
-        Optional[OutputCriblHTTPCompression], PlainValidator(validate_open_enum(False))
-    ] = OutputCriblHTTPCompression.GZIP
+    compression: Optional[OutputCriblHTTPCompression] = OutputCriblHTTPCompression.GZIP
     r"""Codec to use to compress the data before sending"""
 
     concurrency: Optional[float] = 5
@@ -387,10 +374,7 @@ class OutputCriblHTTP(BaseModel):
     r"""Headers to add to all events"""
 
     failed_request_logging_mode: Annotated[
-        Annotated[
-            Optional[OutputCriblHTTPFailedRequestLoggingMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblHTTPFailedRequestLoggingMode],
         pydantic.Field(alias="failedRequestLoggingMode"),
     ] = OutputCriblHTTPFailedRequestLoggingMode.NONE
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
@@ -417,10 +401,7 @@ class OutputCriblHTTP(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[OutputCriblHTTPBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblHTTPBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputCriblHTTPBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -464,28 +445,19 @@ class OutputCriblHTTP(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[OutputCriblHTTPPqCompressCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblHTTPPqCompressCompression],
         pydantic.Field(alias="pqCompress"),
     ] = OutputCriblHTTPPqCompressCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputCriblHTTPQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblHTTPQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputCriblHTTPQueueFullBehavior.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[OutputCriblHTTPMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputCriblHTTPMode], pydantic.Field(alias="pqMode")
     ] = OutputCriblHTTPMode.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/outputcribllake.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 OutputCriblLakeType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeType(str, Enum):
     CRIBL_LAKE = "cribl_lake"
 
 
-class OutputCriblLakeSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeSignatureVersion(str, Enum):
     r"""Signature version to use for signing S3 requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputCriblLakeObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeObjectACL(str, Enum):
     r"""Object ACL to assign to uploaded objects"""
 
     PRIVATE = "private"
@@ -34,7 +31,7 @@ class OutputCriblLakeObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
     BUCKET_OWNER_FULL_CONTROL = "bucket-owner-full-control"
 
 
-class OutputCriblLakeStorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeStorageClass(str, Enum):
     r"""Storage class to select for uploaded objects"""
 
     STANDARD = "STANDARD"
@@ -47,34 +44,32 @@ class OutputCriblLakeStorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
     DEEP_ARCHIVE = "DEEP_ARCHIVE"
 
 
-class OutputCriblLakeServerSideEncryptionForUploadedObjects(
-    str, Enum, metaclass=utils.OpenEnumMeta
-):
+class OutputCriblLakeServerSideEncryptionForUploadedObjects(str, Enum):
     AES256 = "AES256"
     AWS_KMS = "aws:kms"
 
 
-class OutputCriblLakeBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class OutputCriblLakeDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeDiskSpaceProtection(str, Enum):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
     BLOCK = "block"
     DROP = "drop"
 
 
-class AwsAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+class AwsAuthenticationMethod(str, Enum):
     AUTO = "auto"
     AUTO_RPC = "auto_rpc"
     MANUAL = "manual"
 
 
-class OutputCriblLakeFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputCriblLakeFormat(str, Enum):
     JSON = "json"
     PARQUET = "parquet"
     DDSS = "ddss"
@@ -174,7 +169,7 @@ class OutputCriblLake(BaseModel):
     id: str
     r"""Unique ID for this output"""
 
-    type: Annotated[OutputCriblLakeType, PlainValidator(validate_open_enum(False))]
+    type: OutputCriblLakeType
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -205,10 +200,7 @@ class OutputCriblLake(BaseModel):
     r"""S3 service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to S3-compatible endpoint."""
 
     signature_version: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeSignatureVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblLakeSignatureVersion],
         pydantic.Field(alias="signatureVersion"),
     ] = OutputCriblLakeSignatureVersion.V4
     r"""Signature version to use for signing S3 requests"""
@@ -257,28 +249,17 @@ class OutputCriblLake(BaseModel):
     r"""Lake dataset to send the data to."""
 
     object_acl: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeObjectACL],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="objectACL"),
+        Optional[OutputCriblLakeObjectACL], pydantic.Field(alias="objectACL")
     ] = OutputCriblLakeObjectACL.PRIVATE
     r"""Object ACL to assign to uploaded objects"""
 
     storage_class: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeStorageClass],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="storageClass"),
+        Optional[OutputCriblLakeStorageClass], pydantic.Field(alias="storageClass")
     ] = None
     r"""Storage class to select for uploaded objects"""
 
     server_side_encryption: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeServerSideEncryptionForUploadedObjects],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblLakeServerSideEncryptionForUploadedObjects],
         pydantic.Field(alias="serverSideEncryption"),
     ] = None
 
@@ -319,10 +300,7 @@ class OutputCriblLake(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblLakeBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputCriblLakeBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -333,10 +311,7 @@ class OutputCriblLake(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[OutputCriblLakeDiskSpaceProtection],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputCriblLakeDiskSpaceProtection],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputCriblLakeDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
@@ -362,17 +337,12 @@ class OutputCriblLake(BaseModel):
     r"""Maximum number of files that can be waiting for upload before backpressure is applied"""
 
     aws_authentication_method: Annotated[
-        Annotated[
-            Optional[AwsAuthenticationMethod], PlainValidator(validate_open_enum(False))
-        ],
+        Optional[AwsAuthenticationMethod],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = AwsAuthenticationMethod.AUTO
 
     format_: Annotated[
-        Annotated[
-            Optional[OutputCriblLakeFormat], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="format"),
+        Optional[OutputCriblLakeFormat], pydantic.Field(alias="format")
     ] = None
 
     max_concurrent_file_parts: Annotated[