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

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

cribl_control_plane/models/inputfirehose.py

@@ -37,6 +37,14 @@ class InputFirehoseCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputFirehosePqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputFirehosePqControls(BaseModel):
+    pass
+
+
 class InputFirehosePqTypedDict(TypedDict):
     mode: NotRequired[InputFirehoseMode]
     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 InputFirehosePqTypedDict(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[InputFirehoseCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputFirehosePqControlsTypedDict]
 
 
 class InputFirehosePq(BaseModel):
@@ -82,6 +91,10 @@ class InputFirehosePq(BaseModel):
     compress: Optional[InputFirehoseCompression] = InputFirehoseCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputFirehosePqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputFirehoseMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputgooglepubsub.py

@@ -37,6 +37,14 @@ class InputGooglePubsubCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputGooglePubsubPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputGooglePubsubPqControls(BaseModel):
+    pass
+
+
 class InputGooglePubsubPqTypedDict(TypedDict):
     mode: NotRequired[InputGooglePubsubMode]
     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 InputGooglePubsubPqTypedDict(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[InputGooglePubsubCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputGooglePubsubPqControlsTypedDict]
 
 
 class InputGooglePubsubPq(BaseModel):
@@ -82,6 +91,10 @@ class InputGooglePubsubPq(BaseModel):
     compress: Optional[InputGooglePubsubCompression] = InputGooglePubsubCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputGooglePubsubPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputGooglePubsubGoogleAuthenticationMethod(str, Enum):
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""

cribl_control_plane/models/inputgrafana.py

@@ -37,6 +37,14 @@ class InputGrafanaCompression2(str, Enum):
     GZIP = "gzip"
 
 
+class InputGrafanaPqControls2TypedDict(TypedDict):
+    pass
+
+
+class InputGrafanaPqControls2(BaseModel):
+    pass
+
+
 class InputGrafanaPq2TypedDict(TypedDict):
     mode: NotRequired[InputGrafanaMode2]
     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 InputGrafanaPq2TypedDict(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[InputGrafanaCompression2]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputGrafanaPqControls2TypedDict]
 
 
 class InputGrafanaPq2(BaseModel):
@@ -82,6 +91,10 @@ class InputGrafanaPq2(BaseModel):
     compress: Optional[InputGrafanaCompression2] = InputGrafanaCompression2.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputGrafanaPqControls2], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputGrafanaMinimumTLSVersion2(str, Enum):
     TL_SV1 = "TLSv1"
@@ -477,8 +490,6 @@ class InputGrafanaGrafana2TypedDict(TypedDict):
     r"""Absolute path on which to listen for Grafana Agent's Remote Write requests. Defaults to /api/prom/push, which will expand as: 'http://<your‑upstream‑URL>:<your‑port>/api/prom/push'. Either this field or 'Logs API endpoint' must be configured."""
     loki_api: NotRequired[str]
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'. Either this field or 'Remote Write API endpoint' must be configured."""
-    extract_structured_metadata: NotRequired[bool]
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
     prometheus_auth: NotRequired[InputGrafanaPrometheusAuth2TypedDict]
     loki_auth: NotRequired[InputGrafanaLokiAuth2TypedDict]
     metadata: NotRequired[List[InputGrafanaMetadatum2TypedDict]]
@@ -589,11 +600,6 @@ class InputGrafanaGrafana2(BaseModel):
     )
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'. Either this field or 'Remote Write API endpoint' must be configured."""
 
-    extract_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="extractStructuredMetadata")
-    ] = False
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
-
     prometheus_auth: Annotated[
         Optional[InputGrafanaPrometheusAuth2], pydantic.Field(alias="prometheusAuth")
     ] = None
@@ -637,6 +643,14 @@ class InputGrafanaCompression1(str, Enum):
     GZIP = "gzip"
 
 
+class InputGrafanaPqControls1TypedDict(TypedDict):
+    pass
+
+
+class InputGrafanaPqControls1(BaseModel):
+    pass
+
+
 class InputGrafanaPq1TypedDict(TypedDict):
     mode: NotRequired[InputGrafanaMode1]
     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."""
@@ -652,6 +666,7 @@ class InputGrafanaPq1TypedDict(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[InputGrafanaCompression1]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputGrafanaPqControls1TypedDict]
 
 
 class InputGrafanaPq1(BaseModel):
@@ -682,6 +697,10 @@ class InputGrafanaPq1(BaseModel):
     compress: Optional[InputGrafanaCompression1] = InputGrafanaCompression1.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputGrafanaPqControls1], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputGrafanaMinimumTLSVersion1(str, Enum):
     TL_SV1 = "TLSv1"
@@ -1077,8 +1096,6 @@ class InputGrafanaGrafana1TypedDict(TypedDict):
     r"""Absolute path on which to listen for Grafana Agent's Remote Write requests. Defaults to /api/prom/push, which will expand as: 'http://<your‑upstream‑URL>:<your‑port>/api/prom/push'. Either this field or 'Logs API endpoint' must be configured."""
     loki_api: NotRequired[str]
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'. Either this field or 'Remote Write API endpoint' must be configured."""
-    extract_structured_metadata: NotRequired[bool]
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
     prometheus_auth: NotRequired[InputGrafanaPrometheusAuth1TypedDict]
     loki_auth: NotRequired[InputGrafanaLokiAuth1TypedDict]
     metadata: NotRequired[List[InputGrafanaMetadatum1TypedDict]]
@@ -1189,11 +1206,6 @@ class InputGrafanaGrafana1(BaseModel):
     )
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'. Either this field or 'Remote Write API endpoint' must be configured."""
 
-    extract_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="extractStructuredMetadata")
-    ] = False
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
-
     prometheus_auth: Annotated[
         Optional[InputGrafanaPrometheusAuth1], pydantic.Field(alias="prometheusAuth")
     ] = None

cribl_control_plane/models/inputhttp.py

@@ -37,6 +37,14 @@ class InputHTTPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputHTTPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputHTTPPqControls(BaseModel):
+    pass
+
+
 class InputHTTPPqTypedDict(TypedDict):
     mode: NotRequired[InputHTTPMode]
     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 InputHTTPPqTypedDict(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[InputHTTPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputHTTPPqControlsTypedDict]
 
 
 class InputHTTPPq(BaseModel):
@@ -82,6 +91,10 @@ class InputHTTPPq(BaseModel):
     compress: Optional[InputHTTPCompression] = InputHTTPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputHTTPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputHTTPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputhttpraw.py

@@ -37,6 +37,14 @@ class InputHTTPRawCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputHTTPRawPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputHTTPRawPqControls(BaseModel):
+    pass
+
+
 class InputHTTPRawPqTypedDict(TypedDict):
     mode: NotRequired[InputHTTPRawMode]
     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 InputHTTPRawPqTypedDict(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[InputHTTPRawCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputHTTPRawPqControlsTypedDict]
 
 
 class InputHTTPRawPq(BaseModel):
@@ -82,6 +91,10 @@ class InputHTTPRawPq(BaseModel):
     compress: Optional[InputHTTPRawCompression] = InputHTTPRawCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputHTTPRawPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputHTTPRawMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputjournalfiles.py

@@ -37,6 +37,14 @@ class InputJournalFilesCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputJournalFilesPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputJournalFilesPqControls(BaseModel):
+    pass
+
+
 class InputJournalFilesPqTypedDict(TypedDict):
     mode: NotRequired[InputJournalFilesMode]
     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 InputJournalFilesPqTypedDict(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[InputJournalFilesCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputJournalFilesPqControlsTypedDict]
 
 
 class InputJournalFilesPq(BaseModel):
@@ -82,6 +91,10 @@ class InputJournalFilesPq(BaseModel):
     compress: Optional[InputJournalFilesCompression] = InputJournalFilesCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputJournalFilesPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputJournalFilesRuleTypedDict(TypedDict):
     filter_: str

cribl_control_plane/models/inputkafka.py

@@ -37,6 +37,14 @@ class InputKafkaCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputKafkaPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputKafkaPqControls(BaseModel):
+    pass
+
+
 class InputKafkaPqTypedDict(TypedDict):
     mode: NotRequired[InputKafkaMode]
     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 InputKafkaPqTypedDict(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[InputKafkaCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputKafkaPqControlsTypedDict]
 
 
 class InputKafkaPq(BaseModel):
@@ -82,6 +91,10 @@ class InputKafkaPq(BaseModel):
     compress: Optional[InputKafkaCompression] = InputKafkaCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputKafkaPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputKafkaSchemaType(str, Enum):
     r"""The schema format used to encode and decode event data"""

cribl_control_plane/models/inputkinesis.py

@@ -37,6 +37,14 @@ class InputKinesisCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputKinesisPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputKinesisPqControls(BaseModel):
+    pass
+
+
 class InputKinesisPqTypedDict(TypedDict):
     mode: NotRequired[InputKinesisMode]
     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 InputKinesisPqTypedDict(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[InputKinesisCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputKinesisPqControlsTypedDict]
 
 
 class InputKinesisPq(BaseModel):
@@ -82,6 +91,10 @@ class InputKinesisPq(BaseModel):
     compress: Optional[InputKinesisCompression] = InputKinesisCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputKinesisPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class ShardIteratorStart(str, Enum):
     r"""Location at which to start reading a shard for the first time"""

cribl_control_plane/models/inputkubeevents.py

@@ -37,6 +37,14 @@ class InputKubeEventsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputKubeEventsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputKubeEventsPqControls(BaseModel):
+    pass
+
+
 class InputKubeEventsPqTypedDict(TypedDict):
     mode: NotRequired[InputKubeEventsMode]
     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 InputKubeEventsPqTypedDict(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[InputKubeEventsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputKubeEventsPqControlsTypedDict]
 
 
 class InputKubeEventsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputKubeEventsPq(BaseModel):
     compress: Optional[InputKubeEventsCompression] = InputKubeEventsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputKubeEventsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputKubeEventsRuleTypedDict(TypedDict):
     filter_: str

cribl_control_plane/models/inputkubelogs.py

@@ -37,6 +37,14 @@ class InputKubeLogsPqCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputKubeLogsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputKubeLogsPqControls(BaseModel):
+    pass
+
+
 class InputKubeLogsPqTypedDict(TypedDict):
     mode: NotRequired[InputKubeLogsMode]
     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 InputKubeLogsPqTypedDict(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[InputKubeLogsPqCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputKubeLogsPqControlsTypedDict]
 
 
 class InputKubeLogsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputKubeLogsPq(BaseModel):
     compress: Optional[InputKubeLogsPqCompression] = InputKubeLogsPqCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputKubeLogsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputKubeLogsRuleTypedDict(TypedDict):
     filter_: str

cribl_control_plane/models/inputkubemetrics.py

@@ -37,6 +37,14 @@ class InputKubeMetricsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputKubeMetricsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputKubeMetricsPqControls(BaseModel):
+    pass
+
+
 class InputKubeMetricsPqTypedDict(TypedDict):
     mode: NotRequired[InputKubeMetricsMode]
     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 InputKubeMetricsPqTypedDict(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[InputKubeMetricsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputKubeMetricsPqControlsTypedDict]
 
 
 class InputKubeMetricsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputKubeMetricsPq(BaseModel):
     compress: Optional[InputKubeMetricsCompression] = InputKubeMetricsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputKubeMetricsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputKubeMetricsRuleTypedDict(TypedDict):
     filter_: str

cribl_control_plane/models/inputloki.py

@@ -37,6 +37,14 @@ class InputLokiCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputLokiPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputLokiPqControls(BaseModel):
+    pass
+
+
 class InputLokiPqTypedDict(TypedDict):
     mode: NotRequired[InputLokiMode]
     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 InputLokiPqTypedDict(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[InputLokiCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputLokiPqControlsTypedDict]
 
 
 class InputLokiPq(BaseModel):
@@ -82,6 +91,10 @@ class InputLokiPq(BaseModel):
     compress: Optional[InputLokiCompression] = InputLokiCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputLokiPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputLokiMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"
@@ -258,8 +271,6 @@ class InputLokiTypedDict(TypedDict):
     r"""Messages from matched IP addresses will be ignored. This takes precedence over the allowlist."""
     loki_api: NotRequired[str]
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'."""
-    extract_structured_metadata: NotRequired[bool]
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
     auth_type: NotRequired[InputLokiAuthenticationType]
     r"""Loki logs authentication type"""
     metadata: NotRequired[List[InputLokiMetadatumTypedDict]]
@@ -389,11 +400,6 @@ class InputLoki(BaseModel):
     )
     r"""Absolute path on which to listen for Loki logs requests. Defaults to /loki/api/v1/push, which will (in this example) expand as: 'http://<your‑upstream‑URL>:<your‑port>/loki/api/v1/push'."""
 
-    extract_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="extractStructuredMetadata")
-    ] = False
-    r"""Extract structured metadata from the Loki 3.5.3+ format and place it in the __structuredMetadata field. When disabled, uses legacy Loki parsing for backward compatibility."""
-
     auth_type: Annotated[
         Optional[InputLokiAuthenticationType], pydantic.Field(alias="authType")
     ] = InputLokiAuthenticationType.NONE

cribl_control_plane/models/inputmetrics.py

@@ -37,6 +37,14 @@ class InputMetricsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputMetricsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputMetricsPqControls(BaseModel):
+    pass
+
+
 class InputMetricsPqTypedDict(TypedDict):
     mode: NotRequired[InputMetricsMode]
     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 InputMetricsPqTypedDict(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[InputMetricsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputMetricsPqControlsTypedDict]
 
 
 class InputMetricsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputMetricsPq(BaseModel):
     compress: Optional[InputMetricsCompression] = InputMetricsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputMetricsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputMetricsMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"