cribl-control-plane 0.0.21__py3-none-any.whl → 0.4.0b23__py3-none-any.whl

cribl_control_plane/models/outputazuredataexplorer.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,12 +16,16 @@ class OutputAzureDataExplorerType(str, Enum):
     AZURE_DATA_EXPLORER = "azure_data_explorer"
 
 
-class IngestionMode(str, Enum):
+class IngestionMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    # Batching
     BATCHING = "batching"
+    # Streaming
     STREAMING = "streaming"
 
 
-class MicrosoftEntraIDAuthenticationEndpoint(str, Enum):
+class OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""Endpoint used to acquire authentication tokens from Azure"""
 
     HTTPS_LOGIN_MICROSOFTONLINE_COM = "https://login.microsoftonline.com"
@@ -25,11 +33,16 @@ class MicrosoftEntraIDAuthenticationEndpoint(str, Enum):
     HTTPS_LOGIN_PARTNER_MICROSOFTONLINE_CN = "https://login.partner.microsoftonline.cn"
 
 
-class OutputAzureDataExplorerAuthenticationMethod(str, Enum):
+class OutputAzureDataExplorerAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""The type of OAuth 2.0 client credentials grant flow to use"""
 
+    # Client secret
     CLIENT_SECRET = "clientSecret"
+    # Client secret (text secret)
     CLIENT_TEXT_SECRET = "clientTextSecret"
+    # Certificate
     CERTIFICATE = "certificate"
 
 
@@ -45,31 +58,96 @@ class OutputAzureDataExplorerCertificate(BaseModel):
     r"""The certificate you registered as credentials for your app in the Azure portal"""
 
 
-class OutputAzureDataExplorerBackpressureBehavior(str, Enum):
-    r"""How to handle events when all receivers are exerting backpressure"""
-
-    BLOCK = "block"
-    DROP = "drop"
-    QUEUE = "queue"
-
-
-class OutputAzureDataExplorerDataFormat(str, Enum):
+class OutputAzureDataExplorerDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of the output data"""
 
+    # JSON
     JSON = "json"
+    # Raw
     RAW = "raw"
+    # Parquet
     PARQUET = "parquet"
 
 
-class OutputAzureDataExplorerDiskSpaceProtection(str, Enum):
+class OutputAzureDataExplorerCompressCompression(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Data compression format to apply to HTTP content before it is delivered"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+class OutputAzureDataExplorerCompressionLevel(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 OutputAzureDataExplorerParquetVersion(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 OutputAzureDataExplorerDataPageVersion(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"
+
+
+class OutputAzureDataExplorerKeyValueMetadatumTypedDict(TypedDict):
+    value: str
+    key: NotRequired[str]
+
+
+class OutputAzureDataExplorerKeyValueMetadatum(BaseModel):
+    value: str
+
+    key: Optional[str] = ""
+
+
+class OutputAzureDataExplorerBackpressureBehavior(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""How to handle events when all receivers are exerting backpressure"""
+
+    # Block
+    BLOCK = "block"
+    # Drop
+    DROP = "drop"
+    # Persistent Queue
+    QUEUE = "queue"
+
+
+class OutputAzureDataExplorerDiskSpaceProtection(
+    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 PrefixOptional(str, Enum):
+class PrefixOptional(str, Enum, metaclass=utils.OpenEnumMeta):
+    # drop-by
     DROP_BY = "dropBy"
+    # ingest-by
     INGEST_BY = "ingestBy"
 
 
@@ -81,7 +159,18 @@ class ExtentTagTypedDict(TypedDict):
 class ExtentTag(BaseModel):
     value: str
 
-    prefix: Optional[PrefixOptional] = None
+    prefix: Annotated[
+        Optional[PrefixOptional], PlainValidator(validate_open_enum(False))
+    ] = None
+
+    @field_serializer("prefix")
+    def serialize_prefix(self, value):
+        if isinstance(value, str):
+            try:
+                return models.PrefixOptional(value)
+            except ValueError:
+                return value
+        return value
 
 
 class IngestIfNotExistTypedDict(TypedDict):
@@ -92,19 +181,25 @@ class IngestIfNotExist(BaseModel):
     value: str
 
 
-class ReportLevel(str, Enum):
+class ReportLevel(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Level of ingestion status reporting. Defaults to FailuresOnly."""
 
+    # FailuresOnly
     FAILURES_ONLY = "failuresOnly"
+    # DoNotReport
     DO_NOT_REPORT = "doNotReport"
+    # FailuresAndSuccesses
     FAILURES_AND_SUCCESSES = "failuresAndSuccesses"
 
 
-class ReportMethod(str, Enum):
+class ReportMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Target of the ingestion status reporting. Defaults to Queue."""
 
+    # Queue
     QUEUE = "queue"
+    # Table
     TABLE = "table"
+    # QueueAndTable
     QUEUE_AND_TABLE = "queueAndTable"
 
 
@@ -173,35 +268,37 @@ class OutputAzureDataExplorerTimeoutRetrySettings(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 OutputAzureDataExplorerCompressCompression(str, Enum):
-    r"""Data compression format to apply to HTTP content before it is delivered"""
+class OutputAzureDataExplorerMode(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."""
 
-    NONE = "none"
-    GZIP = "gzip"
+    # Error
+    ERROR = "error"
+    # Backpressure
+    ALWAYS = "always"
+    # Always On
+    BACKPRESSURE = "backpressure"
 
 
-class OutputAzureDataExplorerPqCompressCompression(str, Enum):
+class OutputAzureDataExplorerPqCompressCompression(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""Codec to use to compress the persisted data"""
 
+    # None
     NONE = "none"
+    # Gzip
     GZIP = "gzip"
 
 
-class OutputAzureDataExplorerQueueFullBehavior(str, Enum):
+class OutputAzureDataExplorerQueueFullBehavior(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 = "block"
+    # Drop new data
     DROP = "drop"
 
 
-class OutputAzureDataExplorerMode(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"
-    BACKPRESSURE = "backpressure"
-    ALWAYS = "always"
-
-
 class OutputAzureDataExplorerPqControlsTypedDict(TypedDict):
     pass
 
@@ -211,6 +308,7 @@ class OutputAzureDataExplorerPqControls(BaseModel):
 
 
 class OutputAzureDataExplorerTypedDict(TypedDict):
+    type: OutputAzureDataExplorerType
     cluster_url: str
     r"""The base URI for your cluster. Typically, `https://<cluster>.<region>.kusto.windows.net`."""
     database: str
@@ -225,7 +323,6 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     r"""Scope to pass in the OAuth request parameter"""
     id: NotRequired[str]
     r"""Unique ID for this output"""
-    type: NotRequired[OutputAzureDataExplorerType]
     pipeline: NotRequired[str]
     r"""Pipeline to process data before sending out to this output"""
     system_fields: NotRequired[List[str]]
@@ -237,7 +334,9 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     validate_database_settings: NotRequired[bool]
     r"""When saving or starting the Destination, validate the database name and credentials; also validate table name, except when creating a new table. Disable if your Azure app does not have both the Database Viewer and the Table Viewer role."""
     ingest_mode: NotRequired[IngestionMode]
-    oauth_endpoint: NotRequired[MicrosoftEntraIDAuthenticationEndpoint]
+    oauth_endpoint: NotRequired[
+        OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint
+    ]
     r"""Endpoint used to acquire authentication tokens from Azure"""
     oauth_type: NotRequired[OutputAzureDataExplorerAuthenticationMethod]
     r"""The type of OAuth 2.0 client credentials grant flow to use"""
@@ -247,14 +346,58 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     text_secret: NotRequired[str]
     r"""Select or create a stored text secret"""
     certificate: NotRequired[OutputAzureDataExplorerCertificateTypedDict]
+    format_: NotRequired[OutputAzureDataExplorerDataFormat]
+    r"""Format of the output data"""
+    compress: NotRequired[OutputAzureDataExplorerCompressCompression]
+    r"""Data compression format to apply to HTTP content before it is delivered"""
+    compression_level: NotRequired[OutputAzureDataExplorerCompressionLevel]
+    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[OutputAzureDataExplorerParquetVersion]
+    r"""Determines which data types are supported and how they are represented"""
+    parquet_data_page_version: NotRequired[OutputAzureDataExplorerDataPageVersion]
+    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."""
+    parquet_row_group_length: NotRequired[float]
+    r"""The number of rows that every group will contain. The final group can contain a smaller number of rows."""
+    parquet_page_size: NotRequired[str]
+    r"""Target memory size for page segments, such as 1MB or 128MB. Generally, lower values improve reading speed, while higher values improve compression."""
+    should_log_invalid_rows: NotRequired[bool]
+    r"""Log up to 3 rows that @{product} skips due to data mismatch"""
+    key_value_metadata: NotRequired[
+        List[OutputAzureDataExplorerKeyValueMetadatumTypedDict]
+    ]
+    r"""The metadata of files the Destination writes will include the properties you add here as key-value pairs. Useful for tagging. Examples: \"key\":\"OCSF Event Class\", \"value\":\"9001\" """
+    enable_statistics: NotRequired[bool]
+    r"""Statistics profile an entire file in terms of minimum/maximum values within data, numbers of nulls, etc. You can use Parquet tools to view statistics."""
+    enable_write_page_index: NotRequired[bool]
+    r"""One page index contains statistics for one data page. Parquet readers use statistics to enable page skipping."""
+    enable_page_checksum: NotRequired[bool]
+    r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
+    remove_empty_dirs: NotRequired[bool]
+    r"""Remove empty staging directories after moving files"""
+    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_enabled: NotRequired[bool]
+    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"""
+    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]
+    r"""The maximum number of times a file will attempt to move to its final destination before being dead-lettered"""
+    is_mapping_obj: NotRequired[bool]
+    r"""Send a JSON mapping object instead of specifying an existing named data mapping"""
+    mapping_obj: NotRequired[str]
+    r"""Enter a JSON object that defines your desired data mapping"""
+    mapping_ref: NotRequired[str]
+    r"""Enter the name of a data mapping associated with your target table. Or, if incoming event and target table fields match exactly, you can leave the field empty."""
     ingest_url: NotRequired[str]
     r"""The ingestion service URI for your cluster. Typically, `https://ingest-<cluster>.<region>.kusto.windows.net`."""
     on_backpressure: NotRequired[OutputAzureDataExplorerBackpressureBehavior]
     r"""How to handle events when all receivers are exerting backpressure"""
-    is_mapping_obj: NotRequired[bool]
-    r"""Send a JSON mapping object instead of specifying an existing named data mapping"""
-    format_: NotRequired[OutputAzureDataExplorerDataFormat]
-    r"""Format of the output data"""
     stage_path: NotRequired[str]
     r"""Filesystem location in which to buffer files before compressing and moving to final destination. Use performant and stable storage."""
     file_name_suffix: NotRequired[str]
@@ -273,10 +416,6 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
     add_id_to_stage_path: NotRequired[bool]
     r"""Add the Output ID value to staging location"""
-    remove_empty_dirs: NotRequired[bool]
-    r"""Remove empty staging directories after moving files"""
-    deadletter_enabled: NotRequired[bool]
-    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"""
     timeout_sec: NotRequired[float]
     r"""Amount of time, in seconds, to wait for a request to complete before canceling it"""
     flush_immediately: NotRequired[bool]
@@ -302,10 +441,6 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     ]
     response_honor_retry_after_header: NotRequired[bool]
     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."""
-    compress: NotRequired[OutputAzureDataExplorerCompressCompression]
-    r"""Data compression format to apply to HTTP content before it is delivered"""
-    mapping_ref: NotRequired[str]
-    r"""Enter the name of a data mapping associated with your target table. Or, if incoming event and target table fields match exactly, you can leave the field empty."""
     concurrency: NotRequired[float]
     r"""Maximum number of ongoing requests before blocking"""
     max_payload_size_kb: NotRequired[float]
@@ -323,6 +458,16 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     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."""
     keep_alive: NotRequired[bool]
     r"""Disable to close the connection immediately after sending the outgoing request"""
+    pq_strict_ordering: NotRequired[bool]
+    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
+    pq_rate_per_sec: NotRequired[float]
+    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
+    pq_mode: NotRequired[OutputAzureDataExplorerMode]
+    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_max_buffer_size: NotRequired[float]
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+    pq_max_backpressure_sec: NotRequired[float]
+    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -333,12 +478,12 @@ class OutputAzureDataExplorerTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputAzureDataExplorerQueueFullBehavior]
     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: NotRequired[OutputAzureDataExplorerMode]
-    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: NotRequired[OutputAzureDataExplorerPqControlsTypedDict]
 
 
 class OutputAzureDataExplorer(BaseModel):
+    type: OutputAzureDataExplorerType
+
     cluster_url: Annotated[str, pydantic.Field(alias="clusterUrl")]
     r"""The base URI for your cluster. Typically, `https://<cluster>.<region>.kusto.windows.net`."""
 
@@ -360,8 +505,6 @@ class OutputAzureDataExplorer(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Optional[OutputAzureDataExplorerType] = None
-
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
 
@@ -382,17 +525,24 @@ class OutputAzureDataExplorer(BaseModel):
     r"""When saving or starting the Destination, validate the database name and credentials; also validate table name, except when creating a new table. Disable if your Azure app does not have both the Database Viewer and the Table Viewer role."""
 
     ingest_mode: Annotated[
-        Optional[IngestionMode], pydantic.Field(alias="ingestMode")
+        Annotated[Optional[IngestionMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="ingestMode"),
     ] = IngestionMode.BATCHING
 
     oauth_endpoint: Annotated[
-        Optional[MicrosoftEntraIDAuthenticationEndpoint],
+        Annotated[
+            Optional[OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="oauthEndpoint"),
-    ] = MicrosoftEntraIDAuthenticationEndpoint.HTTPS_LOGIN_MICROSOFTONLINE_COM
+    ] = OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint.HTTPS_LOGIN_MICROSOFTONLINE_COM
     r"""Endpoint used to acquire authentication tokens from Azure"""
 
     oauth_type: Annotated[
-        Optional[OutputAzureDataExplorerAuthenticationMethod],
+        Annotated[
+            Optional[OutputAzureDataExplorerAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="oauthType"),
     ] = OutputAzureDataExplorerAuthenticationMethod.CLIENT_SECRET
     r"""The type of OAuth 2.0 client credentials grant flow to use"""
@@ -407,24 +557,144 @@ class OutputAzureDataExplorer(BaseModel):
 
     certificate: Optional[OutputAzureDataExplorerCertificate] = None
 
-    ingest_url: Annotated[Optional[str], pydantic.Field(alias="ingestUrl")] = None
-    r"""The ingestion service URI for your cluster. Typically, `https://ingest-<cluster>.<region>.kusto.windows.net`."""
+    format_: Annotated[
+        Annotated[
+            Optional[OutputAzureDataExplorerDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="format"),
+    ] = OutputAzureDataExplorerDataFormat.JSON
+    r"""Format of the output data"""
 
-    on_backpressure: Annotated[
-        Optional[OutputAzureDataExplorerBackpressureBehavior],
-        pydantic.Field(alias="onBackpressure"),
-    ] = OutputAzureDataExplorerBackpressureBehavior.BLOCK
-    r"""How to handle events when all receivers are exerting backpressure"""
+    compress: Annotated[
+        Optional[OutputAzureDataExplorerCompressCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = OutputAzureDataExplorerCompressCompression.GZIP
+    r"""Data compression format to apply to HTTP content before it is delivered"""
+
+    compression_level: Annotated[
+        Annotated[
+            Optional[OutputAzureDataExplorerCompressionLevel],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="compressionLevel"),
+    ] = OutputAzureDataExplorerCompressionLevel.BEST_SPEED
+    r"""Compression level to apply before moving files to final destination"""
+
+    automatic_schema: Annotated[
+        Optional[bool], pydantic.Field(alias="automaticSchema")
+    ] = 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[
+        Annotated[
+            Optional[OutputAzureDataExplorerParquetVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="parquetVersion"),
+    ] = OutputAzureDataExplorerParquetVersion.PARQUET_2_6
+    r"""Determines which data types are supported and how they are represented"""
+
+    parquet_data_page_version: Annotated[
+        Annotated[
+            Optional[OutputAzureDataExplorerDataPageVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="parquetDataPageVersion"),
+    ] = OutputAzureDataExplorerDataPageVersion.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."""
+
+    parquet_row_group_length: Annotated[
+        Optional[float], pydantic.Field(alias="parquetRowGroupLength")
+    ] = 10000
+    r"""The number of rows that every group will contain. The final group can contain a smaller number of rows."""
+
+    parquet_page_size: Annotated[
+        Optional[str], pydantic.Field(alias="parquetPageSize")
+    ] = "1MB"
+    r"""Target memory size for page segments, such as 1MB or 128MB. Generally, lower values improve reading speed, while higher values improve compression."""
+
+    should_log_invalid_rows: Annotated[
+        Optional[bool], pydantic.Field(alias="shouldLogInvalidRows")
+    ] = None
+    r"""Log up to 3 rows that @{product} skips due to data mismatch"""
+
+    key_value_metadata: Annotated[
+        Optional[List[OutputAzureDataExplorerKeyValueMetadatum]],
+        pydantic.Field(alias="keyValueMetadata"),
+    ] = None
+    r"""The metadata of files the Destination writes will include the properties you add here as key-value pairs. Useful for tagging. Examples: \"key\":\"OCSF Event Class\", \"value\":\"9001\" """
+
+    enable_statistics: Annotated[
+        Optional[bool], pydantic.Field(alias="enableStatistics")
+    ] = True
+    r"""Statistics profile an entire file in terms of minimum/maximum values within data, numbers of nulls, etc. You can use Parquet tools to view statistics."""
+
+    enable_write_page_index: Annotated[
+        Optional[bool], pydantic.Field(alias="enableWritePageIndex")
+    ] = True
+    r"""One page index contains statistics for one data page. Parquet readers use statistics to enable page skipping."""
+
+    enable_page_checksum: Annotated[
+        Optional[bool], pydantic.Field(alias="enablePageChecksum")
+    ] = False
+    r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
+
+    remove_empty_dirs: Annotated[
+        Optional[bool], pydantic.Field(alias="removeEmptyDirs")
+    ] = True
+    r"""Remove empty staging directories after moving files"""
+
+    empty_dir_cleanup_sec: Annotated[
+        Optional[float], pydantic.Field(alias="emptyDirCleanupSec")
+    ] = 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_enabled: Annotated[
+        Optional[bool], pydantic.Field(alias="deadletterEnabled")
+    ] = False
+    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"""
+
+    deadletter_path: Annotated[
+        Optional[str], pydantic.Field(alias="deadletterPath")
+    ] = "$CRIBL_HOME/state/outputs/dead-letter"
+    r"""Storage location for files that fail to reach their final destination after maximum retries are exceeded"""
+
+    max_retry_num: Annotated[Optional[float], pydantic.Field(alias="maxRetryNum")] = 20
+    r"""The maximum number of times a file will attempt to move to its final destination before being dead-lettered"""
 
     is_mapping_obj: Annotated[Optional[bool], pydantic.Field(alias="isMappingObj")] = (
         False
     )
     r"""Send a JSON mapping object instead of specifying an existing named data mapping"""
 
-    format_: Annotated[
-        Optional[OutputAzureDataExplorerDataFormat], pydantic.Field(alias="format")
-    ] = OutputAzureDataExplorerDataFormat.JSON
-    r"""Format of the output data"""
+    mapping_obj: Annotated[Optional[str], pydantic.Field(alias="mappingObj")] = None
+    r"""Enter a JSON object that defines your desired data mapping"""
+
+    mapping_ref: Annotated[Optional[str], pydantic.Field(alias="mappingRef")] = None
+    r"""Enter the name of a data mapping associated with your target table. Or, if incoming event and target table fields match exactly, you can leave the field empty."""
+
+    ingest_url: Annotated[Optional[str], pydantic.Field(alias="ingestUrl")] = None
+    r"""The ingestion service URI for your cluster. Typically, `https://ingest-<cluster>.<region>.kusto.windows.net`."""
+
+    on_backpressure: Annotated[
+        Annotated[
+            Optional[OutputAzureDataExplorerBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="onBackpressure"),
+    ] = OutputAzureDataExplorerBackpressureBehavior.BLOCK
+    r"""How to handle events when all receivers are exerting backpressure"""
 
     stage_path: Annotated[Optional[str], pydantic.Field(alias="stagePath")] = (
         "$CRIBL_HOME/state/outputs/staging"
@@ -462,7 +732,10 @@ class OutputAzureDataExplorer(BaseModel):
     r"""Maximum number of parts to upload in parallel per file"""
 
     on_disk_full_backpressure: Annotated[
-        Optional[OutputAzureDataExplorerDiskSpaceProtection],
+        Annotated[
+            Optional[OutputAzureDataExplorerDiskSpaceProtection],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputAzureDataExplorerDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
@@ -472,16 +745,6 @@ class OutputAzureDataExplorer(BaseModel):
     ] = True
     r"""Add the Output ID value to staging location"""
 
-    remove_empty_dirs: Annotated[
-        Optional[bool], pydantic.Field(alias="removeEmptyDirs")
-    ] = True
-    r"""Remove empty staging directories after moving files"""
-
-    deadletter_enabled: Annotated[
-        Optional[bool], pydantic.Field(alias="deadletterEnabled")
-    ] = False
-    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"""
-
     timeout_sec: Annotated[Optional[float], pydantic.Field(alias="timeoutSec")] = 30
     r"""Amount of time, in seconds, to wait for a request to complete before canceling it"""
 
@@ -506,12 +769,14 @@ class OutputAzureDataExplorer(BaseModel):
     r"""Prevents duplicate ingestion by verifying whether an extent with the specified ingest-by tag already exists"""
 
     report_level: Annotated[
-        Optional[ReportLevel], pydantic.Field(alias="reportLevel")
+        Annotated[Optional[ReportLevel], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="reportLevel"),
     ] = ReportLevel.FAILURES_ONLY
     r"""Level of ingestion status reporting. Defaults to FailuresOnly."""
 
     report_method: Annotated[
-        Optional[ReportMethod], pydantic.Field(alias="reportMethod")
+        Annotated[Optional[ReportMethod], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="reportMethod"),
     ] = ReportMethod.QUEUE
     r"""Target of the ingestion status reporting. Defaults to Queue."""
 
@@ -533,17 +798,9 @@ class OutputAzureDataExplorer(BaseModel):
 
     response_honor_retry_after_header: Annotated[
         Optional[bool], pydantic.Field(alias="responseHonorRetryAfterHeader")
-    ] = False
+    ] = True
     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."""
 
-    compress: Optional[OutputAzureDataExplorerCompressCompression] = (
-        OutputAzureDataExplorerCompressCompression.GZIP
-    )
-    r"""Data compression format to apply to HTTP content before it is delivered"""
-
-    mapping_ref: Annotated[Optional[str], pydantic.Field(alias="mappingRef")] = None
-    r"""Enter the name of a data mapping associated with your target table. Or, if incoming event and target table fields match exactly, you can leave the field empty."""
-
     concurrency: Optional[float] = 5
     r"""Maximum number of ongoing requests before blocking"""
 
@@ -578,6 +835,35 @@ class OutputAzureDataExplorer(BaseModel):
     keep_alive: Annotated[Optional[bool], pydantic.Field(alias="keepAlive")] = True
     r"""Disable to close the connection immediately after sending the outgoing request"""
 
+    pq_strict_ordering: Annotated[
+        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
+    ] = True
+    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
+
+    pq_rate_per_sec: Annotated[
+        Optional[float], pydantic.Field(alias="pqRatePerSec")
+    ] = 0
+    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
+
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputAzureDataExplorerMode],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputAzureDataExplorerMode.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_max_buffer_size: Annotated[
+        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
+    ] = 42
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+
+    pq_max_backpressure_sec: Annotated[
+        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
+    ] = 30
+    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
+
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -592,22 +878,160 @@ class OutputAzureDataExplorer(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[OutputAzureDataExplorerPqCompressCompression],
+        Annotated[
+            Optional[OutputAzureDataExplorerPqCompressCompression],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqCompress"),
     ] = OutputAzureDataExplorerPqCompressCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputAzureDataExplorerQueueFullBehavior],
+        Annotated[
+            Optional[OutputAzureDataExplorerQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputAzureDataExplorerQueueFullBehavior.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[OutputAzureDataExplorerMode], pydantic.Field(alias="pqMode")
-    ] = OutputAzureDataExplorerMode.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[
         Optional[OutputAzureDataExplorerPqControls], pydantic.Field(alias="pqControls")
     ] = None
+
+    @field_serializer("ingest_mode")
+    def serialize_ingest_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.IngestionMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("oauth_endpoint")
+    def serialize_oauth_endpoint(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint(
+                    value
+                )
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("oauth_type")
+    def serialize_oauth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("format_")
+    def serialize_format_(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerDataFormat(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerCompressCompression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compression_level")
+    def serialize_compression_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerCompressionLevel(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_version")
+    def serialize_parquet_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerParquetVersion(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.OutputAzureDataExplorerDataPageVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_backpressure")
+    def serialize_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerBackpressureBehavior(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.OutputAzureDataExplorerDiskSpaceProtection(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("report_level")
+    def serialize_report_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportLevel(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("report_method")
+    def serialize_report_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.ReportMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_mode")
+    def serialize_pq_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerMode(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_compress")
+    def serialize_pq_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerPqCompressCompression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("pq_on_backpressure")
+    def serialize_pq_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureDataExplorerQueueFullBehavior(value)
+            except ValueError:
+                return value
+        return value