cribl-control-plane 0.0.13__py3-none-any.whl

cribl_control_plane/models/outputazuredataexplorer.py

@@ -0,0 +1,660 @@
+"""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 OutputAzureDataExplorerType(str, Enum, metaclass=utils.OpenEnumMeta):
+    AZURE_DATA_EXPLORER = "azure_data_explorer"
+
+
+class IngestionMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    BATCHING = "batching"
+    STREAMING = "streaming"
+
+
+class MicrosoftEntraIDAuthenticationEndpoint(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Endpoint used to acquire authentication tokens from Azure"""
+
+    HTTPS_LOGIN_MICROSOFTONLINE_COM = "https://login.microsoftonline.com"
+    HTTPS_LOGIN_MICROSOFTONLINE_US = "https://login.microsoftonline.us"
+    HTTPS_LOGIN_PARTNER_MICROSOFTONLINE_CN = "https://login.partner.microsoftonline.cn"
+
+
+class OutputAzureDataExplorerAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""The type of OAuth 2.0 client credentials grant flow to use"""
+
+    CLIENT_SECRET = "clientSecret"
+    CLIENT_TEXT_SECRET = "clientTextSecret"
+    CERTIFICATE = "certificate"
+
+
+class OutputAzureDataExplorerCertificateTypedDict(TypedDict):
+    certificate_name: NotRequired[str]
+    r"""The certificate you registered as credentials for your app in the Azure portal"""
+
+
+class OutputAzureDataExplorerCertificate(BaseModel):
+    certificate_name: Annotated[
+        Optional[str], pydantic.Field(alias="certificateName")
+    ] = None
+    r"""The certificate you registered as credentials for your app in the Azure portal"""
+
+
+class OutputAzureDataExplorerBackpressureBehavior(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""How to handle events when all receivers are exerting backpressure"""
+
+    BLOCK = "block"
+    DROP = "drop"
+    QUEUE = "queue"
+
+
+class OutputAzureDataExplorerDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Format of the output data"""
+
+    JSON = "json"
+    RAW = "raw"
+    PARQUET = "parquet"
+
+
+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"
+    DROP = "drop"
+
+
+class PrefixOptional(str, Enum, metaclass=utils.OpenEnumMeta):
+    DROP_BY = "dropBy"
+    INGEST_BY = "ingestBy"
+
+
+class ExtentTagTypedDict(TypedDict):
+    value: str
+    prefix: NotRequired[PrefixOptional]
+
+
+class ExtentTag(BaseModel):
+    value: str
+
+    prefix: Annotated[
+        Optional[PrefixOptional], PlainValidator(validate_open_enum(False))
+    ] = None
+
+
+class IngestIfNotExistTypedDict(TypedDict):
+    value: str
+
+
+class IngestIfNotExist(BaseModel):
+    value: str
+
+
+class ReportLevel(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Level of ingestion status reporting. Defaults to FailuresOnly."""
+
+    FAILURES_ONLY = "failuresOnly"
+    DO_NOT_REPORT = "doNotReport"
+    FAILURES_AND_SUCCESSES = "failuresAndSuccesses"
+
+
+class ReportMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Target of the ingestion status reporting. Defaults to Queue."""
+
+    QUEUE = "queue"
+    TABLE = "table"
+    QUEUE_AND_TABLE = "queueAndTable"
+
+
+class AdditionalPropertyTypedDict(TypedDict):
+    key: str
+    value: str
+
+
+class AdditionalProperty(BaseModel):
+    key: str
+
+    value: str
+
+
+class OutputAzureDataExplorerResponseRetrySettingTypedDict(TypedDict):
+    http_status: float
+    r"""The HTTP response status code that will trigger retries"""
+    initial_backoff: NotRequired[float]
+    r"""How long, in milliseconds, Cribl Stream should wait before initiating backoff. Maximum interval is 600,000 ms (10 minutes)."""
+    backoff_rate: NotRequired[float]
+    r"""Base for exponential backoff. A value of 2 (default) means Cribl Stream will retry after 2 seconds, then 4 seconds, then 8 seconds, etc."""
+    max_backoff: NotRequired[float]
+    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 OutputAzureDataExplorerResponseRetrySetting(BaseModel):
+    http_status: Annotated[float, pydantic.Field(alias="httpStatus")]
+    r"""The HTTP response status code that will trigger retries"""
+
+    initial_backoff: Annotated[
+        Optional[float], pydantic.Field(alias="initialBackoff")
+    ] = 1000
+    r"""How long, in milliseconds, Cribl Stream should wait before initiating backoff. Maximum interval is 600,000 ms (10 minutes)."""
+
+    backoff_rate: Annotated[Optional[float], pydantic.Field(alias="backoffRate")] = 2
+    r"""Base for exponential backoff. A value of 2 (default) means Cribl Stream will retry after 2 seconds, then 4 seconds, then 8 seconds, etc."""
+
+    max_backoff: Annotated[Optional[float], pydantic.Field(alias="maxBackoff")] = 10000
+    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 OutputAzureDataExplorerTimeoutRetrySettingsTypedDict(TypedDict):
+    timeout_retry: NotRequired[bool]
+    initial_backoff: NotRequired[float]
+    r"""How long, in milliseconds, Cribl Stream should wait before initiating backoff. Maximum interval is 600,000 ms (10 minutes)."""
+    backoff_rate: NotRequired[float]
+    r"""Base for exponential backoff. A value of 2 (default) means Cribl Stream will retry after 2 seconds, then 4 seconds, then 8 seconds, etc."""
+    max_backoff: NotRequired[float]
+    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 OutputAzureDataExplorerTimeoutRetrySettings(BaseModel):
+    timeout_retry: Annotated[Optional[bool], pydantic.Field(alias="timeoutRetry")] = (
+        False
+    )
+
+    initial_backoff: Annotated[
+        Optional[float], pydantic.Field(alias="initialBackoff")
+    ] = 1000
+    r"""How long, in milliseconds, Cribl Stream should wait before initiating backoff. Maximum interval is 600,000 ms (10 minutes)."""
+
+    backoff_rate: Annotated[Optional[float], pydantic.Field(alias="backoffRate")] = 2
+    r"""Base for exponential backoff. A value of 2 (default) means Cribl Stream will retry after 2 seconds, then 4 seconds, then 8 seconds, etc."""
+
+    max_backoff: Annotated[Optional[float], pydantic.Field(alias="maxBackoff")] = 10000
+    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, metaclass=utils.OpenEnumMeta
+):
+    r"""Data compression format to apply to HTTP content before it is delivered"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+class OutputAzureDataExplorerPqCompressCompression(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Codec to use to compress the persisted data"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+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"
+    DROP = "drop"
+
+
+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."""
+
+    ERROR = "error"
+    BACKPRESSURE = "backpressure"
+    ALWAYS = "always"
+
+
+class OutputAzureDataExplorerPqControlsTypedDict(TypedDict):
+    pass
+
+
+class OutputAzureDataExplorerPqControls(BaseModel):
+    pass
+
+
+class OutputAzureDataExplorerTypedDict(TypedDict):
+    cluster_url: str
+    r"""The base URI for your cluster. Typically, `https://<cluster>.<region>.kusto.windows.net`."""
+    database: str
+    r"""Name of the database containing the table where data will be ingested"""
+    table: str
+    r"""Name of the table to ingest data into"""
+    tenant_id: str
+    r"""Directory ID (tenant identifier) in Azure Active Directory"""
+    client_id: str
+    r"""client_id to pass in the OAuth request parameter"""
+    scope: str
+    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]]
+    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
+    environment: NotRequired[str]
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+    streamtags: NotRequired[List[str]]
+    r"""Tags for filtering and grouping in @{product}"""
+    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]
+    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"""
+    description: NotRequired[str]
+    client_secret: NotRequired[str]
+    r"""The client secret that you generated for your app in the Azure portal"""
+    text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+    certificate: NotRequired[OutputAzureDataExplorerCertificateTypedDict]
+    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]
+    r"""JavaScript expression to define the output filename suffix (can be constant).  The `__format` variable refers to the value of the `Data format` field (`json` or `raw`).  The `__compression` field refers to the kind of compression being used (`none` or `gzip`)."""
+    max_file_size_mb: NotRequired[float]
+    r"""Maximum uncompressed output file size. Files of this size will be closed and moved to final output location."""
+    max_file_open_time_sec: NotRequired[float]
+    r"""Maximum amount of time to write to a file. Files open for longer than this will be closed and moved to final output location."""
+    max_file_idle_time_sec: NotRequired[float]
+    r"""Maximum amount of time to keep inactive files open. Files open for longer than this will be closed and moved to final output location."""
+    max_open_files: NotRequired[float]
+    r"""Maximum number of files to keep open concurrently. When exceeded, @{product} will close the oldest open files and move them to the final output location."""
+    max_concurrent_file_parts: NotRequired[float]
+    r"""Maximum number of parts to upload in parallel per file"""
+    on_disk_full_backpressure: NotRequired[OutputAzureDataExplorerDiskSpaceProtection]
+    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]
+    r"""Bypass the data management service's aggregation mechanism"""
+    retain_blob_on_success: NotRequired[bool]
+    r"""Prevent blob deletion after ingestion is complete"""
+    extent_tags: NotRequired[List[ExtentTagTypedDict]]
+    r"""Strings or tags associated with the extent (ingested data shard)"""
+    ingest_if_not_exists: NotRequired[List[IngestIfNotExistTypedDict]]
+    r"""Prevents duplicate ingestion by verifying whether an extent with the specified ingest-by tag already exists"""
+    report_level: NotRequired[ReportLevel]
+    r"""Level of ingestion status reporting. Defaults to FailuresOnly."""
+    report_method: NotRequired[ReportMethod]
+    r"""Target of the ingestion status reporting. Defaults to Queue."""
+    additional_properties: NotRequired[List[AdditionalPropertyTypedDict]]
+    r"""Optionally, enter additional configuration properties to send to the ingestion service"""
+    response_retry_settings: NotRequired[
+        List[OutputAzureDataExplorerResponseRetrySettingTypedDict]
+    ]
+    r"""Automatically retry after unsuccessful response status codes, such as 429 (Too Many Requests) or 503 (Service Unavailable)"""
+    timeout_retry_settings: NotRequired[
+        OutputAzureDataExplorerTimeoutRetrySettingsTypedDict
+    ]
+    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]
+    r"""Maximum size, in KB, of the request body"""
+    max_payload_events: NotRequired[float]
+    r"""Maximum number of events to include in the request body. Default is 0 (unlimited)."""
+    flush_period_sec: NotRequired[float]
+    r"""Maximum time between requests. Small values could cause the payload size to be smaller than the configured Body size limit."""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's).
+    Enabled by default. When this setting is also present in TLS Settings (Client Side),
+    that value will take precedence.
+    """
+    use_round_robin_dns: NotRequired[bool]
+    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_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]
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+    pq_path: NotRequired[str]
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
+    pq_compress: NotRequired[OutputAzureDataExplorerPqCompressCompression]
+    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):
+    cluster_url: Annotated[str, pydantic.Field(alias="clusterUrl")]
+    r"""The base URI for your cluster. Typically, `https://<cluster>.<region>.kusto.windows.net`."""
+
+    database: str
+    r"""Name of the database containing the table where data will be ingested"""
+
+    table: str
+    r"""Name of the table to ingest data into"""
+
+    tenant_id: Annotated[str, pydantic.Field(alias="tenantId")]
+    r"""Directory ID (tenant identifier) in Azure Active Directory"""
+
+    client_id: Annotated[str, pydantic.Field(alias="clientId")]
+    r"""client_id to pass in the OAuth request parameter"""
+
+    scope: str
+    r"""Scope to pass in the OAuth request parameter"""
+
+    id: Optional[str] = None
+    r"""Unique ID for this output"""
+
+    type: Annotated[
+        Optional[OutputAzureDataExplorerType], PlainValidator(validate_open_enum(False))
+    ] = None
+
+    pipeline: Optional[str] = None
+    r"""Pipeline to process data before sending out to this output"""
+
+    system_fields: Annotated[
+        Optional[List[str]], pydantic.Field(alias="systemFields")
+    ] = None
+    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
+
+    environment: Optional[str] = None
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+
+    streamtags: Optional[List[str]] = None
+    r"""Tags for filtering and grouping in @{product}"""
+
+    validate_database_settings: Annotated[
+        Optional[bool], pydantic.Field(alias="validateDatabaseSettings")
+    ] = True
+    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[
+        Annotated[Optional[IngestionMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="ingestMode"),
+    ] = IngestionMode.BATCHING
+
+    oauth_endpoint: Annotated[
+        Annotated[
+            Optional[MicrosoftEntraIDAuthenticationEndpoint],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="oauthEndpoint"),
+    ] = MicrosoftEntraIDAuthenticationEndpoint.HTTPS_LOGIN_MICROSOFTONLINE_COM
+    r"""Endpoint used to acquire authentication tokens from Azure"""
+
+    oauth_type: Annotated[
+        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"""
+
+    description: Optional[str] = None
+
+    client_secret: Annotated[Optional[str], pydantic.Field(alias="clientSecret")] = None
+    r"""The client secret that you generated for your app in the Azure portal"""
+
+    text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
+    r"""Select or create a stored text secret"""
+
+    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`."""
+
+    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"""
+
+    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[
+        Annotated[
+            Optional[OutputAzureDataExplorerDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="format"),
+    ] = OutputAzureDataExplorerDataFormat.JSON
+    r"""Format of the output data"""
+
+    stage_path: Annotated[Optional[str], pydantic.Field(alias="stagePath")] = (
+        "$CRIBL_HOME/state/outputs/staging"
+    )
+    r"""Filesystem location in which to buffer files before compressing and moving to final destination. Use performant and stable storage."""
+
+    file_name_suffix: Annotated[
+        Optional[str], pydantic.Field(alias="fileNameSuffix")
+    ] = '`.${C.env["CRIBL_WORKER_ID"]}.${__format}${__compression === "gzip" ? ".gz" : ""}`'
+    r"""JavaScript expression to define the output filename suffix (can be constant).  The `__format` variable refers to the value of the `Data format` field (`json` or `raw`).  The `__compression` field refers to the kind of compression being used (`none` or `gzip`)."""
+
+    max_file_size_mb: Annotated[
+        Optional[float], pydantic.Field(alias="maxFileSizeMB")
+    ] = 32
+    r"""Maximum uncompressed output file size. Files of this size will be closed and moved to final output location."""
+
+    max_file_open_time_sec: Annotated[
+        Optional[float], pydantic.Field(alias="maxFileOpenTimeSec")
+    ] = 300
+    r"""Maximum amount of time to write to a file. Files open for longer than this will be closed and moved to final output location."""
+
+    max_file_idle_time_sec: Annotated[
+        Optional[float], pydantic.Field(alias="maxFileIdleTimeSec")
+    ] = 30
+    r"""Maximum amount of time to keep inactive files open. Files open for longer than this will be closed and moved to final output location."""
+
+    max_open_files: Annotated[Optional[float], pydantic.Field(alias="maxOpenFiles")] = (
+        100
+    )
+    r"""Maximum number of files to keep open concurrently. When exceeded, @{product} will close the oldest open files and move them to the final output location."""
+
+    max_concurrent_file_parts: Annotated[
+        Optional[float], pydantic.Field(alias="maxConcurrentFileParts")
+    ] = 1
+    r"""Maximum number of parts to upload in parallel per file"""
+
+    on_disk_full_backpressure: Annotated[
+        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"""
+
+    add_id_to_stage_path: Annotated[
+        Optional[bool], pydantic.Field(alias="addIdToStagePath")
+    ] = 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"""
+
+    flush_immediately: Annotated[
+        Optional[bool], pydantic.Field(alias="flushImmediately")
+    ] = False
+    r"""Bypass the data management service's aggregation mechanism"""
+
+    retain_blob_on_success: Annotated[
+        Optional[bool], pydantic.Field(alias="retainBlobOnSuccess")
+    ] = False
+    r"""Prevent blob deletion after ingestion is complete"""
+
+    extent_tags: Annotated[
+        Optional[List[ExtentTag]], pydantic.Field(alias="extentTags")
+    ] = None
+    r"""Strings or tags associated with the extent (ingested data shard)"""
+
+    ingest_if_not_exists: Annotated[
+        Optional[List[IngestIfNotExist]], pydantic.Field(alias="ingestIfNotExists")
+    ] = None
+    r"""Prevents duplicate ingestion by verifying whether an extent with the specified ingest-by tag already exists"""
+
+    report_level: Annotated[
+        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[
+        Annotated[Optional[ReportMethod], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="reportMethod"),
+    ] = ReportMethod.QUEUE
+    r"""Target of the ingestion status reporting. Defaults to Queue."""
+
+    additional_properties: Annotated[
+        Optional[List[AdditionalProperty]], pydantic.Field(alias="additionalProperties")
+    ] = None
+    r"""Optionally, enter additional configuration properties to send to the ingestion service"""
+
+    response_retry_settings: Annotated[
+        Optional[List[OutputAzureDataExplorerResponseRetrySetting]],
+        pydantic.Field(alias="responseRetrySettings"),
+    ] = None
+    r"""Automatically retry after unsuccessful response status codes, such as 429 (Too Many Requests) or 503 (Service Unavailable)"""
+
+    timeout_retry_settings: Annotated[
+        Optional[OutputAzureDataExplorerTimeoutRetrySettings],
+        pydantic.Field(alias="timeoutRetrySettings"),
+    ] = None
+
+    response_honor_retry_after_header: Annotated[
+        Optional[bool], pydantic.Field(alias="responseHonorRetryAfterHeader")
+    ] = False
+    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: Annotated[
+        Optional[OutputAzureDataExplorerCompressCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = 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"""
+
+    max_payload_size_kb: Annotated[
+        Optional[float], pydantic.Field(alias="maxPayloadSizeKB")
+    ] = 4096
+    r"""Maximum size, in KB, of the request body"""
+
+    max_payload_events: Annotated[
+        Optional[float], pydantic.Field(alias="maxPayloadEvents")
+    ] = 0
+    r"""Maximum number of events to include in the request body. Default is 0 (unlimited)."""
+
+    flush_period_sec: Annotated[
+        Optional[float], pydantic.Field(alias="flushPeriodSec")
+    ] = 1
+    r"""Maximum time between requests. Small values could cause the payload size to be smaller than the configured Body size limit."""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's).
+    Enabled by default. When this setting is also present in TLS Settings (Client Side),
+    that value will take precedence.
+    """
+
+    use_round_robin_dns: Annotated[
+        Optional[bool], pydantic.Field(alias="useRoundRobinDns")
+    ] = False
+    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: Annotated[Optional[bool], pydantic.Field(alias="keepAlive")] = True
+    r"""Disable to close the connection immediately after sending the outgoing request"""
+
+    pq_max_file_size: Annotated[
+        Optional[str], pydantic.Field(alias="pqMaxFileSize")
+    ] = "1 MB"
+    r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
+
+    pq_max_size: Annotated[Optional[str], pydantic.Field(alias="pqMaxSize")] = "5GB"
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+
+    pq_path: Annotated[Optional[str], pydantic.Field(alias="pqPath")] = (
+        "$CRIBL_HOME/state/queues"
+    )
+    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[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[
+        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[
+        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_controls: Annotated[
+        Optional[OutputAzureDataExplorerPqControls], pydantic.Field(alias="pqControls")
+    ] = None