cribl-control-plane 0.0.38__py3-none-any.whl → 0.4.0a6__py3-none-any.whl

cribl_control_plane/models/output.py

@@ -8,7 +8,9 @@ from .outputazuredataexplorer import (
 )
 from .outputazureeventhub import OutputAzureEventhub, OutputAzureEventhubTypedDict
 from .outputazurelogs import OutputAzureLogs, OutputAzureLogsTypedDict
+from .outputchronicle import OutputChronicle, OutputChronicleTypedDict
 from .outputclickhouse import OutputClickHouse, OutputClickHouseTypedDict
+from .outputcloudflarer2 import OutputCloudflareR2, OutputCloudflareR2TypedDict
 from .outputcloudwatch import OutputCloudwatch, OutputCloudwatchTypedDict
 from .outputconfluentcloud import OutputConfluentCloud, OutputConfluentCloudTypedDict
 from .outputcriblhttp import OutputCriblHTTP, OutputCriblHTTPTypedDict
@@ -18,6 +20,7 @@ from .outputcrowdstrikenextgensiem import (
     OutputCrowdstrikeNextGenSiem,
     OutputCrowdstrikeNextGenSiemTypedDict,
 )
+from .outputdatabricks import OutputDatabricks, OutputDatabricksTypedDict
 from .outputdatadog import OutputDatadog, OutputDatadogTypedDict
 from .outputdataset import OutputDataset, OutputDatasetTypedDict
 from .outputdefault import OutputDefault, OutputDefaultTypedDict
@@ -48,6 +51,7 @@ from .outputinfluxdb import OutputInfluxdb, OutputInfluxdbTypedDict
 from .outputkafka import OutputKafka, OutputKafkaTypedDict
 from .outputkinesis import OutputKinesis, OutputKinesisTypedDict
 from .outputloki import OutputLoki, OutputLokiTypedDict
+from .outputmicrosoftfabric import OutputMicrosoftFabric, OutputMicrosoftFabricTypedDict
 from .outputminio import OutputMinio, OutputMinioTypedDict
 from .outputmsk import OutputMsk, OutputMskTypedDict
 from .outputnetflow import OutputNetflow, OutputNetflowTypedDict
@@ -80,8 +84,10 @@ from .outputtcpjson import OutputTcpjson, OutputTcpjsonTypedDict
 from .outputwavefront import OutputWavefront, OutputWavefrontTypedDict
 from .outputwebhook import OutputWebhook, OutputWebhookTypedDict
 from .outputxsiam import OutputXsiam, OutputXsiamTypedDict
+from cribl_control_plane.utils import get_discriminator
+from pydantic import Discriminator, Tag
 from typing import Union
-from typing_extensions import TypeAliasType
+from typing_extensions import Annotated, TypeAliasType
 
 
 OutputTypedDict = TypeAliasType(
@@ -90,137 +96,145 @@ OutputTypedDict = TypeAliasType(
         OutputDevnullTypedDict,
         OutputDefaultTypedDict,
         OutputRouterTypedDict,
-        OutputNetflowTypedDict,
         OutputSnmpTypedDict,
+        OutputNetflowTypedDict,
         OutputDiskSpoolTypedDict,
         OutputRingTypedDict,
-        OutputStatsdExtTypedDict,
         OutputGraphiteTypedDict,
+        OutputStatsdExtTypedDict,
         OutputStatsdTypedDict,
         OutputGooglePubsubTypedDict,
-        OutputCriblTCPTypedDict,
-        OutputSnsTypedDict,
         OutputSplunkTypedDict,
-        OutputCloudwatchTypedDict,
-        OutputSyslogTypedDict,
+        OutputSnsTypedDict,
+        OutputCriblTCPTypedDict,
         OutputAzureEventhubTypedDict,
-        OutputWavefrontTypedDict,
-        OutputSignalfxTypedDict,
+        OutputCloudwatchTypedDict,
+        OutputExabeamTypedDict,
+        OutputMicrosoftFabricTypedDict,
         OutputHoneycombTypedDict,
+        OutputSignalfxTypedDict,
+        OutputWavefrontTypedDict,
         OutputSumoLogicTypedDict,
-        OutputTcpjsonTypedDict,
+        OutputCrowdstrikeNextGenSiemTypedDict,
         OutputHumioHecTypedDict,
+        OutputTcpjsonTypedDict,
         OutputElasticCloudTypedDict,
-        OutputCrowdstrikeNextGenSiemTypedDict,
         OutputKinesisTypedDict,
         OutputConfluentCloudTypedDict,
         OutputKafkaTypedDict,
-        OutputExabeamTypedDict,
         OutputNewrelicEventsTypedDict,
         OutputAzureLogsTypedDict,
         OutputSplunkLbTypedDict,
         OutputSqsTypedDict,
         OutputNewrelicTypedDict,
-        OutputCriblHTTPTypedDict,
-        OutputXsiamTypedDict,
         OutputFilesystemTypedDict,
+        OutputSyslogTypedDict,
+        OutputXsiamTypedDict,
+        OutputCriblHTTPTypedDict,
         OutputDatasetTypedDict,
-        OutputSplunkHecTypedDict,
         OutputDynatraceHTTPTypedDict,
-        OutputServiceNowTypedDict,
         OutputLokiTypedDict,
+        OutputChronicleTypedDict,
         OutputDynatraceOtlpTypedDict,
-        OutputGoogleChronicleTypedDict,
+        OutputServiceNowTypedDict,
+        OutputSplunkHecTypedDict,
+        OutputCriblLakeTypedDict,
         OutputElasticTypedDict,
         OutputDatadogTypedDict,
-        OutputCriblLakeTypedDict,
+        OutputGoogleChronicleTypedDict,
         OutputPrometheusTypedDict,
-        OutputMskTypedDict,
+        OutputDatabricksTypedDict,
         OutputSentinelOneAiSiemTypedDict,
+        OutputMskTypedDict,
         OutputSentinelTypedDict,
-        OutputInfluxdbTypedDict,
         OutputGoogleCloudStorageTypedDict,
+        OutputInfluxdbTypedDict,
         OutputAzureBlobTypedDict,
-        OutputOpenTelemetryTypedDict,
+        OutputCloudflareR2TypedDict,
         OutputMinioTypedDict,
-        OutputClickHouseTypedDict,
+        OutputOpenTelemetryTypedDict,
         OutputSecurityLakeTypedDict,
+        OutputClickHouseTypedDict,
         OutputDlS3TypedDict,
         OutputS3TypedDict,
-        OutputAzureDataExplorerTypedDict,
         OutputWebhookTypedDict,
         OutputGoogleCloudLoggingTypedDict,
+        OutputAzureDataExplorerTypedDict,
         OutputGrafanaCloudTypedDict,
     ],
 )
 
 
-Output = TypeAliasType(
-    "Output",
+Output = Annotated[
     Union[
-        OutputDevnull,
-        OutputDefault,
-        OutputRouter,
-        OutputNetflow,
-        OutputSnmp,
-        OutputDiskSpool,
-        OutputRing,
-        OutputStatsdExt,
-        OutputGraphite,
-        OutputStatsd,
-        OutputGooglePubsub,
-        OutputCriblTCP,
-        OutputSns,
-        OutputSplunk,
-        OutputCloudwatch,
-        OutputSyslog,
-        OutputAzureEventhub,
-        OutputWavefront,
-        OutputSignalfx,
-        OutputHoneycomb,
-        OutputSumoLogic,
-        OutputTcpjson,
-        OutputHumioHec,
-        OutputElasticCloud,
-        OutputCrowdstrikeNextGenSiem,
-        OutputKinesis,
-        OutputConfluentCloud,
-        OutputKafka,
-        OutputExabeam,
-        OutputNewrelicEvents,
-        OutputAzureLogs,
-        OutputSplunkLb,
-        OutputSqs,
-        OutputNewrelic,
-        OutputCriblHTTP,
-        OutputXsiam,
-        OutputFilesystem,
-        OutputDataset,
-        OutputSplunkHec,
-        OutputDynatraceHTTP,
-        OutputServiceNow,
-        OutputLoki,
-        OutputDynatraceOtlp,
-        OutputGoogleChronicle,
-        OutputElastic,
-        OutputDatadog,
-        OutputCriblLake,
-        OutputPrometheus,
-        OutputMsk,
-        OutputSentinelOneAiSiem,
-        OutputSentinel,
-        OutputInfluxdb,
-        OutputGoogleCloudStorage,
-        OutputAzureBlob,
-        OutputOpenTelemetry,
-        OutputMinio,
-        OutputClickHouse,
-        OutputSecurityLake,
-        OutputDlS3,
-        OutputS3,
-        OutputAzureDataExplorer,
-        OutputWebhook,
-        OutputGoogleCloudLogging,
-        OutputGrafanaCloud,
+        Annotated[OutputDefault, Tag("default")],
+        Annotated[OutputWebhook, Tag("webhook")],
+        Annotated[OutputSentinel, Tag("sentinel")],
+        Annotated[OutputDevnull, Tag("devnull")],
+        Annotated[OutputSyslog, Tag("syslog")],
+        Annotated[OutputSplunk, Tag("splunk")],
+        Annotated[OutputSplunkLb, Tag("splunk_lb")],
+        Annotated[OutputSplunkHec, Tag("splunk_hec")],
+        Annotated[OutputTcpjson, Tag("tcpjson")],
+        Annotated[OutputWavefront, Tag("wavefront")],
+        Annotated[OutputSignalfx, Tag("signalfx")],
+        Annotated[OutputFilesystem, Tag("filesystem")],
+        Annotated[OutputS3, Tag("s3")],
+        Annotated[OutputAzureBlob, Tag("azure_blob")],
+        Annotated[OutputAzureDataExplorer, Tag("azure_data_explorer")],
+        Annotated[OutputAzureLogs, Tag("azure_logs")],
+        Annotated[OutputKinesis, Tag("kinesis")],
+        Annotated[OutputHoneycomb, Tag("honeycomb")],
+        Annotated[OutputAzureEventhub, Tag("azure_eventhub")],
+        Annotated[OutputGoogleChronicle, Tag("google_chronicle")],
+        Annotated[OutputGoogleCloudStorage, Tag("google_cloud_storage")],
+        Annotated[OutputGoogleCloudLogging, Tag("google_cloud_logging")],
+        Annotated[OutputGooglePubsub, Tag("google_pubsub")],
+        Annotated[OutputExabeam, Tag("exabeam")],
+        Annotated[OutputKafka, Tag("kafka")],
+        Annotated[OutputConfluentCloud, Tag("confluent_cloud")],
+        Annotated[OutputMsk, Tag("msk")],
+        Annotated[OutputElastic, Tag("elastic")],
+        Annotated[OutputElasticCloud, Tag("elastic_cloud")],
+        Annotated[OutputNewrelic, Tag("newrelic")],
+        Annotated[OutputNewrelicEvents, Tag("newrelic_events")],
+        Annotated[OutputInfluxdb, Tag("influxdb")],
+        Annotated[OutputCloudwatch, Tag("cloudwatch")],
+        Annotated[OutputMinio, Tag("minio")],
+        Annotated[OutputStatsd, Tag("statsd")],
+        Annotated[OutputStatsdExt, Tag("statsd_ext")],
+        Annotated[OutputGraphite, Tag("graphite")],
+        Annotated[OutputRouter, Tag("router")],
+        Annotated[OutputSns, Tag("sns")],
+        Annotated[OutputSqs, Tag("sqs")],
+        Annotated[OutputSnmp, Tag("snmp")],
+        Annotated[OutputSumoLogic, Tag("sumo_logic")],
+        Annotated[OutputDatadog, Tag("datadog")],
+        Annotated[OutputGrafanaCloud, Tag("grafana_cloud")],
+        Annotated[OutputLoki, Tag("loki")],
+        Annotated[OutputPrometheus, Tag("prometheus")],
+        Annotated[OutputRing, Tag("ring")],
+        Annotated[OutputOpenTelemetry, Tag("open_telemetry")],
+        Annotated[OutputServiceNow, Tag("service_now")],
+        Annotated[OutputDataset, Tag("dataset")],
+        Annotated[OutputCriblTCP, Tag("cribl_tcp")],
+        Annotated[OutputCriblHTTP, Tag("cribl_http")],
+        Annotated[OutputHumioHec, Tag("humio_hec")],
+        Annotated[OutputCrowdstrikeNextGenSiem, Tag("crowdstrike_next_gen_siem")],
+        Annotated[OutputDlS3, Tag("dl_s3")],
+        Annotated[OutputSecurityLake, Tag("security_lake")],
+        Annotated[OutputCriblLake, Tag("cribl_lake")],
+        Annotated[OutputDiskSpool, Tag("disk_spool")],
+        Annotated[OutputClickHouse, Tag("click_house")],
+        Annotated[OutputXsiam, Tag("xsiam")],
+        Annotated[OutputNetflow, Tag("netflow")],
+        Annotated[OutputDynatraceHTTP, Tag("dynatrace_http")],
+        Annotated[OutputDynatraceOtlp, Tag("dynatrace_otlp")],
+        Annotated[OutputSentinelOneAiSiem, Tag("sentinel_one_ai_siem")],
+        Annotated[OutputChronicle, Tag("chronicle")],
+        Annotated[OutputDatabricks, Tag("databricks")],
+        Annotated[OutputMicrosoftFabric, Tag("microsoft_fabric")],
+        Annotated[OutputCloudflareR2, Tag("cloudflare_r2")],
     ],
-)
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]

cribl_control_plane/models/outputazureblob.py

@@ -1,9 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -12,70 +16,90 @@ class OutputAzureBlobType(str, Enum):
     AZURE_BLOB = "azure_blob"
 
 
-class OutputAzureBlobDataFormat(str, Enum):
+class OutputAzureBlobDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of the output data"""
 
+    # JSON
     JSON = "json"
+    # Raw
     RAW = "raw"
+    # Parquet
     PARQUET = "parquet"
 
 
-class OutputAzureBlobBackpressureBehavior(str, Enum):
+class OutputAzureBlobBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
 
 
-class OutputAzureBlobDiskSpaceProtection(str, Enum):
+class OutputAzureBlobDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
 
 
-class OutputAzureBlobAuthenticationMethod(str, Enum):
+class OutputAzureBlobAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     MANUAL = "manual"
     SECRET = "secret"
     CLIENT_SECRET = "clientSecret"
     CLIENT_CERT = "clientCert"
 
 
-class BlobAccessTier(str, Enum):
+class BlobAccessTier(str, Enum, metaclass=utils.OpenEnumMeta):
+    # Default account access tier
     INFERRED = "Inferred"
+    # Hot tier
     HOT = "Hot"
+    # Cool tier
     COOL = "Cool"
+    # Cold tier
     COLD = "Cold"
+    # Archive tier
     ARCHIVE = "Archive"
 
 
-class OutputAzureBlobCompression(str, Enum):
+class OutputAzureBlobCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputAzureBlobCompressionLevel(str, Enum):
+class OutputAzureBlobCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Compression level to apply before moving files to final destination"""
 
+    # Best Speed
     BEST_SPEED = "best_speed"
+    # Normal
     NORMAL = "normal"
+    # Best Compression
     BEST_COMPRESSION = "best_compression"
 
 
-class OutputAzureBlobParquetVersion(str, Enum):
+class OutputAzureBlobParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Determines which data types are supported and how they are represented"""
 
+    # 1.0
     PARQUET_1_0 = "PARQUET_1_0"
+    # 2.4
     PARQUET_2_4 = "PARQUET_2_4"
+    # 2.6
     PARQUET_2_6 = "PARQUET_2_6"
 
 
-class OutputAzureBlobDataPageVersion(str, Enum):
+class OutputAzureBlobDataPageVersion(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."""
 
+    # V1
     DATA_PAGE_V1 = "DATA_PAGE_V1"
+    # V2
     DATA_PAGE_V2 = "DATA_PAGE_V2"
 
 
@@ -152,6 +176,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     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: NotRequired[OutputAzureBlobDiskSpaceProtection]
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
+    force_close_on_shutdown: NotRequired[bool]
+    r"""Force all staged files to close during an orderly Node shutdown. This triggers immediate upload of in-progress data — regardless of idle time, file age, or size thresholds — to minimize data loss."""
     auth_type: NotRequired[OutputAzureBlobAuthenticationMethod]
     storage_class: NotRequired[BlobAccessTier]
     description: NotRequired[str]
@@ -161,6 +187,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     r"""Compression level to apply before moving files to final destination"""
     automatic_schema: NotRequired[bool]
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
+    parquet_schema: NotRequired[str]
+    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
     parquet_version: NotRequired[OutputAzureBlobParquetVersion]
     r"""Determines which data types are supported and how they are represented"""
     parquet_data_page_version: NotRequired[OutputAzureBlobDataPageVersion]
@@ -181,6 +209,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
     empty_dir_cleanup_sec: NotRequired[float]
     r"""How frequently, in seconds, to clean up empty directories"""
+    directory_batch_size: NotRequired[float]
+    r"""Number of directories to process in each batch during cleanup of empty directories. Minimum is 10, maximum is 10000. Higher values may require more memory."""
     deadletter_path: NotRequired[str]
     r"""Storage location for files that fail to reach their final destination after maximum retries are exceeded"""
     max_retry_num: NotRequired[float]
@@ -261,7 +291,11 @@ class OutputAzureBlob(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[OutputAzureBlobDataFormat], pydantic.Field(alias="format")
+        Annotated[
+            Optional[OutputAzureBlobDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="format"),
     ] = OutputAzureBlobDataFormat.JSON
     r"""Format of the output data"""
 
@@ -304,7 +338,10 @@ class OutputAzureBlob(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Optional[OutputAzureBlobBackpressureBehavior],
+        Annotated[
+            Optional[OutputAzureBlobBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputAzureBlobBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -315,26 +352,44 @@ class OutputAzureBlob(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[OutputAzureBlobDiskSpaceProtection],
+        Annotated[
+            Optional[OutputAzureBlobDiskSpaceProtection],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputAzureBlobDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
+    force_close_on_shutdown: Annotated[
+        Optional[bool], pydantic.Field(alias="forceCloseOnShutdown")
+    ] = False
+    r"""Force all staged files to close during an orderly Node shutdown. This triggers immediate upload of in-progress data — regardless of idle time, file age, or size thresholds — to minimize data loss."""
+
     auth_type: Annotated[
-        Optional[OutputAzureBlobAuthenticationMethod], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[OutputAzureBlobAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = OutputAzureBlobAuthenticationMethod.MANUAL
 
     storage_class: Annotated[
-        Optional[BlobAccessTier], pydantic.Field(alias="storageClass")
+        Annotated[Optional[BlobAccessTier], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="storageClass"),
     ] = BlobAccessTier.INFERRED
 
     description: Optional[str] = None
 
-    compress: Optional[OutputAzureBlobCompression] = OutputAzureBlobCompression.GZIP
+    compress: Annotated[
+        Optional[OutputAzureBlobCompression], PlainValidator(validate_open_enum(False))
+    ] = OutputAzureBlobCompression.GZIP
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     compression_level: Annotated[
-        Optional[OutputAzureBlobCompressionLevel],
+        Annotated[
+            Optional[OutputAzureBlobCompressionLevel],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="compressionLevel"),
     ] = OutputAzureBlobCompressionLevel.BEST_SPEED
     r"""Compression level to apply before moving files to final destination"""
@@ -344,13 +399,25 @@ class OutputAzureBlob(BaseModel):
     ] = False
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
 
+    parquet_schema: Annotated[Optional[str], pydantic.Field(alias="parquetSchema")] = (
+        None
+    )
+    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
+
     parquet_version: Annotated[
-        Optional[OutputAzureBlobParquetVersion], pydantic.Field(alias="parquetVersion")
+        Annotated[
+            Optional[OutputAzureBlobParquetVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="parquetVersion"),
     ] = OutputAzureBlobParquetVersion.PARQUET_2_6
     r"""Determines which data types are supported and how they are represented"""
 
     parquet_data_page_version: Annotated[
-        Optional[OutputAzureBlobDataPageVersion],
+        Annotated[
+            Optional[OutputAzureBlobDataPageVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="parquetDataPageVersion"),
     ] = OutputAzureBlobDataPageVersion.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."""
@@ -396,6 +463,11 @@ class OutputAzureBlob(BaseModel):
     ] = 300
     r"""How frequently, in seconds, to clean up empty directories"""
 
+    directory_batch_size: Annotated[
+        Optional[float], pydantic.Field(alias="directoryBatchSize")
+    ] = 1000
+    r"""Number of directories to process in each batch during cleanup of empty directories. Minimum is 10, maximum is 10000. Higher values may require more memory."""
+
     deadletter_path: Annotated[
         Optional[str], pydantic.Field(alias="deadletterPath")
     ] = "$CRIBL_HOME/state/outputs/dead-letter"
@@ -437,3 +509,84 @@ class OutputAzureBlob(BaseModel):
     r"""Select or create a stored text secret"""
 
     certificate: Optional[OutputAzureBlobCertificate] = None
+
+    @field_serializer("format_")
+    def serialize_format_(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDataFormat(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_backpressure")
+    def serialize_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobBackpressureBehavior(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_disk_full_backpressure")
+    def serialize_on_disk_full_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDiskSpaceProtection(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("storage_class")
+    def serialize_storage_class(self, value):
+        if isinstance(value, str):
+            try:
+                return models.BlobAccessTier(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobCompression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compression_level")
+    def serialize_compression_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobCompressionLevel(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_version")
+    def serialize_parquet_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobParquetVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_data_page_version")
+    def serialize_parquet_data_page_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDataPageVersion(value)
+            except ValueError:
+                return value
+        return value