cribl-control-plane 0.0.50__py3-none-any.whl → 0.0.50rc2__py3-none-any.whl

cribl_control_plane/models/input.py

@@ -66,8 +66,10 @@ from .inputwineventlogs import InputWinEventLogs, InputWinEventLogsTypedDict
 from .inputwiz import InputWiz, InputWizTypedDict
 from .inputwizwebhook import InputWizWebhook, InputWizWebhookTypedDict
 from .inputzscalerhec import InputZscalerHec, InputZscalerHecTypedDict
+from cribl_control_plane.utils import get_discriminator
+from pydantic import Discriminator, Tag
 from typing import Union
-from typing_extensions import TypeAliasType
+from typing_extensions import Annotated, TypeAliasType
 
 
 InputTypedDict = TypeAliasType(
@@ -136,67 +138,67 @@ InputTypedDict = TypeAliasType(
 )
 
 
-Input = TypeAliasType(
-    "Input",
+Input = Annotated[
     Union[
-        InputDatagen,
-        InputKubeEvents,
-        InputCribl,
-        InputCriblmetrics,
-        InputKubeMetrics,
-        InputCollection,
-        InputSystemState,
-        InputModelDrivenTelemetry,
-        InputSystemMetrics,
-        InputWindowsMetrics,
-        InputJournalFiles,
-        InputWinEventLogs,
-        InputRawUDP,
-        InputExec,
-        InputKubeLogs,
-        InputMetrics,
-        InputSnmp,
-        InputCriblTCP,
-        InputNetflow,
-        InputTcpjson,
-        InputGooglePubsub,
-        InputOffice365Service,
-        InputWiz,
-        InputTCP,
-        InputFirehose,
-        InputCriblHTTP,
-        InputDatadogAgent,
-        InputOffice365Mgmt,
-        InputFile,
-        InputSplunk,
-        InputWef,
-        InputAppscope,
-        InputHTTPRaw,
-        InputWizWebhook,
-        InputHTTP,
-        InputCriblLakeHTTP,
-        InputAzureBlob,
-        InputSqs,
-        InputZscalerHec,
-        InputKinesis,
-        InputConfluentCloud,
-        InputEventhub,
-        InputKafka,
-        InputElastic,
-        InputOffice365MsgTrace,
-        InputSplunkHec,
-        InputLoki,
-        InputPrometheusRw,
-        InputPrometheus,
-        InputCrowdstrike,
-        InputEdgePrometheus,
-        InputOpenTelemetry,
-        InputS3,
-        InputSecurityLake,
-        InputMsk,
-        InputS3Inventory,
-        InputSplunkSearch,
-        InputSyslog,
-        InputGrafana,
+        Annotated[InputCollection, Tag("collection")],
+        Annotated[InputKafka, Tag("kafka")],
+        Annotated[InputMsk, Tag("msk")],
+        Annotated[InputHTTP, Tag("http")],
+        Annotated[InputSplunk, Tag("splunk")],
+        Annotated[InputSplunkSearch, Tag("splunk_search")],
+        Annotated[InputSplunkHec, Tag("splunk_hec")],
+        Annotated[InputAzureBlob, Tag("azure_blob")],
+        Annotated[InputElastic, Tag("elastic")],
+        Annotated[InputConfluentCloud, Tag("confluent_cloud")],
+        Annotated[InputGrafana, Tag("grafana")],
+        Annotated[InputLoki, Tag("loki")],
+        Annotated[InputPrometheusRw, Tag("prometheus_rw")],
+        Annotated[InputPrometheus, Tag("prometheus")],
+        Annotated[InputEdgePrometheus, Tag("edge_prometheus")],
+        Annotated[InputOffice365Mgmt, Tag("office365_mgmt")],
+        Annotated[InputOffice365Service, Tag("office365_service")],
+        Annotated[InputOffice365MsgTrace, Tag("office365_msg_trace")],
+        Annotated[InputEventhub, Tag("eventhub")],
+        Annotated[InputExec, Tag("exec")],
+        Annotated[InputFirehose, Tag("firehose")],
+        Annotated[InputGooglePubsub, Tag("google_pubsub")],
+        Annotated[InputCribl, Tag("cribl")],
+        Annotated[InputCriblTCP, Tag("cribl_tcp")],
+        Annotated[InputCriblHTTP, Tag("cribl_http")],
+        Annotated[InputCriblLakeHTTP, Tag("cribl_lake_http")],
+        Annotated[InputTcpjson, Tag("tcpjson")],
+        Annotated[InputSystemMetrics, Tag("system_metrics")],
+        Annotated[InputSystemState, Tag("system_state")],
+        Annotated[InputKubeMetrics, Tag("kube_metrics")],
+        Annotated[InputKubeLogs, Tag("kube_logs")],
+        Annotated[InputKubeEvents, Tag("kube_events")],
+        Annotated[InputWindowsMetrics, Tag("windows_metrics")],
+        Annotated[InputCrowdstrike, Tag("crowdstrike")],
+        Annotated[InputDatadogAgent, Tag("datadog_agent")],
+        Annotated[InputDatagen, Tag("datagen")],
+        Annotated[InputHTTPRaw, Tag("http_raw")],
+        Annotated[InputKinesis, Tag("kinesis")],
+        Annotated[InputCriblmetrics, Tag("criblmetrics")],
+        Annotated[InputMetrics, Tag("metrics")],
+        Annotated[InputS3, Tag("s3")],
+        Annotated[InputS3Inventory, Tag("s3_inventory")],
+        Annotated[InputSnmp, Tag("snmp")],
+        Annotated[InputOpenTelemetry, Tag("open_telemetry")],
+        Annotated[InputModelDrivenTelemetry, Tag("model_driven_telemetry")],
+        Annotated[InputSqs, Tag("sqs")],
+        Annotated[InputSyslog, Tag("syslog")],
+        Annotated[InputFile, Tag("file")],
+        Annotated[InputTCP, Tag("tcp")],
+        Annotated[InputAppscope, Tag("appscope")],
+        Annotated[InputWef, Tag("wef")],
+        Annotated[InputWinEventLogs, Tag("win_event_logs")],
+        Annotated[InputRawUDP, Tag("raw_udp")],
+        Annotated[InputJournalFiles, Tag("journal_files")],
+        Annotated[InputWiz, Tag("wiz")],
+        Annotated[InputWizWebhook, Tag("wiz_webhook")],
+        Annotated[InputNetflow, Tag("netflow")],
+        Annotated[InputSecurityLake, Tag("security_lake")],
+        Annotated[InputZscalerHec, Tag("zscaler_hec")],
     ],
-)
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]

cribl_control_plane/models/inputappscope.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 Any, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -23,14 +26,14 @@ class InputAppscopeConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputAppscopeMode(str, Enum):
+class InputAppscopeMode(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 InputAppscopeCompression(str, Enum):
+class InputAppscopeCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
@@ -64,7 +67,9 @@ class InputAppscopePqTypedDict(TypedDict):
 
 
 class InputAppscopePq(BaseModel):
-    mode: Optional[InputAppscopeMode] = InputAppscopeMode.ALWAYS
+    mode: Annotated[
+        Optional[InputAppscopeMode], PlainValidator(validate_open_enum(False))
+    ] = InputAppscopeMode.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[
@@ -88,7 +93,9 @@ class InputAppscopePq(BaseModel):
     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: Optional[InputAppscopeCompression] = InputAppscopeCompression.NONE
+    compress: Annotated[
+        Optional[InputAppscopeCompression], PlainValidator(validate_open_enum(False))
+    ] = InputAppscopeCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_controls: Annotated[
@@ -144,7 +151,7 @@ class InputAppscopeFilter(BaseModel):
     r"""To override the UNIX domain socket or address/port specified in General Settings (while leaving Authentication settings as is), enter a URL."""
 
 
-class InputAppscopeDataCompressionFormat(str, Enum):
+class InputAppscopeDataCompressionFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     NONE = "none"
     GZIP = "gzip"
 
@@ -176,9 +183,10 @@ class InputAppscopePersistence(BaseModel):
     max_data_time: Annotated[Optional[str], pydantic.Field(alias="maxDataTime")] = "24h"
     r"""Maximum amount of time to retain data (examples: 2h, 4d). When limit is reached, older data will be deleted."""
 
-    compress: Optional[InputAppscopeDataCompressionFormat] = (
-        InputAppscopeDataCompressionFormat.GZIP
-    )
+    compress: Annotated[
+        Optional[InputAppscopeDataCompressionFormat],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputAppscopeDataCompressionFormat.GZIP
 
     dest_path: Annotated[Optional[str], pydantic.Field(alias="destPath")] = (
         "$CRIBL_HOME/state/appscope"
@@ -186,21 +194,21 @@ class InputAppscopePersistence(BaseModel):
     r"""Path to use to write metrics. Defaults to $CRIBL_HOME/state/appscope"""
 
 
-class InputAppscopeAuthenticationMethod(str, Enum):
+class InputAppscopeAuthenticationMethod(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 InputAppscopeMinimumTLSVersion(str, Enum):
+class InputAppscopeMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputAppscopeMaximumTLSVersion(str, Enum):
+class InputAppscopeMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -259,11 +267,19 @@ class InputAppscopeTLSSettingsServerSide(BaseModel):
     ] = None
 
     min_version: Annotated[
-        Optional[InputAppscopeMinimumTLSVersion], pydantic.Field(alias="minVersion")
+        Annotated[
+            Optional[InputAppscopeMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputAppscopeMaximumTLSVersion], pydantic.Field(alias="maxVersion")
+        Annotated[
+            Optional[InputAppscopeMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="maxVersion"),
     ] = None
 
 
@@ -410,7 +426,11 @@ class InputAppscope(BaseModel):
     persistence: Optional[InputAppscopePersistence] = None
 
     auth_type: Annotated[
-        Optional[InputAppscopeAuthenticationMethod], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[InputAppscopeAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = InputAppscopeAuthenticationMethod.MANUAL
     r"""Select Manual to enter an auth token directly, or select Secret to use a text secret to authenticate"""
 

cribl_control_plane/models/inputazureblob.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
 
@@ -23,14 +26,14 @@ class InputAzureBlobConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputAzureBlobMode(str, Enum):
+class InputAzureBlobMode(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 InputAzureBlobCompression(str, Enum):
+class InputAzureBlobCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
@@ -64,7 +67,9 @@ class InputAzureBlobPqTypedDict(TypedDict):
 
 
 class InputAzureBlobPq(BaseModel):
-    mode: Optional[InputAzureBlobMode] = InputAzureBlobMode.ALWAYS
+    mode: Annotated[
+        Optional[InputAzureBlobMode], PlainValidator(validate_open_enum(False))
+    ] = InputAzureBlobMode.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[
@@ -88,7 +93,9 @@ class InputAzureBlobPq(BaseModel):
     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: Optional[InputAzureBlobCompression] = InputAzureBlobCompression.NONE
+    compress: Annotated[
+        Optional[InputAzureBlobCompression], PlainValidator(validate_open_enum(False))
+    ] = InputAzureBlobCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_controls: Annotated[
@@ -109,7 +116,7 @@ class InputAzureBlobMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
-class InputAzureBlobAuthenticationMethod(str, Enum):
+class InputAzureBlobAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     MANUAL = "manual"
     SECRET = "secret"
     CLIENT_SECRET = "clientSecret"
@@ -270,7 +277,11 @@ class InputAzureBlob(BaseModel):
     r"""The maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified."""
 
     auth_type: Annotated[
-        Optional[InputAzureBlobAuthenticationMethod], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[InputAzureBlobAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = InputAzureBlobAuthenticationMethod.MANUAL
 
     description: Optional[str] = None

cribl_control_plane/models/inputcollection.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
 
@@ -23,14 +26,14 @@ class InputCollectionConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputCollectionMode(str, Enum):
+class InputCollectionMode(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 InputCollectionCompression(str, Enum):
+class InputCollectionCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
@@ -64,7 +67,9 @@ class InputCollectionPqTypedDict(TypedDict):
 
 
 class InputCollectionPq(BaseModel):
-    mode: Optional[InputCollectionMode] = InputCollectionMode.ALWAYS
+    mode: Annotated[
+        Optional[InputCollectionMode], PlainValidator(validate_open_enum(False))
+    ] = InputCollectionMode.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[
@@ -88,7 +93,9 @@ class InputCollectionPq(BaseModel):
     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: Optional[InputCollectionCompression] = InputCollectionCompression.NONE
+    compress: Annotated[
+        Optional[InputCollectionCompression], PlainValidator(validate_open_enum(False))
+    ] = InputCollectionCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_controls: Annotated[

cribl_control_plane/models/inputconfluentcloud.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
 
@@ -23,14 +26,14 @@ class InputConfluentCloudConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputConfluentCloudMode(str, Enum):
+class InputConfluentCloudMode(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 InputConfluentCloudCompression(str, Enum):
+class InputConfluentCloudCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
@@ -64,7 +67,9 @@ class InputConfluentCloudPqTypedDict(TypedDict):
 
 
 class InputConfluentCloudPq(BaseModel):
-    mode: Optional[InputConfluentCloudMode] = InputConfluentCloudMode.ALWAYS
+    mode: Annotated[
+        Optional[InputConfluentCloudMode], PlainValidator(validate_open_enum(False))
+    ] = InputConfluentCloudMode.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[
@@ -88,9 +93,10 @@ class InputConfluentCloudPq(BaseModel):
     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: Optional[InputConfluentCloudCompression] = (
-        InputConfluentCloudCompression.NONE
-    )
+    compress: Annotated[
+        Optional[InputConfluentCloudCompression],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputConfluentCloudCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_controls: Annotated[
@@ -98,14 +104,14 @@ class InputConfluentCloudPq(BaseModel):
     ] = None
 
 
-class InputConfluentCloudMinimumTLSVersion(str, Enum):
+class InputConfluentCloudMinimumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputConfluentCloudMaximumTLSVersion(str, Enum):
+class InputConfluentCloudMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -165,23 +171,22 @@ class InputConfluentCloudTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Optional[InputConfluentCloudMinimumTLSVersion],
+        Annotated[
+            Optional[InputConfluentCloudMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputConfluentCloudMaximumTLSVersion],
+        Annotated[
+            Optional[InputConfluentCloudMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="maxVersion"),
     ] = None
 
 
-class InputConfluentCloudSchemaType(str, Enum):
-    r"""The schema format used to encode and decode event data"""
-
-    AVRO = "avro"
-    JSON = "json"
-
-
 class InputConfluentCloudAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
 
@@ -201,14 +206,18 @@ class InputConfluentCloudAuth(BaseModel):
     r"""Select or create a secret that references your credentials"""
 
 
-class InputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion(str, Enum):
+class InputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
     TL_SV1_3 = "TLSv1.3"
 
 
-class InputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion(str, Enum):
+class InputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
     TL_SV1 = "TLSv1"
     TL_SV1_1 = "TLSv1.1"
     TL_SV1_2 = "TLSv1.2"
@@ -268,12 +277,18 @@ class InputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide(BaseModel):
     r"""Passphrase to use to decrypt private key"""
 
     min_version: Annotated[
-        Optional[InputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion],
+        Annotated[
+            Optional[InputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="minVersion"),
     ] = None
 
     max_version: Annotated[
-        Optional[InputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion],
+        Annotated[
+            Optional[InputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="maxVersion"),
     ] = None
 
@@ -282,8 +297,6 @@ class InputConfluentCloudKafkaSchemaRegistryAuthenticationTypedDict(TypedDict):
     disabled: NotRequired[bool]
     schema_registry_url: NotRequired[str]
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
-    schema_type: NotRequired[InputConfluentCloudSchemaType]
-    r"""The schema format used to encode and decode event data"""
     connection_timeout: NotRequired[float]
     r"""Maximum time to wait for a Schema Registry connection to complete successfully"""
     request_timeout: NotRequired[float]
@@ -305,11 +318,6 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     ] = "http://localhost:8081"
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
 
-    schema_type: Annotated[
-        Optional[InputConfluentCloudSchemaType], pydantic.Field(alias="schemaType")
-    ] = InputConfluentCloudSchemaType.AVRO
-    r"""The schema format used to encode and decode event data"""
-
     connection_timeout: Annotated[
         Optional[float], pydantic.Field(alias="connectionTimeout")
     ] = 30000
@@ -329,7 +337,7 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     tls: Optional[InputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide] = None
 
 
-class InputConfluentCloudSASLMechanism(str, Enum):
+class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     PLAIN = "plain"
     SCRAM_SHA_256 = "scram-sha-256"
     SCRAM_SHA_512 = "scram-sha-512"
@@ -350,9 +358,10 @@ class InputConfluentCloudAuthentication(BaseModel):
 
     disabled: Optional[bool] = True
 
-    mechanism: Optional[InputConfluentCloudSASLMechanism] = (
-        InputConfluentCloudSASLMechanism.PLAIN
-    )
+    mechanism: Annotated[
+        Optional[InputConfluentCloudSASLMechanism],
+        PlainValidator(validate_open_enum(False)),
+    ] = InputConfluentCloudSASLMechanism.PLAIN
 
     oauth_enabled: Annotated[Optional[bool], pydantic.Field(alias="oauthEnabled")] = (
         False

cribl_control_plane/models/inputcribl.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
 
@@ -23,14 +26,14 @@ class InputCriblConnection(BaseModel):
     pipeline: Optional[str] = None
 
 
-class InputCriblMode(str, Enum):
+class InputCriblMode(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 InputCriblCompression(str, Enum):
+class InputCriblCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
     NONE = "none"
@@ -64,7 +67,9 @@ class InputCriblPqTypedDict(TypedDict):
 
 
 class InputCriblPq(BaseModel):
-    mode: Optional[InputCriblMode] = InputCriblMode.ALWAYS
+    mode: Annotated[
+        Optional[InputCriblMode], PlainValidator(validate_open_enum(False))
+    ] = InputCriblMode.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[
@@ -88,7 +93,9 @@ class InputCriblPq(BaseModel):
     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: Optional[InputCriblCompression] = InputCriblCompression.NONE
+    compress: Annotated[
+        Optional[InputCriblCompression], PlainValidator(validate_open_enum(False))
+    ] = InputCriblCompression.NONE
     r"""Codec to use to compress the persisted data"""
 
     pq_controls: Annotated[