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

cribl_control_plane/models/outputsplunklb.py

@@ -0,0 +1,558 @@
+"""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 OutputSplunkLbType(str, Enum, metaclass=utils.OpenEnumMeta):
+    SPLUNK_LB = "splunk_lb"
+
+
+class OutputSplunkLbNestedFieldSerialization(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How to serialize nested fields into index-time fields"""
+
+    JSON = "json"
+    NONE = "none"
+
+
+class OutputSplunkLbMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    TL_SV1 = "TLSv1"
+    TL_SV1_1 = "TLSv1.1"
+    TL_SV1_2 = "TLSv1.2"
+    TL_SV1_3 = "TLSv1.3"
+
+
+class OutputSplunkLbMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    TL_SV1 = "TLSv1"
+    TL_SV1_1 = "TLSv1.1"
+    TL_SV1_2 = "TLSv1.2"
+    TL_SV1_3 = "TLSv1.3"
+
+
+class OutputSplunkLbTLSSettingsClientSideTypedDict(TypedDict):
+    disabled: NotRequired[bool]
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates that are not authorized by a CA in the CA certificate path, or by another
+    trusted CA (such as the system's). Defaults to Enabled. Overrides the toggle from Advanced Settings, when also present.
+    """
+    servername: NotRequired[str]
+    r"""Server name for the SNI (Server Name Indication) TLS extension. It must be a host name, and not an IP address."""
+    certificate_name: NotRequired[str]
+    r"""The name of the predefined certificate"""
+    ca_path: NotRequired[str]
+    r"""Path on client in which to find CA certificates to verify the server's cert. PEM format. Can reference $ENV_VARS."""
+    priv_key_path: NotRequired[str]
+    r"""Path on client in which to find the private key to use. PEM format. Can reference $ENV_VARS."""
+    cert_path: NotRequired[str]
+    r"""Path on client in which to find certificates to use. PEM format. Can reference $ENV_VARS."""
+    passphrase: NotRequired[str]
+    r"""Passphrase to use to decrypt private key"""
+    min_version: NotRequired[OutputSplunkLbMinimumTLSVersion]
+    max_version: NotRequired[OutputSplunkLbMaximumTLSVersion]
+
+
+class OutputSplunkLbTLSSettingsClientSide(BaseModel):
+    disabled: Optional[bool] = True
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates that are not authorized by a CA in the CA certificate path, or by another
+    trusted CA (such as the system's). Defaults to Enabled. Overrides the toggle from Advanced Settings, when also present.
+    """
+
+    servername: Optional[str] = None
+    r"""Server name for the SNI (Server Name Indication) TLS extension. It must be a host name, and not an IP address."""
+
+    certificate_name: Annotated[
+        Optional[str], pydantic.Field(alias="certificateName")
+    ] = None
+    r"""The name of the predefined certificate"""
+
+    ca_path: Annotated[Optional[str], pydantic.Field(alias="caPath")] = None
+    r"""Path on client in which to find CA certificates to verify the server's cert. PEM format. Can reference $ENV_VARS."""
+
+    priv_key_path: Annotated[Optional[str], pydantic.Field(alias="privKeyPath")] = None
+    r"""Path on client in which to find the private key to use. PEM format. Can reference $ENV_VARS."""
+
+    cert_path: Annotated[Optional[str], pydantic.Field(alias="certPath")] = None
+    r"""Path on client in which to find certificates to use. PEM format. Can reference $ENV_VARS."""
+
+    passphrase: Optional[str] = None
+    r"""Passphrase to use to decrypt private key"""
+
+    min_version: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
+    ] = None
+
+    max_version: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
+    ] = None
+
+
+class OutputSplunkLbMaxS2SVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The highest S2S protocol version to advertise during handshake"""
+
+    V3 = "v3"
+    V4 = "v4"
+
+
+class OutputSplunkLbBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How to handle events when all receivers are exerting backpressure"""
+
+    BLOCK = "block"
+    DROP = "drop"
+    QUEUE = "queue"
+
+
+class OutputSplunkLbAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class OutputSplunkLbCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Controls whether the sender should send compressed data to the server. Select 'Disabled' to reject compressed connections or 'Always' to ignore server's configuration and send compressed data."""
+
+    DISABLED = "disabled"
+    AUTO = "auto"
+    ALWAYS = "always"
+
+
+class IndexerDiscoveryConfigsAuthTokenAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class OutputSplunkLbAuthTokenTypedDict(TypedDict):
+    auth_type: NotRequired[IndexerDiscoveryConfigsAuthTokenAuthenticationMethod]
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+
+class OutputSplunkLbAuthToken(BaseModel):
+    auth_type: Annotated[
+        Annotated[
+            Optional[IndexerDiscoveryConfigsAuthTokenAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = IndexerDiscoveryConfigsAuthTokenAuthenticationMethod.MANUAL
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+
+class IndexerDiscoveryConfigsAuthenticationMethod(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
+class IndexerDiscoveryConfigsTypedDict(TypedDict):
+    r"""List of configurations to set up indexer discovery in Splunk Indexer clustering environment."""
+
+    master_uri: str
+    r"""Full URI of Splunk cluster manager (scheme://host:port). Example: https://managerAddress:8089"""
+    site: NotRequired[str]
+    r"""Clustering site of the indexers from where indexers need to be discovered. In case of single site cluster, it defaults to 'default' site."""
+    refresh_interval_sec: NotRequired[float]
+    r"""Time interval, in seconds, between two consecutive indexer list fetches from cluster manager"""
+    reject_unauthorized: NotRequired[bool]
+    r"""During indexer discovery, reject cluster manager certificates that are not authorized by the system's CA. Disable to allow untrusted (for example, self-signed) certificates."""
+    auth_tokens: NotRequired[List[OutputSplunkLbAuthTokenTypedDict]]
+    r"""Tokens required to authenticate to cluster manager for indexer discovery"""
+    auth_type: NotRequired[IndexerDiscoveryConfigsAuthenticationMethod]
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+    auth_token: NotRequired[str]
+    r"""Shared secret to be provided by any client (in authToken header field). If empty, unauthorized access is permitted."""
+    text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+
+
+class IndexerDiscoveryConfigs(BaseModel):
+    r"""List of configurations to set up indexer discovery in Splunk Indexer clustering environment."""
+
+    master_uri: Annotated[str, pydantic.Field(alias="masterUri")]
+    r"""Full URI of Splunk cluster manager (scheme://host:port). Example: https://managerAddress:8089"""
+
+    site: Optional[str] = "default"
+    r"""Clustering site of the indexers from where indexers need to be discovered. In case of single site cluster, it defaults to 'default' site."""
+
+    refresh_interval_sec: Annotated[
+        Optional[float], pydantic.Field(alias="refreshIntervalSec")
+    ] = 300
+    r"""Time interval, in seconds, between two consecutive indexer list fetches from cluster manager"""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = False
+    r"""During indexer discovery, reject cluster manager certificates that are not authorized by the system's CA. Disable to allow untrusted (for example, self-signed) certificates."""
+
+    auth_tokens: Annotated[
+        Optional[List[OutputSplunkLbAuthToken]], pydantic.Field(alias="authTokens")
+    ] = None
+    r"""Tokens required to authenticate to cluster manager for indexer discovery"""
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[IndexerDiscoveryConfigsAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = IndexerDiscoveryConfigsAuthenticationMethod.MANUAL
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+    auth_token: Annotated[Optional[str], pydantic.Field(alias="authToken")] = ""
+    r"""Shared secret to be provided by any client (in authToken header field). If empty, unauthorized access is permitted."""
+
+    text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
+    r"""Select or create a stored text secret"""
+
+
+class OutputSplunkLbTLS(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Whether to inherit TLS configs from group setting or disable TLS"""
+
+    INHERIT = "inherit"
+    OFF = "off"
+
+
+class OutputSplunkLbHostTypedDict(TypedDict):
+    host: str
+    r"""The hostname of the receiver"""
+    port: NotRequired[float]
+    r"""The port to connect to on the provided host"""
+    tls: NotRequired[OutputSplunkLbTLS]
+    r"""Whether to inherit TLS configs from group setting or disable TLS"""
+    servername: NotRequired[str]
+    r"""Servername to use if establishing a TLS connection. If not specified, defaults to connection host (if not an IP); otherwise, uses the global TLS settings."""
+    weight: NotRequired[float]
+    r"""Assign a weight (>0) to each endpoint to indicate its traffic-handling capability"""
+
+
+class OutputSplunkLbHost(BaseModel):
+    host: str
+    r"""The hostname of the receiver"""
+
+    port: Optional[float] = 9997
+    r"""The port to connect to on the provided host"""
+
+    tls: Annotated[
+        Optional[OutputSplunkLbTLS], PlainValidator(validate_open_enum(False))
+    ] = OutputSplunkLbTLS.INHERIT
+    r"""Whether to inherit TLS configs from group setting or disable TLS"""
+
+    servername: Optional[str] = None
+    r"""Servername to use if establishing a TLS connection. If not specified, defaults to connection host (if not an IP); otherwise, uses the global TLS settings."""
+
+    weight: Optional[float] = 1
+    r"""Assign a weight (>0) to each endpoint to indicate its traffic-handling capability"""
+
+
+class OutputSplunkLbPqCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Codec to use to compress the persisted data"""
+
+    NONE = "none"
+    GZIP = "gzip"
+
+
+class OutputSplunkLbQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+
+    BLOCK = "block"
+    DROP = "drop"
+
+
+class OutputSplunkLbMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    ERROR = "error"
+    BACKPRESSURE = "backpressure"
+    ALWAYS = "always"
+
+
+class OutputSplunkLbPqControlsTypedDict(TypedDict):
+    pass
+
+
+class OutputSplunkLbPqControls(BaseModel):
+    pass
+
+
+class OutputSplunkLbTypedDict(TypedDict):
+    type: OutputSplunkLbType
+    hosts: List[OutputSplunkLbHostTypedDict]
+    r"""Set of Splunk indexers to load-balance data to."""
+    id: NotRequired[str]
+    r"""Unique ID for this output"""
+    pipeline: NotRequired[str]
+    r"""Pipeline to process data before sending out to this output"""
+    system_fields: NotRequired[List[str]]
+    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
+    environment: NotRequired[str]
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+    streamtags: NotRequired[List[str]]
+    r"""Tags for filtering and grouping in @{product}"""
+    dns_resolve_period_sec: NotRequired[float]
+    r"""The interval in which to re-resolve any hostnames and pick up destinations from A records"""
+    load_balance_stats_period_sec: NotRequired[float]
+    r"""How far back in time to keep traffic stats for load balancing purposes"""
+    max_concurrent_senders: NotRequired[float]
+    r"""Maximum number of concurrent connections (per Worker Process). A random set of IPs will be picked on every DNS resolution period. Use 0 for unlimited."""
+    nested_fields: NotRequired[OutputSplunkLbNestedFieldSerialization]
+    r"""How to serialize nested fields into index-time fields"""
+    throttle_rate_per_sec: NotRequired[str]
+    r"""Rate (in bytes per second) to throttle while writing to an output. Accepts values with multiple-byte units, such as KB, MB, and GB. (Example: 42 MB) Default value of 0 specifies no throttling."""
+    connection_timeout: NotRequired[float]
+    r"""Amount of time (milliseconds) to wait for the connection to establish before retrying"""
+    write_timeout: NotRequired[float]
+    r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
+    tls: NotRequired[OutputSplunkLbTLSSettingsClientSideTypedDict]
+    enable_multi_metrics: NotRequired[bool]
+    r"""Output metrics in multiple-metric format in a single event. Supported in Splunk 8.0 and above."""
+    enable_ack: NotRequired[bool]
+    r"""Check if indexer is shutting down and stop sending data. This helps minimize data loss during shutdown."""
+    log_failed_requests: NotRequired[bool]
+    r"""Use to troubleshoot issues with sending data"""
+    max_s2_sversion: NotRequired[OutputSplunkLbMaxS2SVersion]
+    r"""The highest S2S protocol version to advertise during handshake"""
+    on_backpressure: NotRequired[OutputSplunkLbBackpressureBehavior]
+    r"""How to handle events when all receivers are exerting backpressure"""
+    indexer_discovery: NotRequired[bool]
+    r"""Automatically discover indexers in indexer clustering environment."""
+    sender_unhealthy_time_allowance: NotRequired[float]
+    r"""How long (in milliseconds) each LB endpoint can report blocked before the Destination reports unhealthy, blocking the sender. (Grace period for fluctuations.) Use 0 to disable; max 1 minute."""
+    auth_type: NotRequired[OutputSplunkLbAuthenticationMethod]
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+    description: NotRequired[str]
+    max_failed_health_checks: NotRequired[float]
+    r"""Maximum number of times healthcheck can fail before we close connection. If set to 0 (disabled), and the connection to Splunk is forcibly closed, some data loss might occur."""
+    compress: NotRequired[OutputSplunkLbCompressCompression]
+    r"""Controls whether the sender should send compressed data to the server. Select 'Disabled' to reject compressed connections or 'Always' to ignore server's configuration and send compressed data."""
+    indexer_discovery_configs: NotRequired[IndexerDiscoveryConfigsTypedDict]
+    r"""List of configurations to set up indexer discovery in Splunk Indexer clustering environment."""
+    exclude_self: NotRequired[bool]
+    r"""Exclude all IPs of the current host from the list of any resolved hostnames"""
+    pq_max_file_size: NotRequired[str]
+    r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
+    pq_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."""
+    pq_path: NotRequired[str]
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
+    pq_compress: NotRequired[OutputSplunkLbPqCompressCompression]
+    r"""Codec to use to compress the persisted data"""
+    pq_on_backpressure: NotRequired[OutputSplunkLbQueueFullBehavior]
+    r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+    pq_mode: NotRequired[OutputSplunkLbMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+    pq_controls: NotRequired[OutputSplunkLbPqControlsTypedDict]
+    auth_token: NotRequired[str]
+    r"""Shared secret token to use when establishing a connection to a Splunk indexer."""
+    text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+
+
+class OutputSplunkLb(BaseModel):
+    type: Annotated[OutputSplunkLbType, PlainValidator(validate_open_enum(False))]
+
+    hosts: List[OutputSplunkLbHost]
+    r"""Set of Splunk indexers to load-balance data to."""
+
+    id: Optional[str] = None
+    r"""Unique ID for this output"""
+
+    pipeline: Optional[str] = None
+    r"""Pipeline to process data before sending out to this output"""
+
+    system_fields: Annotated[
+        Optional[List[str]], pydantic.Field(alias="systemFields")
+    ] = None
+    r"""Fields to automatically add to events, such as cribl_pipe. Supports wildcards."""
+
+    environment: Optional[str] = None
+    r"""Optionally, enable this config only on a specified Git branch. If empty, will be enabled everywhere."""
+
+    streamtags: Optional[List[str]] = None
+    r"""Tags for filtering and grouping in @{product}"""
+
+    dns_resolve_period_sec: Annotated[
+        Optional[float], pydantic.Field(alias="dnsResolvePeriodSec")
+    ] = 600
+    r"""The interval in which to re-resolve any hostnames and pick up destinations from A records"""
+
+    load_balance_stats_period_sec: Annotated[
+        Optional[float], pydantic.Field(alias="loadBalanceStatsPeriodSec")
+    ] = 300
+    r"""How far back in time to keep traffic stats for load balancing purposes"""
+
+    max_concurrent_senders: Annotated[
+        Optional[float], pydantic.Field(alias="maxConcurrentSenders")
+    ] = 0
+    r"""Maximum number of concurrent connections (per Worker Process). A random set of IPs will be picked on every DNS resolution period. Use 0 for unlimited."""
+
+    nested_fields: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbNestedFieldSerialization],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="nestedFields"),
+    ] = OutputSplunkLbNestedFieldSerialization.NONE
+    r"""How to serialize nested fields into index-time fields"""
+
+    throttle_rate_per_sec: Annotated[
+        Optional[str], pydantic.Field(alias="throttleRatePerSec")
+    ] = "0"
+    r"""Rate (in bytes per second) to throttle while writing to an output. Accepts values with multiple-byte units, such as KB, MB, and GB. (Example: 42 MB) Default value of 0 specifies no throttling."""
+
+    connection_timeout: Annotated[
+        Optional[float], pydantic.Field(alias="connectionTimeout")
+    ] = 10000
+    r"""Amount of time (milliseconds) to wait for the connection to establish before retrying"""
+
+    write_timeout: Annotated[Optional[float], pydantic.Field(alias="writeTimeout")] = (
+        60000
+    )
+    r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
+
+    tls: Optional[OutputSplunkLbTLSSettingsClientSide] = None
+
+    enable_multi_metrics: Annotated[
+        Optional[bool], pydantic.Field(alias="enableMultiMetrics")
+    ] = False
+    r"""Output metrics in multiple-metric format in a single event. Supported in Splunk 8.0 and above."""
+
+    enable_ack: Annotated[Optional[bool], pydantic.Field(alias="enableACK")] = True
+    r"""Check if indexer is shutting down and stop sending data. This helps minimize data loss during shutdown."""
+
+    log_failed_requests: Annotated[
+        Optional[bool], pydantic.Field(alias="logFailedRequests")
+    ] = False
+    r"""Use to troubleshoot issues with sending data"""
+
+    max_s2_sversion: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbMaxS2SVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxS2Sversion"),
+    ] = OutputSplunkLbMaxS2SVersion.V3
+    r"""The highest S2S protocol version to advertise during handshake"""
+
+    on_backpressure: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="onBackpressure"),
+    ] = OutputSplunkLbBackpressureBehavior.BLOCK
+    r"""How to handle events when all receivers are exerting backpressure"""
+
+    indexer_discovery: Annotated[
+        Optional[bool], pydantic.Field(alias="indexerDiscovery")
+    ] = False
+    r"""Automatically discover indexers in indexer clustering environment."""
+
+    sender_unhealthy_time_allowance: Annotated[
+        Optional[float], pydantic.Field(alias="senderUnhealthyTimeAllowance")
+    ] = 100
+    r"""How long (in milliseconds) each LB endpoint can report blocked before the Destination reports unhealthy, blocking the sender. (Grace period for fluctuations.) Use 0 to disable; max 1 minute."""
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = OutputSplunkLbAuthenticationMethod.MANUAL
+    r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
+
+    description: Optional[str] = None
+
+    max_failed_health_checks: Annotated[
+        Optional[float], pydantic.Field(alias="maxFailedHealthChecks")
+    ] = 1
+    r"""Maximum number of times healthcheck can fail before we close connection. If set to 0 (disabled), and the connection to Splunk is forcibly closed, some data loss might occur."""
+
+    compress: Annotated[
+        Optional[OutputSplunkLbCompressCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = OutputSplunkLbCompressCompression.DISABLED
+    r"""Controls whether the sender should send compressed data to the server. Select 'Disabled' to reject compressed connections or 'Always' to ignore server's configuration and send compressed data."""
+
+    indexer_discovery_configs: Annotated[
+        Optional[IndexerDiscoveryConfigs],
+        pydantic.Field(alias="indexerDiscoveryConfigs"),
+    ] = None
+    r"""List of configurations to set up indexer discovery in Splunk Indexer clustering environment."""
+
+    exclude_self: Annotated[Optional[bool], pydantic.Field(alias="excludeSelf")] = False
+    r"""Exclude all IPs of the current host from the list of any resolved hostnames"""
+
+    pq_max_file_size: Annotated[
+        Optional[str], pydantic.Field(alias="pqMaxFileSize")
+    ] = "1 MB"
+    r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
+
+    pq_max_size: Annotated[Optional[str], pydantic.Field(alias="pqMaxSize")] = "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."""
+
+    pq_path: Annotated[Optional[str], pydantic.Field(alias="pqPath")] = (
+        "$CRIBL_HOME/state/queues"
+    )
+    r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
+
+    pq_compress: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbPqCompressCompression],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqCompress"),
+    ] = OutputSplunkLbPqCompressCompression.NONE
+    r"""Codec to use to compress the persisted data"""
+
+    pq_on_backpressure: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqOnBackpressure"),
+    ] = OutputSplunkLbQueueFullBehavior.BLOCK
+    r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputSplunkLbMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputSplunkLbMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    pq_controls: Annotated[
+        Optional[OutputSplunkLbPqControls], pydantic.Field(alias="pqControls")
+    ] = None
+
+    auth_token: Annotated[Optional[str], pydantic.Field(alias="authToken")] = ""
+    r"""Shared secret token to use when establishing a connection to a Splunk indexer."""
+
+    text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
+    r"""Select or create a stored text secret"""