cribl-control-plane 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

cribl_control_plane/models/outputsqs.py

@@ -1,28 +1,25 @@
 """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 OutputSqsType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsType(str, Enum):
     SQS = "sqs"
 
 
-class OutputSqsQueueType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsQueueType(str, Enum):
     r"""The queue type used (or created). Defaults to Standard."""
 
     STANDARD = "standard"
     FIFO = "fifo"
 
 
-class OutputSqsAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsAuthenticationMethod(str, Enum):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
     AUTO = "auto"
@@ -30,14 +27,14 @@ class OutputSqsAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     SECRET = "secret"
 
 
-class OutputSqsSignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsSignatureVersion(str, Enum):
     r"""Signature version to use for signing SQS requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputSqsBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -45,21 +42,21 @@ class OutputSqsBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     QUEUE = "queue"
 
 
-class OutputSqsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputSqsQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSqsQueueFullBehavior(str, Enum):
     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, metaclass=utils.OpenEnumMeta):
+class OutputSqsMode(str, Enum):
     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"
@@ -154,9 +151,7 @@ class OutputSqs(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputSqsType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputSqsType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -173,10 +168,7 @@ class OutputSqs(BaseModel):
     r"""Tags for filtering and grouping in @{product}"""
 
     queue_type: Annotated[
-        Annotated[
-            Optional[OutputSqsQueueType], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="queueType"),
+        Optional[OutputSqsQueueType], pydantic.Field(alias="queueType")
     ] = OutputSqsQueueType.STANDARD
     r"""The queue type used (or created). Defaults to Standard."""
 
@@ -194,10 +186,7 @@ class OutputSqs(BaseModel):
     r"""Create queue if it does not exist."""
 
     aws_authentication_method: Annotated[
-        Annotated[
-            Optional[OutputSqsAuthenticationMethod],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputSqsAuthenticationMethod],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputSqsAuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -213,11 +202,7 @@ 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[
-        Annotated[
-            Optional[OutputSqsSignatureVersion],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="signatureVersion"),
+        Optional[OutputSqsSignatureVersion], pydantic.Field(alias="signatureVersion")
     ] = OutputSqsSignatureVersion.V4
     r"""Signature version to use for signing SQS requests"""
 
@@ -272,11 +257,7 @@ class OutputSqs(BaseModel):
     r"""The maximum number of in-progress API requests before backpressure is applied."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputSqsBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="onBackpressure"),
+        Optional[OutputSqsBackpressureBehavior], pydantic.Field(alias="onBackpressure")
     ] = OutputSqsBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -301,26 +282,18 @@ 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[
-        Annotated[
-            Optional[OutputSqsCompression], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputSqsCompression], pydantic.Field(alias="pqCompress")
     ] = OutputSqsCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputSqsQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqOnBackpressure"),
+        Optional[OutputSqsQueueFullBehavior], 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[
-        Annotated[Optional[OutputSqsMode], PlainValidator(validate_open_enum(False))],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputSqsMode.ERROR
+    pq_mode: Annotated[Optional[OutputSqsMode], 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,28 +1,25 @@
 """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 OutputStatsdType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdType(str, Enum):
     STATSD = "statsd"
 
 
-class OutputStatsdDestinationProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdDestinationProtocol(str, Enum):
     r"""Protocol to use when communicating with the destination."""
 
     UDP = "udp"
     TCP = "tcp"
 
 
-class OutputStatsdBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -30,21 +27,21 @@ class OutputStatsdBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     QUEUE = "queue"
 
 
-class OutputStatsdCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputStatsdQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdQueueFullBehavior(str, Enum):
     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, metaclass=utils.OpenEnumMeta):
+class OutputStatsdMode(str, Enum):
     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"
@@ -115,9 +112,7 @@ class OutputStatsd(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputStatsdType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputStatsdType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -133,10 +128,9 @@ class OutputStatsd(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
-    protocol: Annotated[
-        Optional[OutputStatsdDestinationProtocol],
-        PlainValidator(validate_open_enum(False)),
-    ] = OutputStatsdDestinationProtocol.UDP
+    protocol: Optional[OutputStatsdDestinationProtocol] = (
+        OutputStatsdDestinationProtocol.UDP
+    )
     r"""Protocol to use when communicating with the destination."""
 
     port: Optional[float] = 8125
@@ -173,10 +167,7 @@ class OutputStatsd(BaseModel):
     r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputStatsdBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputStatsdBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputStatsdBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -195,28 +186,19 @@ 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[
-        Annotated[
-            Optional[OutputStatsdCompression], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputStatsdCompression], pydantic.Field(alias="pqCompress")
     ] = OutputStatsdCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputStatsdQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputStatsdQueueFullBehavior],
         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[
-        Annotated[
-            Optional[OutputStatsdMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputStatsdMode.ERROR
+    pq_mode: Annotated[Optional[OutputStatsdMode], 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,28 +1,25 @@
 """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 OutputStatsdExtType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtType(str, Enum):
     STATSD_EXT = "statsd_ext"
 
 
-class OutputStatsdExtDestinationProtocol(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtDestinationProtocol(str, Enum):
     r"""Protocol to use when communicating with the destination."""
 
     UDP = "udp"
     TCP = "tcp"
 
 
-class OutputStatsdExtBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -30,21 +27,21 @@ class OutputStatsdExtBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMet
     QUEUE = "queue"
 
 
-class OutputStatsdExtCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputStatsdExtQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtQueueFullBehavior(str, Enum):
     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, metaclass=utils.OpenEnumMeta):
+class OutputStatsdExtMode(str, Enum):
     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"
@@ -115,9 +112,7 @@ class OutputStatsdExt(BaseModel):
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Annotated[
-        Optional[OutputStatsdExtType], PlainValidator(validate_open_enum(False))
-    ] = None
+    type: Optional[OutputStatsdExtType] = None
 
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
@@ -133,10 +128,9 @@ class OutputStatsdExt(BaseModel):
     streamtags: Optional[List[str]] = None
     r"""Tags for filtering and grouping in @{product}"""
 
-    protocol: Annotated[
-        Optional[OutputStatsdExtDestinationProtocol],
-        PlainValidator(validate_open_enum(False)),
-    ] = OutputStatsdExtDestinationProtocol.UDP
+    protocol: Optional[OutputStatsdExtDestinationProtocol] = (
+        OutputStatsdExtDestinationProtocol.UDP
+    )
     r"""Protocol to use when communicating with the destination."""
 
     port: Optional[float] = 8125
@@ -173,10 +167,7 @@ class OutputStatsdExt(BaseModel):
     r"""Amount of time (milliseconds) to wait for a write to complete before assuming connection is dead"""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputStatsdExtBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputStatsdExtBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputStatsdExtBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -195,28 +186,18 @@ 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[
-        Annotated[
-            Optional[OutputStatsdExtCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputStatsdExtCompression], pydantic.Field(alias="pqCompress")
     ] = OutputStatsdExtCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputStatsdExtQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputStatsdExtQueueFullBehavior],
         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[
-        Annotated[
-            Optional[OutputStatsdExtMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputStatsdExtMode], 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."""
 

cribl_control_plane/models/outputsumologic.py

@@ -1,21 +1,18 @@
 """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 OutputSumoLogicType(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicType(str, Enum):
     SUMO_LOGIC = "sumo_logic"
 
 
-class OutputSumoLogicDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicDataFormat(str, Enum):
     r"""Preserve the raw event format instead of JSONifying it"""
 
     JSON = "json"
@@ -33,7 +30,7 @@ class OutputSumoLogicExtraHTTPHeader(BaseModel):
     name: Optional[str] = None
 
 
-class OutputSumoLogicFailedRequestLoggingMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicFailedRequestLoggingMode(str, Enum):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
     PAYLOAD = "payload"
@@ -95,7 +92,7 @@ class OutputSumoLogicTimeoutRetrySettings(BaseModel):
     r"""The maximum backoff interval, in milliseconds, Cribl Stream should apply. Default (and minimum) is 10,000 ms (10 seconds); maximum is 180,000 ms (180 seconds)."""
 
 
-class OutputSumoLogicBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicBackpressureBehavior(str, Enum):
     r"""How to handle events when all receivers are exerting backpressure"""
 
     BLOCK = "block"
@@ -103,21 +100,21 @@ class OutputSumoLogicBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMet
     QUEUE = "queue"
 
 
-class OutputSumoLogicCompression(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicCompression(str, Enum):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputSumoLogicQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicQueueFullBehavior(str, Enum):
     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 OutputSumoLogicMode(str, Enum, metaclass=utils.OpenEnumMeta):
+class OutputSumoLogicMode(str, Enum):
     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"
@@ -206,7 +203,7 @@ class OutputSumoLogicTypedDict(TypedDict):
 
 
 class OutputSumoLogic(BaseModel):
-    type: Annotated[OutputSumoLogicType, PlainValidator(validate_open_enum(False))]
+    type: OutputSumoLogicType
 
     url: str
     r"""Sumo Logic HTTP collector URL to which events should be sent"""
@@ -237,11 +234,7 @@ class OutputSumoLogic(BaseModel):
     r"""Override the source category configured on the Sumo Logic HTTP collector. This can also be overridden at the event level with the __sourceCategory field."""
 
     format_: Annotated[
-        Annotated[
-            Optional[OutputSumoLogicDataFormat],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="format"),
+        Optional[OutputSumoLogicDataFormat], pydantic.Field(alias="format")
     ] = OutputSumoLogicDataFormat.JSON
     r"""Preserve the raw event format instead of JSONifying it"""
 
@@ -289,10 +282,7 @@ class OutputSumoLogic(BaseModel):
     r"""Enable round-robin DNS lookup. When a DNS server returns multiple addresses, @{product} will cycle through them in the order returned. For optimal performance, consider enabling this setting for non-load balanced destinations."""
 
     failed_request_logging_mode: Annotated[
-        Annotated[
-            Optional[OutputSumoLogicFailedRequestLoggingMode],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputSumoLogicFailedRequestLoggingMode],
         pydantic.Field(alias="failedRequestLoggingMode"),
     ] = OutputSumoLogicFailedRequestLoggingMode.NONE
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
@@ -319,10 +309,7 @@ class OutputSumoLogic(BaseModel):
     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."""
 
     on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputSumoLogicBackpressureBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputSumoLogicBackpressureBehavior],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputSumoLogicBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -348,28 +335,18 @@ class OutputSumoLogic(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[
-        Annotated[
-            Optional[OutputSumoLogicCompression],
-            PlainValidator(validate_open_enum(False)),
-        ],
-        pydantic.Field(alias="pqCompress"),
+        Optional[OutputSumoLogicCompression], pydantic.Field(alias="pqCompress")
     ] = OutputSumoLogicCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_on_backpressure: Annotated[
-        Annotated[
-            Optional[OutputSumoLogicQueueFullBehavior],
-            PlainValidator(validate_open_enum(False)),
-        ],
+        Optional[OutputSumoLogicQueueFullBehavior],
         pydantic.Field(alias="pqOnBackpressure"),
     ] = OutputSumoLogicQueueFullBehavior.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[OutputSumoLogicMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
+        Optional[OutputSumoLogicMode], pydantic.Field(alias="pqMode")
     ] = OutputSumoLogicMode.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."""