cribl-control-plane 0.2.1rc6__py3-none-any.whl → 0.2.1rc8__py3-none-any.whl

cribl_control_plane/models/outputazuredataexplorer.py

@@ -22,7 +22,9 @@ class IngestionMode(str, Enum, metaclass=utils.OpenEnumMeta):
     STREAMING = "streaming"
 
 
-class MicrosoftEntraIDAuthenticationEndpoint(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputAzureDataExplorerMicrosoftEntraIDAuthenticationEndpoint(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     r"""Endpoint used to acquire authentication tokens from Azure"""
 
     HTTPS_LOGIN_MICROSOFTONLINE_COM = "https://login.microsoftonline.com"
@@ -55,6 +57,68 @@ class OutputAzureDataExplorerCertificate(BaseModel):
     r"""The certificate you registered as credentials for your app in the Azure portal"""
 
 
+class OutputAzureDataExplorerDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Format of the output data"""
+
+    # JSON
+    JSON = "json"
+    # Raw
+    RAW = "raw"
+    # Parquet
+    PARQUET = "parquet"
+
+
+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
 ):
@@ -68,17 +132,6 @@ class OutputAzureDataExplorerBackpressureBehavior(
     QUEUE = "queue"
 
 
-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, metaclass=utils.OpenEnumMeta
 ):
@@ -205,13 +258,15 @@ 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, metaclass=utils.OpenEnumMeta
-):
-    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(
@@ -234,17 +289,6 @@ class OutputAzureDataExplorerQueueFullBehavior(str, Enum, metaclass=utils.OpenEn
     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 = "error"
-    # Backpressure
-    BACKPRESSURE = "backpressure"
-    # Always On
-    ALWAYS = "always"
-
-
 class OutputAzureDataExplorerPqControlsTypedDict(TypedDict):
     pass
 
@@ -280,7 +324,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"""
@@ -290,14 +336,56 @@ 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"""
+    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]
@@ -316,10 +404,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]
@@ -345,10 +429,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]
@@ -366,6 +446,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]
@@ -376,11 +466,7 @@ 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]
-    empty_dir_cleanup_sec: NotRequired[float]
-    r"""How frequently, in seconds, to clean up empty directories"""
 
 
 class OutputAzureDataExplorer(BaseModel):
@@ -433,11 +519,11 @@ class OutputAzureDataExplorer(BaseModel):
 
     oauth_endpoint: Annotated[
         Annotated[
-            Optional[MicrosoftEntraIDAuthenticationEndpoint],
+            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[
@@ -459,31 +545,139 @@ 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[
+    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[OutputAzureDataExplorerBackpressureBehavior],
+            Optional[OutputAzureDataExplorerCompressionLevel],
             PlainValidator(validate_open_enum(False)),
         ],
-        pydantic.Field(alias="onBackpressure"),
-    ] = OutputAzureDataExplorerBackpressureBehavior.BLOCK
-    r"""How to handle events when all receivers are exerting backpressure"""
+        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"""
+
+    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[
+    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[OutputAzureDataExplorerDataFormat],
+            Optional[OutputAzureDataExplorerBackpressureBehavior],
             PlainValidator(validate_open_enum(False)),
         ],
-        pydantic.Field(alias="format"),
-    ] = OutputAzureDataExplorerDataFormat.JSON
-    r"""Format of the output data"""
+        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"
@@ -534,16 +728,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"""
 
@@ -600,15 +784,6 @@ class OutputAzureDataExplorer(BaseModel):
     ] = 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: 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"""
 
@@ -643,6 +818,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"
@@ -674,20 +878,6 @@ class OutputAzureDataExplorer(BaseModel):
     ] = 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
-
-    empty_dir_cleanup_sec: Annotated[
-        Optional[float], pydantic.Field(alias="emptyDirCleanupSec")
-    ] = 300
-    r"""How frequently, in seconds, to clean up empty directories"""