cribl-control-plane 0.0.13__py3-none-any.whl

cribl_control_plane/models/inputkinesis.py

@@ -0,0 +1,363 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane import utils
+from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class InputKinesisType(str, Enum, metaclass=utils.OpenEnumMeta):
+    KINESIS = "kinesis"
+
+
+class InputKinesisConnectionTypedDict(TypedDict):
+    output: str
+    pipeline: NotRequired[str]
+
+
+class InputKinesisConnection(BaseModel):
+    output: str
+
+    pipeline: Optional[str] = None
+
+
+class InputKinesisMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    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."""
+
+    SMART = "smart"
+    ALWAYS = "always"
+
+
+class InputKinesisCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Codec to use to compress the persisted data"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+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."""
+    max_buffer_size: NotRequired[float]
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+    commit_frequency: NotRequired[float]
+    r"""The number of events to send downstream before committing that Stream has read them"""
+    max_file_size: NotRequired[str]
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+    max_size: NotRequired[str]
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+    path: NotRequired[str]
+    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"""
+
+
+class InputKinesisPq(BaseModel):
+    mode: Annotated[
+        Optional[InputKinesisMode], PlainValidator(validate_open_enum(False))
+    ] = InputKinesisMode.ALWAYS
+    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."""
+
+    max_buffer_size: Annotated[
+        Optional[float], pydantic.Field(alias="maxBufferSize")
+    ] = 1000
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+
+    commit_frequency: Annotated[
+        Optional[float], pydantic.Field(alias="commitFrequency")
+    ] = 42
+    r"""The number of events to send downstream before committing that Stream has read them"""
+
+    max_file_size: Annotated[Optional[str], pydantic.Field(alias="maxFileSize")] = (
+        "1 MB"
+    )
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+
+    max_size: Annotated[Optional[str], pydantic.Field(alias="maxSize")] = "5GB"
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+
+    path: Optional[str] = "$CRIBL_HOME/state/queues"
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
+
+    compress: Annotated[
+        Optional[InputKinesisCompression], PlainValidator(validate_open_enum(False))
+    ] = InputKinesisCompression.NONE
+    r"""Codec to use to compress the persisted data"""
+
+
+class ShardIteratorStart(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Location at which to start reading a shard for the first time"""
+
+    TRIM_HORIZON = "TRIM_HORIZON"
+    LATEST = "LATEST"
+
+
+class InputKinesisRecordDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Format of data inside the Kinesis Stream records. Gzip compression is automatically detected."""
+
+    CRIBL = "cribl"
+    NDJSON = "ndjson"
+    CLOUDWATCH = "cloudwatch"
+    LINE = "line"
+
+
+class ShardLoadBalancing(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The load-balancing algorithm to use for spreading out shards across Workers and Worker Processes"""
+
+    CONSISTENT_HASHING = "ConsistentHashing"
+    ROUND_ROBIN = "RoundRobin"
+
+
+class InputKinesisAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    AUTO = "auto"
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class InputKinesisSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Signature version to use for signing Kinesis stream requests"""
+
+    V2 = "v2"
+    V4 = "v4"
+
+
+class InputKinesisMetadatumTypedDict(TypedDict):
+    name: str
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputKinesisMetadatum(BaseModel):
+    name: str
+
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputKinesisTypedDict(TypedDict):
+    type: InputKinesisType
+    stream_name: str
+    r"""Kinesis Data Stream to read data from"""
+    region: str
+    r"""Region where the Kinesis stream is located"""
+    id: NotRequired[str]
+    r"""Unique ID for this input"""
+    disabled: NotRequired[bool]
+    pipeline: NotRequired[str]
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+    send_to_routes: NotRequired[bool]
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+    environment: NotRequired[str]
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+    pq_enabled: NotRequired[bool]
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+    streamtags: NotRequired[List[str]]
+    r"""Tags for filtering and grouping in @{product}"""
+    connections: NotRequired[List[InputKinesisConnectionTypedDict]]
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+    pq: NotRequired[InputKinesisPqTypedDict]
+    service_interval: NotRequired[float]
+    r"""Time interval in minutes between consecutive service calls"""
+    shard_expr: NotRequired[str]
+    r"""A JavaScript expression to be called with each shardId for the stream. If the expression evaluates to a truthy value, the shard will be processed."""
+    shard_iterator_type: NotRequired[ShardIteratorStart]
+    r"""Location at which to start reading a shard for the first time"""
+    payload_format: NotRequired[InputKinesisRecordDataFormat]
+    r"""Format of data inside the Kinesis Stream records. Gzip compression is automatically detected."""
+    get_records_limit: NotRequired[float]
+    r"""Maximum number of records per getRecords call"""
+    get_records_limit_total: NotRequired[float]
+    r"""Maximum number of records, across all shards, to pull down at once per Worker Process"""
+    load_balancing_algorithm: NotRequired[ShardLoadBalancing]
+    r"""The load-balancing algorithm to use for spreading out shards across Workers and Worker Processes"""
+    aws_authentication_method: NotRequired[InputKinesisAuthenticationMethod]
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+    aws_secret_key: NotRequired[str]
+    endpoint: NotRequired[str]
+    r"""Kinesis stream service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to Kinesis stream-compatible endpoint."""
+    signature_version: NotRequired[InputKinesisSignatureVersion]
+    r"""Signature version to use for signing Kinesis stream requests"""
+    reuse_connections: NotRequired[bool]
+    r"""Reuse connections between requests, which can improve performance"""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates that cannot be verified against a valid CA, such as self-signed certificates"""
+    enable_assume_role: NotRequired[bool]
+    r"""Use Assume Role credentials to access Kinesis stream"""
+    assume_role_arn: NotRequired[str]
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+    assume_role_external_id: NotRequired[str]
+    r"""External ID to use when assuming role"""
+    duration_seconds: NotRequired[float]
+    r"""Duration of the assumed role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+    verify_kpl_check_sums: NotRequired[bool]
+    r"""Verify Kinesis Producer Library (KPL) event checksums"""
+    avoid_duplicates: NotRequired[bool]
+    r"""When resuming streaming from a stored state, Stream will read the next available record, rather than rereading the last-read record. Enabling this setting can cause data loss after a Worker Node's unexpected shutdown or restart."""
+    metadata: NotRequired[List[InputKinesisMetadatumTypedDict]]
+    r"""Fields to add to events from this input"""
+    description: NotRequired[str]
+    aws_api_key: NotRequired[str]
+    aws_secret: NotRequired[str]
+    r"""Select or create a stored secret that references your access key and secret key"""
+
+
+class InputKinesis(BaseModel):
+    type: Annotated[InputKinesisType, PlainValidator(validate_open_enum(False))]
+
+    stream_name: Annotated[str, pydantic.Field(alias="streamName")]
+    r"""Kinesis Data Stream to read data from"""
+
+    region: str
+    r"""Region where the Kinesis stream is located"""
+
+    id: Optional[str] = None
+    r"""Unique ID for this input"""
+
+    disabled: Optional[bool] = False
+
+    pipeline: Optional[str] = None
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+
+    send_to_routes: Annotated[Optional[bool], pydantic.Field(alias="sendToRoutes")] = (
+        True
+    )
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+
+    environment: Optional[str] = None
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+
+    pq_enabled: Annotated[Optional[bool], pydantic.Field(alias="pqEnabled")] = False
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+
+    streamtags: Optional[List[str]] = None
+    r"""Tags for filtering and grouping in @{product}"""
+
+    connections: Optional[List[InputKinesisConnection]] = None
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+
+    pq: Optional[InputKinesisPq] = None
+
+    service_interval: Annotated[
+        Optional[float], pydantic.Field(alias="serviceInterval")
+    ] = 1
+    r"""Time interval in minutes between consecutive service calls"""
+
+    shard_expr: Annotated[Optional[str], pydantic.Field(alias="shardExpr")] = "true"
+    r"""A JavaScript expression to be called with each shardId for the stream. If the expression evaluates to a truthy value, the shard will be processed."""
+
+    shard_iterator_type: Annotated[
+        Annotated[
+            Optional[ShardIteratorStart], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="shardIteratorType"),
+    ] = ShardIteratorStart.TRIM_HORIZON
+    r"""Location at which to start reading a shard for the first time"""
+
+    payload_format: Annotated[
+        Annotated[
+            Optional[InputKinesisRecordDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="payloadFormat"),
+    ] = InputKinesisRecordDataFormat.CRIBL
+    r"""Format of data inside the Kinesis Stream records. Gzip compression is automatically detected."""
+
+    get_records_limit: Annotated[
+        Optional[float], pydantic.Field(alias="getRecordsLimit")
+    ] = 5000
+    r"""Maximum number of records per getRecords call"""
+
+    get_records_limit_total: Annotated[
+        Optional[float], pydantic.Field(alias="getRecordsLimitTotal")
+    ] = 20000
+    r"""Maximum number of records, across all shards, to pull down at once per Worker Process"""
+
+    load_balancing_algorithm: Annotated[
+        Annotated[
+            Optional[ShardLoadBalancing], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="loadBalancingAlgorithm"),
+    ] = ShardLoadBalancing.CONSISTENT_HASHING
+    r"""The load-balancing algorithm to use for spreading out shards across Workers and Worker Processes"""
+
+    aws_authentication_method: Annotated[
+        Annotated[
+            Optional[InputKinesisAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="awsAuthenticationMethod"),
+    ] = InputKinesisAuthenticationMethod.AUTO
+    r"""AWS authentication method. Choose Auto to use IAM roles."""
+
+    aws_secret_key: Annotated[Optional[str], pydantic.Field(alias="awsSecretKey")] = (
+        None
+    )
+
+    endpoint: Optional[str] = None
+    r"""Kinesis stream service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to Kinesis stream-compatible endpoint."""
+
+    signature_version: Annotated[
+        Annotated[
+            Optional[InputKinesisSignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
+    ] = InputKinesisSignatureVersion.V4
+    r"""Signature version to use for signing Kinesis stream requests"""
+
+    reuse_connections: Annotated[
+        Optional[bool], pydantic.Field(alias="reuseConnections")
+    ] = True
+    r"""Reuse connections between requests, which can improve performance"""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates that cannot be verified against a valid CA, such as self-signed certificates"""
+
+    enable_assume_role: Annotated[
+        Optional[bool], pydantic.Field(alias="enableAssumeRole")
+    ] = False
+    r"""Use Assume Role credentials to access Kinesis stream"""
+
+    assume_role_arn: Annotated[Optional[str], pydantic.Field(alias="assumeRoleArn")] = (
+        None
+    )
+    r"""Amazon Resource Name (ARN) of the role to assume"""
+
+    assume_role_external_id: Annotated[
+        Optional[str], pydantic.Field(alias="assumeRoleExternalId")
+    ] = None
+    r"""External ID to use when assuming role"""
+
+    duration_seconds: Annotated[
+        Optional[float], pydantic.Field(alias="durationSeconds")
+    ] = 3600
+    r"""Duration of the assumed role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours)."""
+
+    verify_kpl_check_sums: Annotated[
+        Optional[bool], pydantic.Field(alias="verifyKPLCheckSums")
+    ] = False
+    r"""Verify Kinesis Producer Library (KPL) event checksums"""
+
+    avoid_duplicates: Annotated[
+        Optional[bool], pydantic.Field(alias="avoidDuplicates")
+    ] = False
+    r"""When resuming streaming from a stored state, Stream will read the next available record, rather than rereading the last-read record. Enabling this setting can cause data loss after a Worker Node's unexpected shutdown or restart."""
+
+    metadata: Optional[List[InputKinesisMetadatum]] = None
+    r"""Fields to add to events from this input"""
+
+    description: Optional[str] = None
+
+    aws_api_key: Annotated[Optional[str], pydantic.Field(alias="awsApiKey")] = None
+
+    aws_secret: Annotated[Optional[str], pydantic.Field(alias="awsSecret")] = None
+    r"""Select or create a stored secret that references your access key and secret key"""

cribl_control_plane/models/inputkubeevents.py

@@ -0,0 +1,182 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane import utils
+from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class InputKubeEventsType(str, Enum, metaclass=utils.OpenEnumMeta):
+    KUBE_EVENTS = "kube_events"
+
+
+class InputKubeEventsConnectionTypedDict(TypedDict):
+    output: str
+    pipeline: NotRequired[str]
+
+
+class InputKubeEventsConnection(BaseModel):
+    output: str
+
+    pipeline: Optional[str] = None
+
+
+class InputKubeEventsMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    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."""
+
+    SMART = "smart"
+    ALWAYS = "always"
+
+
+class InputKubeEventsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Codec to use to compress the persisted data"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+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."""
+    max_buffer_size: NotRequired[float]
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+    commit_frequency: NotRequired[float]
+    r"""The number of events to send downstream before committing that Stream has read them"""
+    max_file_size: NotRequired[str]
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+    max_size: NotRequired[str]
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+    path: NotRequired[str]
+    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"""
+
+
+class InputKubeEventsPq(BaseModel):
+    mode: Annotated[
+        Optional[InputKubeEventsMode], PlainValidator(validate_open_enum(False))
+    ] = InputKubeEventsMode.ALWAYS
+    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."""
+
+    max_buffer_size: Annotated[
+        Optional[float], pydantic.Field(alias="maxBufferSize")
+    ] = 1000
+    r"""The maximum number of events to hold in memory before writing the events to disk"""
+
+    commit_frequency: Annotated[
+        Optional[float], pydantic.Field(alias="commitFrequency")
+    ] = 42
+    r"""The number of events to send downstream before committing that Stream has read them"""
+
+    max_file_size: Annotated[Optional[str], pydantic.Field(alias="maxFileSize")] = (
+        "1 MB"
+    )
+    r"""The maximum size to store in each queue file before closing and optionally compressing. Enter a numeral with units of KB, MB, etc."""
+
+    max_size: Annotated[Optional[str], pydantic.Field(alias="maxSize")] = "5GB"
+    r"""The maximum disk space that the queue can consume (as an average per Worker Process) before queueing stops. Enter a numeral with units of KB, MB, etc."""
+
+    path: Optional[str] = "$CRIBL_HOME/state/queues"
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/inputs/<input-id>"""
+
+    compress: Annotated[
+        Optional[InputKubeEventsCompression], PlainValidator(validate_open_enum(False))
+    ] = InputKubeEventsCompression.NONE
+    r"""Codec to use to compress the persisted data"""
+
+
+class InputKubeEventsRuleTypedDict(TypedDict):
+    filter_: str
+    r"""JavaScript expression applied to Kubernetes objects. Return 'true' to include it."""
+    description: NotRequired[str]
+    r"""Optional description of this rule's purpose"""
+
+
+class InputKubeEventsRule(BaseModel):
+    filter_: Annotated[str, pydantic.Field(alias="filter")]
+    r"""JavaScript expression applied to Kubernetes objects. Return 'true' to include it."""
+
+    description: Optional[str] = None
+    r"""Optional description of this rule's purpose"""
+
+
+class InputKubeEventsMetadatumTypedDict(TypedDict):
+    name: str
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputKubeEventsMetadatum(BaseModel):
+    name: str
+
+    value: str
+    r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
+
+
+class InputKubeEventsTypedDict(TypedDict):
+    id: str
+    r"""Unique ID for this input"""
+    type: InputKubeEventsType
+    disabled: NotRequired[bool]
+    pipeline: NotRequired[str]
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+    send_to_routes: NotRequired[bool]
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+    environment: NotRequired[str]
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+    pq_enabled: NotRequired[bool]
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+    streamtags: NotRequired[List[str]]
+    r"""Tags for filtering and grouping in @{product}"""
+    connections: NotRequired[List[InputKubeEventsConnectionTypedDict]]
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+    pq: NotRequired[InputKubeEventsPqTypedDict]
+    rules: NotRequired[List[InputKubeEventsRuleTypedDict]]
+    r"""Filtering on event fields"""
+    metadata: NotRequired[List[InputKubeEventsMetadatumTypedDict]]
+    r"""Fields to add to events from this input"""
+    description: NotRequired[str]
+
+
+class InputKubeEvents(BaseModel):
+    id: str
+    r"""Unique ID for this input"""
+
+    type: Annotated[InputKubeEventsType, PlainValidator(validate_open_enum(False))]
+
+    disabled: Optional[bool] = False
+
+    pipeline: Optional[str] = None
+    r"""Pipeline to process data from this Source before sending it through the Routes"""
+
+    send_to_routes: Annotated[Optional[bool], pydantic.Field(alias="sendToRoutes")] = (
+        True
+    )
+    r"""Select whether to send data to Routes, or directly to Destinations."""
+
+    environment: Optional[str] = None
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+
+    pq_enabled: Annotated[Optional[bool], pydantic.Field(alias="pqEnabled")] = False
+    r"""Use a disk queue to minimize data loss when connected services block. See [Cribl Docs](https://docs.cribl.io/stream/persistent-queues) for PQ defaults (Cribl-managed Cloud Workers) and configuration options (on-prem and hybrid Workers)."""
+
+    streamtags: Optional[List[str]] = None
+    r"""Tags for filtering and grouping in @{product}"""
+
+    connections: Optional[List[InputKubeEventsConnection]] = None
+    r"""Direct connections to Destinations, and optionally via a Pipeline or a Pack"""
+
+    pq: Optional[InputKubeEventsPq] = None
+
+    rules: Optional[List[InputKubeEventsRule]] = None
+    r"""Filtering on event fields"""
+
+    metadata: Optional[List[InputKubeEventsMetadatum]] = None
+    r"""Fields to add to events from this input"""
+
+    description: Optional[str] = None