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

cribl_control_plane/models/outputminio.py

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

cribl_control_plane/models/outputmsk.py

@@ -1,9 +1,12 @@
 """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
 
@@ -12,7 +15,7 @@ class OutputMskType(str, Enum):
     MSK = "msk"
 
 
-class OutputMskAcknowledgments(int, Enum):
+class OutputMskAcknowledgments(int, Enum, metaclass=utils.OpenEnumMeta):
     r"""Control the number of required acknowledgments."""
 
     ONE = 1
@@ -20,7 +23,7 @@ class OutputMskAcknowledgments(int, Enum):
     MINUS_1 = -1
 
 
-class OutputMskRecordDataFormat(str, Enum):
+class OutputMskRecordDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format to use to serialize events before writing to Kafka."""
 
     JSON = "json"
@@ -28,7 +31,7 @@ class OutputMskRecordDataFormat(str, Enum):
     PROTOBUF = "protobuf"
 
 
-class OutputMskCompression(str, Enum):
+class OutputMskCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the data before sending to Kafka"""
 
     NONE = "none"
@@ -37,13 +40,6 @@ class OutputMskCompression(str, Enum):
     LZ4 = "lz4"
 
 
-class OutputMskSchemaType(str, Enum):
-    r"""The schema format used to encode and decode event data"""
-
-    AVRO = "avro"
-    JSON = "json"
-
-
 class OutputMskAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
 
@@ -63,14 +59,18 @@ class OutputMskAuth(BaseModel):
     r"""Select or create a secret that references your credentials"""
 
 
-class OutputMskKafkaSchemaRegistryMinimumTLSVersion(str, Enum):
+class OutputMskKafkaSchemaRegistryMinimumTLSVersion(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class OutputMskKafkaSchemaRegistryMaximumTLSVersion(str, Enum):
+class OutputMskKafkaSchemaRegistryMaximumTLSVersion(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -130,12 +130,18 @@ class OutputMskKafkaSchemaRegistryTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Optional[OutputMskKafkaSchemaRegistryMinimumTLSVersion],
+        Annotated[
+            Optional[OutputMskKafkaSchemaRegistryMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[OutputMskKafkaSchemaRegistryMaximumTLSVersion],
+        Annotated[
+            Optional[OutputMskKafkaSchemaRegistryMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="maxVersion"),
     ] = None
 
@@ -144,8 +150,6 @@ class OutputMskKafkaSchemaRegistryAuthenticationTypedDict(TypedDict):
     disabled: NotRequired[bool]
     schema_registry_url: NotRequired[str]
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
-    schema_type: NotRequired[OutputMskSchemaType]
-    r"""The schema format used to encode and decode event data"""
     connection_timeout: NotRequired[float]
     r"""Maximum time to wait for a Schema Registry connection to complete successfully"""
     request_timeout: NotRequired[float]
@@ -169,11 +173,6 @@ class OutputMskKafkaSchemaRegistryAuthentication(BaseModel):
     ] = "http://localhost:8081"
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
 
-    schema_type: Annotated[
-        Optional[OutputMskSchemaType], pydantic.Field(alias="schemaType")
-    ] = OutputMskSchemaType.AVRO
-    r"""The schema format used to encode and decode event data"""
-
     connection_timeout: Annotated[
         Optional[float], pydantic.Field(alias="connectionTimeout")
     ] = 30000
@@ -203,7 +202,7 @@ class OutputMskKafkaSchemaRegistryAuthentication(BaseModel):
     r"""Used when __valueSchemaIdOut is not present, to transform _raw, leave blank if value transformation is not required by default."""
 
 
-class OutputMskAuthenticationMethod(str, Enum):
+class OutputMskAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
     AUTO = "auto"
@@ -211,21 +210,21 @@ class OutputMskAuthenticationMethod(str, Enum):
     SECRET = "secret"
 
 
-class OutputMskSignatureVersion(str, Enum):
+class OutputMskSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Signature version to use for signing MSK cluster requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputMskMinimumTLSVersion(str, Enum):
+class OutputMskMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class OutputMskMaximumTLSVersion(str, Enum):
+class OutputMskMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -285,15 +284,23 @@ class OutputMskTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Optional[OutputMskMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[OutputMskMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[OutputMskMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[OutputMskMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
 
-class OutputMskBackpressureBehavior(str, Enum):
+class OutputMskBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -301,21 +308,21 @@ class OutputMskBackpressureBehavior(str, Enum):
     QUEUE = "queue"
 
 
-class OutputMskPqCompressCompression(str, Enum):
+class OutputMskPqCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputMskQueueFullBehavior(str, Enum):
+class OutputMskQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     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 OutputMskMode(str, Enum):
+class OutputMskMode(str, Enum, metaclass=utils.OpenEnumMeta):
     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"
@@ -452,15 +459,23 @@ class OutputMsk(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
-    ack: Optional[OutputMskAcknowledgments] = OutputMskAcknowledgments.ONE
+    ack: Annotated[
+        Optional[OutputMskAcknowledgments], PlainValidator(validate_open_enum(True))
+    ] = OutputMskAcknowledgments.ONE
     r"""Control the number of required acknowledgments."""
 
     format_: Annotated[
-        Optional[OutputMskRecordDataFormat], pydantic.Field(alias="format")
+        Annotated[
+            Optional[OutputMskRecordDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="format"),
     ] = OutputMskRecordDataFormat.JSON
     r"""Format to use to serialize events before writing to Kafka."""
 
-    compression: Optional[OutputMskCompression] = OutputMskCompression.GZIP
+    compression: Annotated[
+        Optional[OutputMskCompression], PlainValidator(validate_open_enum(False))
+    ] = OutputMskCompression.GZIP
     r"""Codec to use to compress the data before sending to Kafka"""
 
     max_record_size_kb: Annotated[
@@ -518,7 +533,10 @@ class OutputMsk(BaseModel):
     r"""Specifies a time window during which @{product} can reauthenticate if needed. Creates the window measuring backward from the moment when credentials are set to expire."""
 
     aws_authentication_method: Annotated[
-        Optional[OutputMskAuthenticationMethod],
+        Annotated[
+            Optional[OutputMskAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputMskAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -531,7 +549,11 @@ class OutputMsk(BaseModel):
     r"""MSK cluster service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to MSK cluster-compatible endpoint."""
 
     signature_version: Annotated[
-        Optional[OutputMskSignatureVersion], pydantic.Field(alias="signatureVersion")
+        Annotated[
+            Optional[OutputMskSignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
     ] = OutputMskSignatureVersion.V4
     r"""Signature version to use for signing MSK cluster requests"""
 
@@ -568,7 +590,11 @@ class OutputMsk(BaseModel):
     tls: Optional[OutputMskTLSSettingsClientSide] = None
 
     on_backpressure: Annotated[
-        Optional[OutputMskBackpressureBehavior], pydantic.Field(alias="onBackpressure")
+        Annotated[
+            Optional[OutputMskBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="onBackpressure"),
     ] = OutputMskBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -598,18 +624,27 @@ class OutputMsk(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[
-        Optional[OutputMskPqCompressCompression], pydantic.Field(alias="pqCompress")
+        Annotated[
+            Optional[OutputMskPqCompressCompression],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqCompress"),
     ] = OutputMskPqCompressCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputMskQueueFullBehavior], pydantic.Field(alias="pqOnBackpressure")
+        Annotated[
+            Optional[OutputMskQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputMskQueueFullBehavior.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[Optional[OutputMskMode], pydantic.Field(alias="pqMode")] = (
-        OutputMskMode.ERROR
-    )
+    pq_mode: Annotated[
+        Annotated[Optional[OutputMskMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputMskMode.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[