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

cribl_control_plane/models/inputmodeldriventelemetry.py

@@ -37,6 +37,14 @@ class InputModelDrivenTelemetryCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputModelDrivenTelemetryPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputModelDrivenTelemetryPqControls(BaseModel):
+    pass
+
+
 class InputModelDrivenTelemetryPqTypedDict(TypedDict):
     mode: NotRequired[InputModelDrivenTelemetryMode]
     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 InputModelDrivenTelemetryPqTypedDict(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[InputModelDrivenTelemetryCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputModelDrivenTelemetryPqControlsTypedDict]
 
 
 class InputModelDrivenTelemetryPq(BaseModel):
@@ -84,6 +93,11 @@ class InputModelDrivenTelemetryPq(BaseModel):
     )
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputModelDrivenTelemetryPqControls],
+        pydantic.Field(alias="pqControls"),
+    ] = None
+
 
 class InputModelDrivenTelemetryMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputmsk.py

@@ -37,6 +37,14 @@ class InputMskCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputMskPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputMskPqControls(BaseModel):
+    pass
+
+
 class InputMskPqTypedDict(TypedDict):
     mode: NotRequired[InputMskMode]
     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 InputMskPqTypedDict(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[InputMskCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputMskPqControlsTypedDict]
 
 
 class InputMskPq(BaseModel):
@@ -82,6 +91,10 @@ class InputMskPq(BaseModel):
     compress: Optional[InputMskCompression] = InputMskCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputMskPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputMskMetadatumTypedDict(TypedDict):
     name: str

cribl_control_plane/models/inputnetflow.py

@@ -37,6 +37,14 @@ class InputNetflowCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputNetflowPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputNetflowPqControls(BaseModel):
+    pass
+
+
 class InputNetflowPqTypedDict(TypedDict):
     mode: NotRequired[InputNetflowMode]
     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 InputNetflowPqTypedDict(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[InputNetflowCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputNetflowPqControlsTypedDict]
 
 
 class InputNetflowPq(BaseModel):
@@ -82,6 +91,10 @@ class InputNetflowPq(BaseModel):
     compress: Optional[InputNetflowCompression] = InputNetflowCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputNetflowPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputNetflowMetadatumTypedDict(TypedDict):
     name: str

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)"""