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

cribl_control_plane/models/inputoffice365mgmt.py

@@ -37,6 +37,14 @@ class InputOffice365MgmtCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputOffice365MgmtPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputOffice365MgmtPqControls(BaseModel):
+    pass
+
+
 class InputOffice365MgmtPqTypedDict(TypedDict):
     mode: NotRequired[InputOffice365MgmtMode]
     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 InputOffice365MgmtPqTypedDict(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[InputOffice365MgmtCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputOffice365MgmtPqControlsTypedDict]
 
 
 class InputOffice365MgmtPq(BaseModel):
@@ -84,6 +93,10 @@ class InputOffice365MgmtPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputOffice365MgmtPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputOffice365MgmtSubscriptionPlan(str, Enum):
     r"""Office 365 subscription plan for your organization, typically Office 365 Enterprise"""

cribl_control_plane/models/inputoffice365msgtrace.py

@@ -37,6 +37,14 @@ class InputOffice365MsgTraceCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputOffice365MsgTracePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputOffice365MsgTracePqControls(BaseModel):
+    pass
+
+
 class InputOffice365MsgTracePqTypedDict(TypedDict):
     mode: NotRequired[InputOffice365MsgTraceMode]
     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 InputOffice365MsgTracePqTypedDict(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[InputOffice365MsgTraceCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputOffice365MsgTracePqControlsTypedDict]
 
 
 class InputOffice365MsgTracePq(BaseModel):
@@ -84,6 +93,10 @@ class InputOffice365MsgTracePq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputOffice365MsgTracePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputOffice365MsgTraceAuthenticationMethod(str, Enum):
     r"""Select authentication method."""

cribl_control_plane/models/inputoffice365service.py

@@ -37,6 +37,14 @@ class InputOffice365ServiceCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputOffice365ServicePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputOffice365ServicePqControls(BaseModel):
+    pass
+
+
 class InputOffice365ServicePqTypedDict(TypedDict):
     mode: NotRequired[InputOffice365ServiceMode]
     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 InputOffice365ServicePqTypedDict(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[InputOffice365ServiceCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputOffice365ServicePqControlsTypedDict]
 
 
 class InputOffice365ServicePq(BaseModel):
@@ -84,6 +93,10 @@ class InputOffice365ServicePq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputOffice365ServicePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputOffice365ServiceSubscriptionPlan(str, Enum):
     r"""Office 365 subscription plan for your organization, typically Office 365 Enterprise"""

cribl_control_plane/models/inputopentelemetry.py

@@ -37,6 +37,14 @@ class InputOpenTelemetryCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputOpenTelemetryPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputOpenTelemetryPqControls(BaseModel):
+    pass
+
+
 class InputOpenTelemetryPqTypedDict(TypedDict):
     mode: NotRequired[InputOpenTelemetryMode]
     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 InputOpenTelemetryPqTypedDict(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[InputOpenTelemetryCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputOpenTelemetryPqControlsTypedDict]
 
 
 class InputOpenTelemetryPq(BaseModel):
@@ -84,6 +93,10 @@ class InputOpenTelemetryPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputOpenTelemetryPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputOpenTelemetryMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputprometheus.py

@@ -37,6 +37,14 @@ class InputPrometheusCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputPrometheusPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputPrometheusPqControls(BaseModel):
+    pass
+
+
 class InputPrometheusPqTypedDict(TypedDict):
     mode: NotRequired[InputPrometheusMode]
     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 InputPrometheusPqTypedDict(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[InputPrometheusCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputPrometheusPqControlsTypedDict]
 
 
 class InputPrometheusPq(BaseModel):
@@ -82,6 +91,10 @@ class InputPrometheusPq(BaseModel):
     compress: Optional[InputPrometheusCompression] = InputPrometheusCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputPrometheusPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputPrometheusDiscoveryType(str, Enum):
     r"""Target discovery mechanism. Use static to manually enter a list of targets."""

cribl_control_plane/models/inputprometheusrw.py

@@ -37,6 +37,14 @@ class InputPrometheusRwCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputPrometheusRwPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputPrometheusRwPqControls(BaseModel):
+    pass
+
+
 class InputPrometheusRwPqTypedDict(TypedDict):
     mode: NotRequired[InputPrometheusRwMode]
     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 InputPrometheusRwPqTypedDict(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[InputPrometheusRwCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputPrometheusRwPqControlsTypedDict]
 
 
 class InputPrometheusRwPq(BaseModel):
@@ -82,6 +91,10 @@ class InputPrometheusRwPq(BaseModel):
     compress: Optional[InputPrometheusRwCompression] = InputPrometheusRwCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputPrometheusRwPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputPrometheusRwMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputrawudp.py

@@ -37,6 +37,14 @@ class InputRawUDPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputRawUDPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputRawUDPPqControls(BaseModel):
+    pass
+
+
 class InputRawUDPPqTypedDict(TypedDict):
     mode: NotRequired[InputRawUDPMode]
     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 InputRawUDPPqTypedDict(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[InputRawUDPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputRawUDPPqControlsTypedDict]
 
 
 class InputRawUDPPq(BaseModel):
@@ -82,6 +91,10 @@ class InputRawUDPPq(BaseModel):
     compress: Optional[InputRawUDPCompression] = InputRawUDPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputRawUDPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputRawUDPMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputs3.py

@@ -37,6 +37,14 @@ class InputS3Compression(str, Enum):
     GZIP = "gzip"
 
 
+class InputS3PqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputS3PqControls(BaseModel):
+    pass
+
+
 class InputS3PqTypedDict(TypedDict):
     mode: NotRequired[InputS3Mode]
     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 InputS3PqTypedDict(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[InputS3Compression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputS3PqControlsTypedDict]
 
 
 class InputS3Pq(BaseModel):
@@ -82,6 +91,10 @@ class InputS3Pq(BaseModel):
     compress: Optional[InputS3Compression] = InputS3Compression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputS3PqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputS3AuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""

cribl_control_plane/models/inputs3inventory.py

@@ -37,6 +37,14 @@ class InputS3InventoryCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputS3InventoryPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputS3InventoryPqControls(BaseModel):
+    pass
+
+
 class InputS3InventoryPqTypedDict(TypedDict):
     mode: NotRequired[InputS3InventoryMode]
     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 InputS3InventoryPqTypedDict(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[InputS3InventoryCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputS3InventoryPqControlsTypedDict]
 
 
 class InputS3InventoryPq(BaseModel):
@@ -82,6 +91,10 @@ class InputS3InventoryPq(BaseModel):
     compress: Optional[InputS3InventoryCompression] = InputS3InventoryCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputS3InventoryPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputS3InventoryAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""

cribl_control_plane/models/inputsecuritylake.py

@@ -37,6 +37,14 @@ class InputSecurityLakeCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSecurityLakePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSecurityLakePqControls(BaseModel):
+    pass
+
+
 class InputSecurityLakePqTypedDict(TypedDict):
     mode: NotRequired[InputSecurityLakeMode]
     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 InputSecurityLakePqTypedDict(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[InputSecurityLakeCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSecurityLakePqControlsTypedDict]
 
 
 class InputSecurityLakePq(BaseModel):
@@ -82,6 +91,10 @@ class InputSecurityLakePq(BaseModel):
     compress: Optional[InputSecurityLakeCompression] = InputSecurityLakeCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSecurityLakePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSecurityLakeAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""

cribl_control_plane/models/inputsnmp.py

@@ -37,6 +37,14 @@ class InputSnmpCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSnmpPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSnmpPqControls(BaseModel):
+    pass
+
+
 class InputSnmpPqTypedDict(TypedDict):
     mode: NotRequired[InputSnmpMode]
     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 InputSnmpPqTypedDict(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[InputSnmpCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSnmpPqControlsTypedDict]
 
 
 class InputSnmpPq(BaseModel):
@@ -82,6 +91,10 @@ class InputSnmpPq(BaseModel):
     compress: Optional[InputSnmpCompression] = InputSnmpCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSnmpPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class AuthenticationProtocol(str, Enum):
     NONE = "none"

cribl_control_plane/models/inputsplunk.py

@@ -37,6 +37,14 @@ class InputSplunkPqCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSplunkPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSplunkPqControls(BaseModel):
+    pass
+
+
 class InputSplunkPqTypedDict(TypedDict):
     mode: NotRequired[InputSplunkMode]
     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 InputSplunkPqTypedDict(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[InputSplunkPqCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSplunkPqControlsTypedDict]
 
 
 class InputSplunkPq(BaseModel):
@@ -82,6 +91,10 @@ class InputSplunkPq(BaseModel):
     compress: Optional[InputSplunkPqCompression] = InputSplunkPqCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSplunkPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSplunkMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputsplunkhec.py

@@ -37,6 +37,14 @@ class InputSplunkHecCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSplunkHecPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSplunkHecPqControls(BaseModel):
+    pass
+
+
 class InputSplunkHecPqTypedDict(TypedDict):
     mode: NotRequired[InputSplunkHecMode]
     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 InputSplunkHecPqTypedDict(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[InputSplunkHecCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSplunkHecPqControlsTypedDict]
 
 
 class InputSplunkHecPq(BaseModel):
@@ -82,6 +91,10 @@ class InputSplunkHecPq(BaseModel):
     compress: Optional[InputSplunkHecCompression] = InputSplunkHecCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSplunkHecPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSplunkHecAuthenticationMethod(str, Enum):
     r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""

cribl_control_plane/models/inputsplunksearch.py

@@ -37,6 +37,14 @@ class InputSplunkSearchCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSplunkSearchPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSplunkSearchPqControls(BaseModel):
+    pass
+
+
 class InputSplunkSearchPqTypedDict(TypedDict):
     mode: NotRequired[InputSplunkSearchMode]
     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 InputSplunkSearchPqTypedDict(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[InputSplunkSearchCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSplunkSearchPqControlsTypedDict]
 
 
 class InputSplunkSearchPq(BaseModel):
@@ -82,6 +91,10 @@ class InputSplunkSearchPq(BaseModel):
     compress: Optional[InputSplunkSearchCompression] = InputSplunkSearchCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSplunkSearchPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class OutputMode(str, Enum):
     r"""Format of the returned output"""

cribl_control_plane/models/inputsqs.py

@@ -37,6 +37,14 @@ class InputSqsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSqsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSqsPqControls(BaseModel):
+    pass
+
+
 class InputSqsPqTypedDict(TypedDict):
     mode: NotRequired[InputSqsMode]
     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 InputSqsPqTypedDict(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[InputSqsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSqsPqControlsTypedDict]
 
 
 class InputSqsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputSqsPq(BaseModel):
     compress: Optional[InputSqsCompression] = InputSqsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSqsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSqsQueueType(str, Enum):
     r"""The queue type used (or created)"""

cribl_control_plane/models/inputsyslog.py

@@ -37,6 +37,14 @@ class InputSyslogCompression2(str, Enum):
     GZIP = "gzip"
 
 
+class InputSyslogPqControls2TypedDict(TypedDict):
+    pass
+
+
+class InputSyslogPqControls2(BaseModel):
+    pass
+
+
 class InputSyslogPq2TypedDict(TypedDict):
     mode: NotRequired[InputSyslogMode2]
     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 InputSyslogPq2TypedDict(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[InputSyslogCompression2]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSyslogPqControls2TypedDict]
 
 
 class InputSyslogPq2(BaseModel):
@@ -82,6 +91,10 @@ class InputSyslogPq2(BaseModel):
     compress: Optional[InputSyslogCompression2] = InputSyslogCompression2.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSyslogPqControls2], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSyslogMinimumTLSVersion2(str, Enum):
     TL_SV1 = "TLSv1"
@@ -395,6 +408,14 @@ class InputSyslogCompression1(str, Enum):
     GZIP = "gzip"
 
 
+class InputSyslogPqControls1TypedDict(TypedDict):
+    pass
+
+
+class InputSyslogPqControls1(BaseModel):
+    pass
+
+
 class InputSyslogPq1TypedDict(TypedDict):
     mode: NotRequired[InputSyslogMode1]
     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."""
@@ -410,6 +431,7 @@ class InputSyslogPq1TypedDict(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[InputSyslogCompression1]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSyslogPqControls1TypedDict]
 
 
 class InputSyslogPq1(BaseModel):
@@ -440,6 +462,10 @@ class InputSyslogPq1(BaseModel):
     compress: Optional[InputSyslogCompression1] = InputSyslogCompression1.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSyslogPqControls1], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSyslogMinimumTLSVersion1(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputsystemmetrics.py

@@ -37,6 +37,14 @@ class InputSystemMetricsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSystemMetricsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSystemMetricsPqControls(BaseModel):
+    pass
+
+
 class InputSystemMetricsPqTypedDict(TypedDict):
     mode: NotRequired[InputSystemMetricsPqMode]
     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 InputSystemMetricsPqTypedDict(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[InputSystemMetricsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSystemMetricsPqControlsTypedDict]
 
 
 class InputSystemMetricsPq(BaseModel):
@@ -84,6 +93,10 @@ class InputSystemMetricsPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSystemMetricsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSystemMetricsHostMode(str, Enum):
     r"""Select level of detail for host metrics"""

cribl_control_plane/models/inputsystemstate.py

@@ -37,6 +37,14 @@ class InputSystemStateCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputSystemStatePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputSystemStatePqControls(BaseModel):
+    pass
+
+
 class InputSystemStatePqTypedDict(TypedDict):
     mode: NotRequired[InputSystemStateMode]
     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 InputSystemStatePqTypedDict(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[InputSystemStateCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputSystemStatePqControlsTypedDict]
 
 
 class InputSystemStatePq(BaseModel):
@@ -82,6 +91,10 @@ class InputSystemStatePq(BaseModel):
     compress: Optional[InputSystemStateCompression] = InputSystemStateCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputSystemStatePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputSystemStateMetadatumTypedDict(TypedDict):
     name: str