cribl-control-plane 0.0.42__py3-none-any.whl → 0.0.43__py3-none-any.whl

cribl_control_plane/models/input.py

@@ -119,8 +119,8 @@ InputTypedDict = TypeAliasType(
         InputElasticTypedDict,
         InputOffice365MsgTraceTypedDict,
         InputSplunkHecTypedDict,
-        InputPrometheusRwTypedDict,
         InputLokiTypedDict,
+        InputPrometheusRwTypedDict,
         InputPrometheusTypedDict,
         InputCrowdstrikeTypedDict,
         InputEdgePrometheusTypedDict,
@@ -185,8 +185,8 @@ Input = TypeAliasType(
         InputElastic,
         InputOffice365MsgTrace,
         InputSplunkHec,
-        InputPrometheusRw,
         InputLoki,
+        InputPrometheusRw,
         InputPrometheus,
         InputCrowdstrike,
         InputEdgePrometheus,

cribl_control_plane/models/inputappscope.py

@@ -37,6 +37,14 @@ class InputAppscopeCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputAppscopePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputAppscopePqControls(BaseModel):
+    pass
+
+
 class InputAppscopePqTypedDict(TypedDict):
     mode: NotRequired[InputAppscopeMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputAppscopePqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputAppscopeCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputAppscopePqControlsTypedDict]
 
 
 class InputAppscopePq(BaseModel):
@@ -82,6 +91,10 @@ class InputAppscopePq(BaseModel):
     compress: Optional[InputAppscopeCompression] = InputAppscopeCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputAppscopePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputAppscopeMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputazureblob.py

@@ -37,6 +37,14 @@ class InputAzureBlobCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputAzureBlobPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputAzureBlobPqControls(BaseModel):
+    pass
+
+
 class InputAzureBlobPqTypedDict(TypedDict):
     mode: NotRequired[InputAzureBlobMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputAzureBlobPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputAzureBlobCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputAzureBlobPqControlsTypedDict]
 
 
 class InputAzureBlobPq(BaseModel):
@@ -82,6 +91,10 @@ class InputAzureBlobPq(BaseModel):
     compress: Optional[InputAzureBlobCompression] = InputAzureBlobCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputAzureBlobPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputAzureBlobMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputcollection.py

@@ -37,6 +37,14 @@ class InputCollectionCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCollectionPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCollectionPqControls(BaseModel):
+    pass
+
+
 class InputCollectionPqTypedDict(TypedDict):
     mode: NotRequired[InputCollectionMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCollectionPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCollectionCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCollectionPqControlsTypedDict]
 
 
 class InputCollectionPq(BaseModel):
@@ -82,6 +91,10 @@ class InputCollectionPq(BaseModel):
     compress: Optional[InputCollectionCompression] = InputCollectionCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCollectionPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCollectionPreprocessTypedDict(TypedDict):
     disabled: NotRequired[bool]

cribl_control_plane/models/inputconfluentcloud.py

@@ -37,6 +37,14 @@ class InputConfluentCloudCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputConfluentCloudPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputConfluentCloudPqControls(BaseModel):
+    pass
+
+
 class InputConfluentCloudPqTypedDict(TypedDict):
     mode: NotRequired[InputConfluentCloudMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputConfluentCloudPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputConfluentCloudCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputConfluentCloudPqControlsTypedDict]
 
 
 class InputConfluentCloudPq(BaseModel):
@@ -84,6 +93,10 @@ class InputConfluentCloudPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputConfluentCloudPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputConfluentCloudMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputcribl.py

@@ -37,6 +37,14 @@ class InputCriblCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCriblPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblPqControls(BaseModel):
+    pass
+
+
 class InputCriblPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCriblPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblPqControlsTypedDict]
 
 
 class InputCriblPq(BaseModel):
@@ -82,6 +91,10 @@ class InputCriblPq(BaseModel):
     compress: Optional[InputCriblCompression] = InputCriblCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCriblMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputcriblhttp.py

@@ -37,6 +37,14 @@ class InputCriblHTTPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCriblHTTPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblHTTPPqControls(BaseModel):
+    pass
+
+
 class InputCriblHTTPPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblHTTPMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCriblHTTPPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblHTTPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblHTTPPqControlsTypedDict]
 
 
 class InputCriblHTTPPq(BaseModel):
@@ -82,6 +91,10 @@ class InputCriblHTTPPq(BaseModel):
     compress: Optional[InputCriblHTTPCompression] = InputCriblHTTPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblHTTPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCriblHTTPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputcribllakehttp.py

@@ -37,6 +37,14 @@ class InputCriblLakeHTTPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCriblLakeHTTPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblLakeHTTPPqControls(BaseModel):
+    pass
+
+
 class InputCriblLakeHTTPPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblLakeHTTPMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCriblLakeHTTPPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblLakeHTTPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblLakeHTTPPqControlsTypedDict]
 
 
 class InputCriblLakeHTTPPq(BaseModel):
@@ -84,6 +93,10 @@ class InputCriblLakeHTTPPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblLakeHTTPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCriblLakeHTTPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
@@ -187,12 +200,29 @@ class InputCriblLakeHTTPAuthTokensExtMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
+class SplunkHecMetadataTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+
+
+class SplunkHecMetadata(BaseModel):
+    enabled: Optional[bool] = None
+
+
+class ElasticsearchMetadataTypedDict(TypedDict):
+    enabled: NotRequired[bool]
+
+
+class ElasticsearchMetadata(BaseModel):
+    enabled: Optional[bool] = None
+
+
 class InputCriblLakeHTTPAuthTokensExtTypedDict(TypedDict):
     token: str
     description: NotRequired[str]
     metadata: NotRequired[List[InputCriblLakeHTTPAuthTokensExtMetadatumTypedDict]]
     r"""Fields to add to events referencing this token"""
-    enable_splunk_hec: NotRequired[bool]
+    splunk_hec_metadata: NotRequired[SplunkHecMetadataTypedDict]
+    elasticsearch_metadata: NotRequired[ElasticsearchMetadataTypedDict]
 
 
 class InputCriblLakeHTTPAuthTokensExt(BaseModel):
@@ -203,9 +233,13 @@ class InputCriblLakeHTTPAuthTokensExt(BaseModel):
     metadata: Optional[List[InputCriblLakeHTTPAuthTokensExtMetadatum]] = None
     r"""Fields to add to events referencing this token"""
 
-    enable_splunk_hec: Annotated[
-        Optional[bool], pydantic.Field(alias="enableSplunkHec")
-    ] = False
+    splunk_hec_metadata: Annotated[
+        Optional[SplunkHecMetadata], pydantic.Field(alias="splunkHecMetadata")
+    ] = None
+
+    elasticsearch_metadata: Annotated[
+        Optional[ElasticsearchMetadata], pydantic.Field(alias="elasticsearchMetadata")
+    ] = None
 
 
 class InputCriblLakeHTTPTypedDict(TypedDict):

cribl_control_plane/models/inputcriblmetrics.py

@@ -37,6 +37,14 @@ class InputCriblmetricsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCriblmetricsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblmetricsPqControls(BaseModel):
+    pass
+
+
 class InputCriblmetricsPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblmetricsMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCriblmetricsPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblmetricsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblmetricsPqControlsTypedDict]
 
 
 class InputCriblmetricsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputCriblmetricsPq(BaseModel):
     compress: Optional[InputCriblmetricsCompression] = InputCriblmetricsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblmetricsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCriblmetricsMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputcribltcp.py

@@ -37,6 +37,14 @@ class InputCriblTCPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCriblTCPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCriblTCPPqControls(BaseModel):
+    pass
+
+
 class InputCriblTCPPqTypedDict(TypedDict):
     mode: NotRequired[InputCriblTCPMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCriblTCPPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCriblTCPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCriblTCPPqControlsTypedDict]
 
 
 class InputCriblTCPPq(BaseModel):
@@ -82,6 +91,10 @@ class InputCriblTCPPq(BaseModel):
     compress: Optional[InputCriblTCPCompression] = InputCriblTCPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCriblTCPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCriblTCPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputcrowdstrike.py

@@ -37,6 +37,14 @@ class InputCrowdstrikeCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputCrowdstrikePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputCrowdstrikePqControls(BaseModel):
+    pass
+
+
 class InputCrowdstrikePqTypedDict(TypedDict):
     mode: NotRequired[InputCrowdstrikeMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputCrowdstrikePqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputCrowdstrikeCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputCrowdstrikePqControlsTypedDict]
 
 
 class InputCrowdstrikePq(BaseModel):
@@ -82,6 +91,10 @@ class InputCrowdstrikePq(BaseModel):
     compress: Optional[InputCrowdstrikeCompression] = InputCrowdstrikeCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputCrowdstrikePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputCrowdstrikeAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""

cribl_control_plane/models/inputdatadogagent.py

@@ -37,6 +37,14 @@ class InputDatadogAgentCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputDatadogAgentPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputDatadogAgentPqControls(BaseModel):
+    pass
+
+
 class InputDatadogAgentPqTypedDict(TypedDict):
     mode: NotRequired[InputDatadogAgentMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputDatadogAgentPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputDatadogAgentCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputDatadogAgentPqControlsTypedDict]
 
 
 class InputDatadogAgentPq(BaseModel):
@@ -82,6 +91,10 @@ class InputDatadogAgentPq(BaseModel):
     compress: Optional[InputDatadogAgentCompression] = InputDatadogAgentCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputDatadogAgentPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputDatadogAgentMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputdatagen.py

@@ -37,6 +37,14 @@ class InputDatagenCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputDatagenPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputDatagenPqControls(BaseModel):
+    pass
+
+
 class InputDatagenPqTypedDict(TypedDict):
     mode: NotRequired[InputDatagenMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputDatagenPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputDatagenCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputDatagenPqControlsTypedDict]
 
 
 class InputDatagenPq(BaseModel):
@@ -82,6 +91,10 @@ class InputDatagenPq(BaseModel):
     compress: Optional[InputDatagenCompression] = InputDatagenCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputDatagenPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class SampleTypedDict(TypedDict):
     sample: str

cribl_control_plane/models/inputedgeprometheus.py

@@ -37,6 +37,14 @@ class InputEdgePrometheusPqCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputEdgePrometheusPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputEdgePrometheusPqControls(BaseModel):
+    pass
+
+
 class InputEdgePrometheusPqTypedDict(TypedDict):
     mode: NotRequired[InputEdgePrometheusMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputEdgePrometheusPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputEdgePrometheusPqCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputEdgePrometheusPqControlsTypedDict]
 
 
 class InputEdgePrometheusPq(BaseModel):
@@ -84,6 +93,10 @@ class InputEdgePrometheusPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputEdgePrometheusPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputEdgePrometheusDiscoveryType(str, Enum):
     r"""Target discovery mechanism. Use static to manually enter a list of targets."""

cribl_control_plane/models/inputelastic.py

@@ -37,6 +37,14 @@ class InputElasticCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputElasticPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputElasticPqControls(BaseModel):
+    pass
+
+
 class InputElasticPqTypedDict(TypedDict):
     mode: NotRequired[InputElasticMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputElasticPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputElasticCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputElasticPqControlsTypedDict]
 
 
 class InputElasticPq(BaseModel):
@@ -82,6 +91,10 @@ class InputElasticPq(BaseModel):
     compress: Optional[InputElasticCompression] = InputElasticCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputElasticPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputElasticMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputeventhub.py

@@ -37,6 +37,14 @@ class InputEventhubCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputEventhubPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputEventhubPqControls(BaseModel):
+    pass
+
+
 class InputEventhubPqTypedDict(TypedDict):
     mode: NotRequired[InputEventhubMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputEventhubPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputEventhubCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputEventhubPqControlsTypedDict]
 
 
 class InputEventhubPq(BaseModel):
@@ -82,6 +91,10 @@ class InputEventhubPq(BaseModel):
     compress: Optional[InputEventhubCompression] = InputEventhubCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputEventhubPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputEventhubSASLMechanism(str, Enum):
     PLAIN = "plain"

cribl_control_plane/models/inputexec.py

@@ -37,6 +37,14 @@ class InputExecCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputExecPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputExecPqControls(BaseModel):
+    pass
+
+
 class InputExecPqTypedDict(TypedDict):
     mode: NotRequired[InputExecMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputExecPqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputExecCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputExecPqControlsTypedDict]
 
 
 class InputExecPq(BaseModel):
@@ -82,6 +91,10 @@ class InputExecPq(BaseModel):
     compress: Optional[InputExecCompression] = InputExecCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputExecPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class ScheduleType(str, Enum):
     r"""Select a schedule type; either an interval (in seconds) or a cron-style schedule."""

cribl_control_plane/models/inputfile.py

@@ -37,6 +37,14 @@ class InputFileCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputFilePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputFilePqControls(BaseModel):
+    pass
+
+
 class InputFilePqTypedDict(TypedDict):
     mode: NotRequired[InputFilePqMode]
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
@@ -52,6 +60,7 @@ class InputFilePqTypedDict(TypedDict):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
     compress: NotRequired[InputFileCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputFilePqControlsTypedDict]
 
 
 class InputFilePq(BaseModel):
@@ -82,6 +91,10 @@ class InputFilePq(BaseModel):
     compress: Optional[InputFileCompression] = InputFileCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputFilePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputFileMode(str, Enum):
     r"""Choose how to discover files to monitor"""