cribl-control-plane 0.0.44a1__py3-none-any.whl → 0.0.44a2__py3-none-any.whl

cribl_control_plane/models/outputsplunklb.py

@@ -1,9 +1,12 @@
 """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
 
@@ -12,21 +15,21 @@ class OutputSplunkLbType(str, Enum):
     SPLUNK_LB = "splunk_lb"
 
 
-class OutputSplunkLbNestedFieldSerialization(str, Enum):
+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):
+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):
+class OutputSplunkLbMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -86,22 +89,30 @@ class OutputSplunkLbTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Optional[OutputSplunkLbMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[OutputSplunkLbMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[OutputSplunkLbMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[OutputSplunkLbMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
 
-class OutputSplunkLbMaxS2SVersion(str, Enum):
+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):
+class OutputSplunkLbBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -109,14 +120,14 @@ class OutputSplunkLbBackpressureBehavior(str, Enum):
     QUEUE = "queue"
 
 
-class OutputSplunkLbAuthenticationMethod(str, Enum):
+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):
+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"
@@ -124,7 +135,9 @@ class OutputSplunkLbCompressCompression(str, Enum):
     ALWAYS = "always"
 
 
-class IndexerDiscoveryConfigsAuthTokenAuthenticationMethod(str, Enum):
+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"
@@ -138,13 +151,18 @@ class OutputSplunkLbAuthTokenTypedDict(TypedDict):
 
 class OutputSplunkLbAuthToken(BaseModel):
     auth_type: Annotated[
-        Optional[IndexerDiscoveryConfigsAuthTokenAuthenticationMethod],
+        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):
+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"
@@ -197,7 +215,10 @@ class IndexerDiscoveryConfigs(BaseModel):
     r"""Tokens required to authenticate to cluster manager for indexer discovery"""
 
     auth_type: Annotated[
-        Optional[IndexerDiscoveryConfigsAuthenticationMethod],
+        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"""
@@ -209,7 +230,7 @@ class IndexerDiscoveryConfigs(BaseModel):
     r"""Select or create a stored text secret"""
 
 
-class OutputSplunkLbTLS(str, Enum):
+class OutputSplunkLbTLS(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Whether to inherit TLS configs from group setting or disable TLS"""
 
     INHERIT = "inherit"
@@ -236,7 +257,9 @@ class OutputSplunkLbHost(BaseModel):
     port: Optional[float] = 9997
     r"""The port to connect to on the provided host"""
 
-    tls: Optional[OutputSplunkLbTLS] = OutputSplunkLbTLS.INHERIT
+    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
@@ -246,21 +269,21 @@ class OutputSplunkLbHost(BaseModel):
     r"""Assign a weight (>0) to each endpoint to indicate its traffic-handling capability"""
 
 
-class OutputSplunkLbPqCompressCompression(str, Enum):
+class OutputSplunkLbPqCompressCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputSplunkLbQueueFullBehavior(str, Enum):
+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):
+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"
@@ -388,7 +411,10 @@ class OutputSplunkLb(BaseModel):
     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[
-        Optional[OutputSplunkLbNestedFieldSerialization],
+        Annotated[
+            Optional[OutputSplunkLbNestedFieldSerialization],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="nestedFields"),
     ] = OutputSplunkLbNestedFieldSerialization.NONE
     r"""How to serialize nested fields into index-time fields"""
@@ -424,12 +450,19 @@ class OutputSplunkLb(BaseModel):
     r"""Use to troubleshoot issues with sending data"""
 
     max_s2_sversion: Annotated[
-        Optional[OutputSplunkLbMaxS2SVersion], pydantic.Field(alias="maxS2Sversion")
+        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[
-        Optional[OutputSplunkLbBackpressureBehavior],
+        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"""
@@ -445,7 +478,11 @@ class OutputSplunkLb(BaseModel):
     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[
-        Optional[OutputSplunkLbAuthenticationMethod], pydantic.Field(alias="authType")
+        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"""
 
@@ -456,9 +493,10 @@ class OutputSplunkLb(BaseModel):
     ] = 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: Optional[OutputSplunkLbCompressCompression] = (
-        OutputSplunkLbCompressCompression.DISABLED
-    )
+    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[
@@ -484,20 +522,29 @@ class OutputSplunkLb(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Optional[OutputSplunkLbPqCompressCompression],
+        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[
-        Optional[OutputSplunkLbQueueFullBehavior],
+        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[Optional[OutputSplunkLbMode], pydantic.Field(alias="pqMode")] = (
-        OutputSplunkLbMode.ERROR
-    )
+    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[

cribl_control_plane/models/outputsqs.py

@@ -1,9 +1,12 @@
 """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
 
@@ -12,14 +15,14 @@ class OutputSqsType(str, Enum):
     SQS = "sqs"
 
 
-class OutputSqsQueueType(str, Enum):
+class OutputSqsQueueType(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""The queue type used (or created). Defaults to Standard."""
 
     STANDARD = "standard"
     FIFO = "fifo"
 
 
-class OutputSqsAuthenticationMethod(str, Enum):
+class OutputSqsAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
     AUTO = "auto"
@@ -27,14 +30,14 @@ class OutputSqsAuthenticationMethod(str, Enum):
     SECRET = "secret"
 
 
-class OutputSqsSignatureVersion(str, Enum):
+class OutputSqsSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Signature version to use for signing SQS requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputSqsBackpressureBehavior(str, Enum):
+class OutputSqsBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -42,21 +45,21 @@ class OutputSqsBackpressureBehavior(str, Enum):
     QUEUE = "queue"
 
 
-class OutputSqsCompression(str, Enum):
+class OutputSqsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputSqsQueueFullBehavior(str, Enum):
+class OutputSqsQueueFullBehavior(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 OutputSqsMode(str, Enum):
+class OutputSqsMode(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"
@@ -168,7 +171,10 @@ class OutputSqs(BaseModel):
     r"""Tags for filtering and grouping in @{product}"""
 
     queue_type: Annotated[
-        Optional[OutputSqsQueueType], pydantic.Field(alias="queueType")
+        Annotated[
+            Optional[OutputSqsQueueType], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="queueType"),
     ] = OutputSqsQueueType.STANDARD
     r"""The queue type used (or created). Defaults to Standard."""
 
@@ -186,7 +192,10 @@ class OutputSqs(BaseModel):
     r"""Create queue if it does not exist."""
 
     aws_authentication_method: Annotated[
-        Optional[OutputSqsAuthenticationMethod],
+        Annotated[
+            Optional[OutputSqsAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputSqsAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -202,7 +211,11 @@ class OutputSqs(BaseModel):
     r"""SQS service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to SQS-compatible endpoint."""
 
     signature_version: Annotated[
-        Optional[OutputSqsSignatureVersion], pydantic.Field(alias="signatureVersion")
+        Annotated[
+            Optional[OutputSqsSignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
     ] = OutputSqsSignatureVersion.V4
     r"""Signature version to use for signing SQS requests"""
 
@@ -257,7 +270,11 @@ class OutputSqs(BaseModel):
     r"""The maximum number of in-progress API requests before backpressure is applied."""
 
     on_backpressure: Annotated[
-        Optional[OutputSqsBackpressureBehavior], pydantic.Field(alias="onBackpressure")
+        Annotated[
+            Optional[OutputSqsBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="onBackpressure"),
     ] = OutputSqsBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -282,18 +299,26 @@ class OutputSqs(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Optional[OutputSqsCompression], pydantic.Field(alias="pqCompress")
+        Annotated[
+            Optional[OutputSqsCompression], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqCompress"),
     ] = OutputSqsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputSqsQueueFullBehavior], pydantic.Field(alias="pqOnBackpressure")
+        Annotated[
+            Optional[OutputSqsQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputSqsQueueFullBehavior.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[Optional[OutputSqsMode], pydantic.Field(alias="pqMode")] = (
-        OutputSqsMode.ERROR
-    )
+    pq_mode: Annotated[
+        Annotated[Optional[OutputSqsMode], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputSqsMode.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[

cribl_control_plane/models/outputstatsd.py

@@ -1,9 +1,12 @@
 """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
 
@@ -12,14 +15,14 @@ class OutputStatsdType(str, Enum):
     STATSD = "statsd"
 
 
-class OutputStatsdDestinationProtocol(str, Enum):
+class OutputStatsdDestinationProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Protocol to use when communicating with the destination."""
 
     UDP = "udp"
     TCP = "tcp"
 
 
-class OutputStatsdBackpressureBehavior(str, Enum):
+class OutputStatsdBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -27,21 +30,21 @@ class OutputStatsdBackpressureBehavior(str, Enum):
     QUEUE = "queue"
 
 
-class OutputStatsdCompression(str, Enum):
+class OutputStatsdCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputStatsdQueueFullBehavior(str, Enum):
+class OutputStatsdQueueFullBehavior(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 OutputStatsdMode(str, Enum):
+class OutputStatsdMode(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"
@@ -128,9 +131,10 @@ class OutputStatsd(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
-    protocol: Optional[OutputStatsdDestinationProtocol] = (
-        OutputStatsdDestinationProtocol.UDP
-    )
+    protocol: Annotated[
+        Optional[OutputStatsdDestinationProtocol],
+        PlainValidator(validate_open_enum(False)),
+    ] = OutputStatsdDestinationProtocol.UDP
     r"""Protocol to use when communicating with the destination."""
 
     port: Optional[float] = 8125
@@ -167,7 +171,10 @@ class OutputStatsd(BaseModel):
     r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
 
     on_backpressure: Annotated[
-        Optional[OutputStatsdBackpressureBehavior],
+        Annotated[
+            Optional[OutputStatsdBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputStatsdBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -186,19 +193,28 @@ class OutputStatsd(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Optional[OutputStatsdCompression], pydantic.Field(alias="pqCompress")
+        Annotated[
+            Optional[OutputStatsdCompression], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqCompress"),
     ] = OutputStatsdCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputStatsdQueueFullBehavior],
+        Annotated[
+            Optional[OutputStatsdQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputStatsdQueueFullBehavior.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[Optional[OutputStatsdMode], pydantic.Field(alias="pqMode")] = (
-        OutputStatsdMode.ERROR
-    )
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputStatsdMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputStatsdMode.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[

cribl_control_plane/models/outputstatsdext.py

@@ -1,9 +1,12 @@
 """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
 
@@ -12,14 +15,14 @@ class OutputStatsdExtType(str, Enum):
     STATSD_EXT = "statsd_ext"
 
 
-class OutputStatsdExtDestinationProtocol(str, Enum):
+class OutputStatsdExtDestinationProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Protocol to use when communicating with the destination."""
 
     UDP = "udp"
     TCP = "tcp"
 
 
-class OutputStatsdExtBackpressureBehavior(str, Enum):
+class OutputStatsdExtBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -27,21 +30,21 @@ class OutputStatsdExtBackpressureBehavior(str, Enum):
     QUEUE = "queue"
 
 
-class OutputStatsdExtCompression(str, Enum):
+class OutputStatsdExtCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputStatsdExtQueueFullBehavior(str, Enum):
+class OutputStatsdExtQueueFullBehavior(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 OutputStatsdExtMode(str, Enum):
+class OutputStatsdExtMode(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"
@@ -128,9 +131,10 @@ class OutputStatsdExt(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
-    protocol: Optional[OutputStatsdExtDestinationProtocol] = (
-        OutputStatsdExtDestinationProtocol.UDP
-    )
+    protocol: Annotated[
+        Optional[OutputStatsdExtDestinationProtocol],
+        PlainValidator(validate_open_enum(False)),
+    ] = OutputStatsdExtDestinationProtocol.UDP
     r"""Protocol to use when communicating with the destination."""
 
     port: Optional[float] = 8125
@@ -167,7 +171,10 @@ class OutputStatsdExt(BaseModel):
     r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
 
     on_backpressure: Annotated[
-        Optional[OutputStatsdExtBackpressureBehavior],
+        Annotated[
+            Optional[OutputStatsdExtBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputStatsdExtBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -186,18 +193,28 @@ class OutputStatsdExt(BaseModel):
     r"""The location for the persistent queue files. To this field's value, the system will append: /<worker-id>/<output-id>."""
 
     pq_compress: Annotated[
-        Optional[OutputStatsdExtCompression], pydantic.Field(alias="pqCompress")
+        Annotated[
+            Optional[OutputStatsdExtCompression],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="pqCompress"),
     ] = OutputStatsdExtCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Optional[OutputStatsdExtQueueFullBehavior],
+        Annotated[
+            Optional[OutputStatsdExtQueueFullBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputStatsdExtQueueFullBehavior.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[
-        Optional[OutputStatsdExtMode], pydantic.Field(alias="pqMode")
+        Annotated[
+            Optional[OutputStatsdExtMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
     ] = OutputStatsdExtMode.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."""