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

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

cribl_control_plane/models/inputtcp.py

@@ -37,6 +37,14 @@ class InputTCPCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputTCPPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputTCPPqControls(BaseModel):
+    pass
+
+
 class InputTCPPqTypedDict(TypedDict):
     mode: NotRequired[InputTCPMode]
     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 InputTCPPqTypedDict(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[InputTCPCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputTCPPqControlsTypedDict]
 
 
 class InputTCPPq(BaseModel):
@@ -82,6 +91,10 @@ class InputTCPPq(BaseModel):
     compress: Optional[InputTCPCompression] = InputTCPCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputTCPPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputTCPMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputtcpjson.py

@@ -37,6 +37,14 @@ class InputTcpjsonCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputTcpjsonPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputTcpjsonPqControls(BaseModel):
+    pass
+
+
 class InputTcpjsonPqTypedDict(TypedDict):
     mode: NotRequired[InputTcpjsonMode]
     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 InputTcpjsonPqTypedDict(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[InputTcpjsonCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputTcpjsonPqControlsTypedDict]
 
 
 class InputTcpjsonPq(BaseModel):
@@ -82,6 +91,10 @@ class InputTcpjsonPq(BaseModel):
     compress: Optional[InputTcpjsonCompression] = InputTcpjsonCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputTcpjsonPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputTcpjsonMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputwef.py

@@ -37,6 +37,14 @@ class InputWefCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputWefPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWefPqControls(BaseModel):
+    pass
+
+
 class InputWefPqTypedDict(TypedDict):
     mode: NotRequired[InputWefMode]
     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 InputWefPqTypedDict(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[InputWefCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWefPqControlsTypedDict]
 
 
 class InputWefPq(BaseModel):
@@ -82,6 +91,10 @@ class InputWefPq(BaseModel):
     compress: Optional[InputWefCompression] = InputWefCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWefPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputWefAuthenticationMethod(str, Enum):
     r"""How to authenticate incoming client connections"""

cribl_control_plane/models/inputwindowsmetrics.py

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

cribl_control_plane/models/inputwineventlogs.py

@@ -37,6 +37,14 @@ class InputWinEventLogsCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputWinEventLogsPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWinEventLogsPqControls(BaseModel):
+    pass
+
+
 class InputWinEventLogsPqTypedDict(TypedDict):
     mode: NotRequired[InputWinEventLogsMode]
     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 InputWinEventLogsPqTypedDict(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[InputWinEventLogsCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWinEventLogsPqControlsTypedDict]
 
 
 class InputWinEventLogsPq(BaseModel):
@@ -82,6 +91,10 @@ class InputWinEventLogsPq(BaseModel):
     compress: Optional[InputWinEventLogsCompression] = InputWinEventLogsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWinEventLogsPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class ReadMode(str, Enum):
     r"""Read all stored and future event logs, or only future events"""

cribl_control_plane/models/inputwiz.py

@@ -37,6 +37,14 @@ class InputWizCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputWizPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWizPqControls(BaseModel):
+    pass
+
+
 class InputWizPqTypedDict(TypedDict):
     mode: NotRequired[InputWizMode]
     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 InputWizPqTypedDict(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[InputWizCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWizPqControlsTypedDict]
 
 
 class InputWizPq(BaseModel):
@@ -82,6 +91,10 @@ class InputWizPq(BaseModel):
     compress: Optional[InputWizCompression] = InputWizCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWizPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputWizContentConfigTypedDict(TypedDict):
     content_type: str

cribl_control_plane/models/inputwizwebhook.py

@@ -37,6 +37,14 @@ class InputWizWebhookCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputWizWebhookPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputWizWebhookPqControls(BaseModel):
+    pass
+
+
 class InputWizWebhookPqTypedDict(TypedDict):
     mode: NotRequired[InputWizWebhookMode]
     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 InputWizWebhookPqTypedDict(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[InputWizWebhookCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputWizWebhookPqControlsTypedDict]
 
 
 class InputWizWebhookPq(BaseModel):
@@ -82,6 +91,10 @@ class InputWizWebhookPq(BaseModel):
     compress: Optional[InputWizWebhookCompression] = InputWizWebhookCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputWizWebhookPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputWizWebhookMinimumTLSVersion(str, Enum):
     TL_SV1 = "TLSv1"

cribl_control_plane/models/inputzscalerhec.py

@@ -37,6 +37,14 @@ class InputZscalerHecCompression(str, Enum):
     GZIP = "gzip"
 
 
+class InputZscalerHecPqControlsTypedDict(TypedDict):
+    pass
+
+
+class InputZscalerHecPqControls(BaseModel):
+    pass
+
+
 class InputZscalerHecPqTypedDict(TypedDict):
     mode: NotRequired[InputZscalerHecMode]
     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 InputZscalerHecPqTypedDict(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[InputZscalerHecCompression]
     r"""Codec to use to compress the persisted data"""
+    pq_controls: NotRequired[InputZscalerHecPqControlsTypedDict]
 
 
 class InputZscalerHecPq(BaseModel):
@@ -82,6 +91,10 @@ class InputZscalerHecPq(BaseModel):
     compress: Optional[InputZscalerHecCompression] = InputZscalerHecCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
+    pq_controls: Annotated[
+        Optional[InputZscalerHecPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
 
 class InputZscalerHecAuthenticationMethod(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/output.py

@@ -90,25 +90,25 @@ OutputTypedDict = TypeAliasType(
         OutputDevnullTypedDict,
         OutputDefaultTypedDict,
         OutputRouterTypedDict,
-        OutputNetflowTypedDict,
         OutputSnmpTypedDict,
+        OutputNetflowTypedDict,
         OutputDiskSpoolTypedDict,
         OutputRingTypedDict,
-        OutputStatsdExtTypedDict,
         OutputGraphiteTypedDict,
         OutputStatsdTypedDict,
+        OutputStatsdExtTypedDict,
         OutputGooglePubsubTypedDict,
         OutputCriblTCPTypedDict,
-        OutputSnsTypedDict,
         OutputSplunkTypedDict,
+        OutputSnsTypedDict,
         OutputCloudwatchTypedDict,
         OutputSyslogTypedDict,
         OutputAzureEventhubTypedDict,
         OutputWavefrontTypedDict,
         OutputSignalfxTypedDict,
         OutputHoneycombTypedDict,
-        OutputSumoLogicTypedDict,
         OutputTcpjsonTypedDict,
+        OutputSumoLogicTypedDict,
         OutputHumioHecTypedDict,
         OutputElasticCloudTypedDict,
         OutputCrowdstrikeNextGenSiemTypedDict,
@@ -125,15 +125,15 @@ OutputTypedDict = TypeAliasType(
         OutputXsiamTypedDict,
         OutputFilesystemTypedDict,
         OutputDatasetTypedDict,
+        OutputLokiTypedDict,
         OutputSplunkHecTypedDict,
         OutputDynatraceHTTPTypedDict,
         OutputServiceNowTypedDict,
-        OutputLokiTypedDict,
         OutputDynatraceOtlpTypedDict,
-        OutputGoogleChronicleTypedDict,
         OutputElasticTypedDict,
-        OutputDatadogTypedDict,
+        OutputGoogleChronicleTypedDict,
         OutputCriblLakeTypedDict,
+        OutputDatadogTypedDict,
         OutputPrometheusTypedDict,
         OutputMskTypedDict,
         OutputSentinelOneAiSiemTypedDict,
@@ -161,25 +161,25 @@ Output = TypeAliasType(
         OutputDevnull,
         OutputDefault,
         OutputRouter,
-        OutputNetflow,
         OutputSnmp,
+        OutputNetflow,
         OutputDiskSpool,
         OutputRing,
-        OutputStatsdExt,
         OutputGraphite,
         OutputStatsd,
+        OutputStatsdExt,
         OutputGooglePubsub,
         OutputCriblTCP,
-        OutputSns,
         OutputSplunk,
+        OutputSns,
         OutputCloudwatch,
         OutputSyslog,
         OutputAzureEventhub,
         OutputWavefront,
         OutputSignalfx,
         OutputHoneycomb,
-        OutputSumoLogic,
         OutputTcpjson,
+        OutputSumoLogic,
         OutputHumioHec,
         OutputElasticCloud,
         OutputCrowdstrikeNextGenSiem,
@@ -196,15 +196,15 @@ Output = TypeAliasType(
         OutputXsiam,
         OutputFilesystem,
         OutputDataset,
+        OutputLoki,
         OutputSplunkHec,
         OutputDynatraceHTTP,
         OutputServiceNow,
-        OutputLoki,
         OutputDynatraceOtlp,
-        OutputGoogleChronicle,
         OutputElastic,
-        OutputDatadog,
+        OutputGoogleChronicle,
         OutputCriblLake,
+        OutputDatadog,
         OutputPrometheus,
         OutputMsk,
         OutputSentinelOneAiSiem,

cribl_control_plane/models/outputgooglechronicle.py

@@ -227,7 +227,7 @@ class OutputGoogleChronicleTypedDict(TypedDict):
     log_text_field: NotRequired[str]
     r"""Name of the event field that contains the log text to send. If not specified, Stream sends a JSON representation of the whole event."""
     customer_id: NotRequired[str]
-    r"""Unique identifier (UUID) corresponding to a particular SecOps instance. Provided by your SecOps representative."""
+    r"""A unique identifier (UUID) for your Google SecOps instance. This is provided by your Google representative and is required for API V2 authentication."""
     namespace: NotRequired[str]
     r"""User-configured environment namespace to identify the data domain the logs originated from. Use namespace as a tag to identify the appropriate data domain for indexing and enrichment functionality. Can be overwritten by event field __namespace."""
     custom_labels: NotRequired[List[CustomLabelTypedDict]]
@@ -388,7 +388,7 @@ class OutputGoogleChronicle(BaseModel):
     r"""Name of the event field that contains the log text to send. If not specified, Stream sends a JSON representation of the whole event."""
 
     customer_id: Annotated[Optional[str], pydantic.Field(alias="customerId")] = None
-    r"""Unique identifier (UUID) corresponding to a particular SecOps instance. Provided by your SecOps representative."""
+    r"""A unique identifier (UUID) for your Google SecOps instance. This is provided by your Google representative and is required for API V2 authentication."""
 
     namespace: Optional[str] = None
     r"""User-configured environment namespace to identify the data domain the logs originated from. Use namespace as a tag to identify the appropriate data domain for indexing and enrichment functionality. Can be overwritten by event field __namespace."""

cribl_control_plane/models/outputgrafanacloud.py

@@ -284,8 +284,6 @@ class OutputGrafanaCloudGrafanaCloud2TypedDict(TypedDict):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
     safe_headers: NotRequired[List[str]]
     r"""List of headers that are safe to log in plain text"""
-    send_structured_metadata: NotRequired[bool]
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
     response_retry_settings: NotRequired[
         List[OutputGrafanaCloudResponseRetrySetting2TypedDict]
     ]
@@ -418,11 +416,6 @@ class OutputGrafanaCloudGrafanaCloud2(BaseModel):
     ] = None
     r"""List of headers that are safe to log in plain text"""
 
-    send_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="sendStructuredMetadata")
-    ] = False
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
-
     response_retry_settings: Annotated[
         Optional[List[OutputGrafanaCloudResponseRetrySetting2]],
         pydantic.Field(alias="responseRetrySettings"),
@@ -760,8 +753,6 @@ class OutputGrafanaCloudGrafanaCloud1TypedDict(TypedDict):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
     safe_headers: NotRequired[List[str]]
     r"""List of headers that are safe to log in plain text"""
-    send_structured_metadata: NotRequired[bool]
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
     response_retry_settings: NotRequired[
         List[OutputGrafanaCloudResponseRetrySetting1TypedDict]
     ]
@@ -896,11 +887,6 @@ class OutputGrafanaCloudGrafanaCloud1(BaseModel):
     ] = None
     r"""List of headers that are safe to log in plain text"""
 
-    send_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="sendStructuredMetadata")
-    ] = False
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
-
     response_retry_settings: Annotated[
         Optional[List[OutputGrafanaCloudResponseRetrySetting1]],
         pydantic.Field(alias="responseRetrySettings"),

cribl_control_plane/models/outputloki.py

@@ -200,8 +200,6 @@ class OutputLokiTypedDict(TypedDict):
     r"""Honor any Retry-After header that specifies a delay (in seconds) no longer than 180 seconds after the retry request. @{product} limits the delay to 180 seconds, even if the Retry-After header specifies a longer delay. When enabled, takes precedence over user-configured retry options. When disabled, all Retry-After headers are ignored."""
     enable_dynamic_headers: NotRequired[bool]
     r"""Add per-event HTTP headers from the __headers field to outgoing requests. Events with different headers are batched and sent separately."""
-    send_structured_metadata: NotRequired[bool]
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
     on_backpressure: NotRequired[OutputLokiBackpressureBehavior]
     r"""How to handle events when all receivers are exerting backpressure"""
     total_memory_limit_kb: NotRequired[float]
@@ -344,11 +342,6 @@ class OutputLoki(BaseModel):
     ] = False
     r"""Add per-event HTTP headers from the __headers field to outgoing requests. Events with different headers are batched and sent separately."""
 
-    send_structured_metadata: Annotated[
-        Optional[bool], pydantic.Field(alias="sendStructuredMetadata")
-    ] = False
-    r"""Add structured metadata fields from __structuredMetadata to each log. Key-value pairs must be strings."""
-
     on_backpressure: Annotated[
         Optional[OutputLokiBackpressureBehavior], pydantic.Field(alias="onBackpressure")
     ] = OutputLokiBackpressureBehavior.BLOCK

cribl_control_plane/models/updatepipelinebyidop.py

@@ -11,9 +11,9 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class UpdatePipelineByIDRequestTypedDict(TypedDict):
     id_param: str
-    r"""Unique ID to PATCH"""
+    r"""The <code>id</code> of the Pipeline to update."""
     pipeline: PipelineTypedDict
-    r"""Pipeline object to be updated"""
+    r"""Pipeline object"""
 
 
 class UpdatePipelineByIDRequest(BaseModel):
@@ -22,16 +22,16 @@ class UpdatePipelineByIDRequest(BaseModel):
         pydantic.Field(alias="id"),
         FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
     ]
-    r"""Unique ID to PATCH"""
+    r"""The <code>id</code> of the Pipeline to update."""
 
     pipeline: Annotated[
         Pipeline, FieldMetadata(request=RequestMetadata(media_type="application/json"))
     ]
-    r"""Pipeline object to be updated"""
+    r"""Pipeline object"""
 
 
 class UpdatePipelineByIDResponseTypedDict(TypedDict):
-    r"""a list of any objects"""
+    r"""a list of Pipeline objects"""
 
     count: NotRequired[int]
     r"""number of items present in the items array"""
@@ -39,7 +39,7 @@ class UpdatePipelineByIDResponseTypedDict(TypedDict):
 
 
 class UpdatePipelineByIDResponse(BaseModel):
-    r"""a list of any objects"""
+    r"""a list of Pipeline objects"""
 
     count: Optional[int] = None
     r"""number of items present in the items array"""

cribl_control_plane/models/updateroutesbyidop.py

@@ -11,7 +11,7 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class UpdateRoutesByIDRequestTypedDict(TypedDict):
     id_param: str
-    r"""Unique ID to PATCH"""
+    r"""The <code>id</code> of the Routing table that contains the Route to update. The supported value is <code>default</code>."""
     routes: RoutesTypedDict
     r"""Routes object"""
 
@@ -22,7 +22,7 @@ class UpdateRoutesByIDRequest(BaseModel):
         pydantic.Field(alias="id"),
         FieldMetadata(path=PathParamMetadata(style="simple", explode=False)),
     ]
-    r"""Unique ID to PATCH"""
+    r"""The <code>id</code> of the Routing table that contains the Route to update. The supported value is <code>default</code>."""
 
     routes: Annotated[
         Routes, FieldMetadata(request=RequestMetadata(media_type="application/json"))