cribl-control-plane 0.0.39__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

cribl_control_plane/models/groupcreaterequest.py

@@ -0,0 +1,175 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .commit import Commit, CommitTypedDict
+from .configgroupcloud import ConfigGroupCloud, ConfigGroupCloudTypedDict
+from .configgrouplookups import ConfigGroupLookups, ConfigGroupLookupsTypedDict
+from cribl_control_plane import models, 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 import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class GroupCreateRequestEstimatedIngestRate(int, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
+
+    # 12 MB/sec
+    RATE12_MB_PER_SEC = 1024
+    # 24 MB/sec
+    RATE24_MB_PER_SEC = 2048
+    # 36 MB/sec
+    RATE36_MB_PER_SEC = 3072
+    # 48 MB/sec
+    RATE48_MB_PER_SEC = 4096
+    # 60 MB/sec
+    RATE60_MB_PER_SEC = 5120
+    # 84 MB/sec
+    RATE84_MB_PER_SEC = 7168
+    # 120 MB/sec
+    RATE120_MB_PER_SEC = 10240
+    # 156 MB/sec
+    RATE156_MB_PER_SEC = 13312
+    # 180 MB/sec
+    RATE180_MB_PER_SEC = 15360
+
+
+class GroupCreateRequestGitTypedDict(TypedDict):
+    commit: NotRequired[str]
+    local_changes: NotRequired[float]
+    log: NotRequired[List[CommitTypedDict]]
+
+
+class GroupCreateRequestGit(BaseModel):
+    commit: Optional[str] = None
+
+    local_changes: Annotated[Optional[float], pydantic.Field(alias="localChanges")] = (
+        None
+    )
+
+    log: Optional[List[Commit]] = None
+
+
+class GroupCreateRequestType(str, Enum, metaclass=utils.OpenEnumMeta):
+    EDGE = "edge"
+    STREAM = "stream"
+    SEARCH = "search"
+    LAKE_ACCESS = "lake_access"
+    LOCAL_SEARCH = "local_search"
+
+
+class GroupCreateRequestTypedDict(TypedDict):
+    id: str
+    cloud: NotRequired[ConfigGroupCloudTypedDict]
+    deploying_worker_count: NotRequired[float]
+    description: NotRequired[str]
+    estimated_ingest_rate: NotRequired[GroupCreateRequestEstimatedIngestRate]
+    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
+    git: NotRequired[GroupCreateRequestGitTypedDict]
+    incompatible_worker_count: NotRequired[float]
+    inherits: NotRequired[str]
+    is_fleet: NotRequired[bool]
+    is_search: NotRequired[bool]
+    lookup_deployments: NotRequired[List[ConfigGroupLookupsTypedDict]]
+    max_worker_age: NotRequired[str]
+    name: NotRequired[str]
+    on_prem: NotRequired[bool]
+    provisioned: NotRequired[bool]
+    source_group_id: NotRequired[str]
+    streamtags: NotRequired[List[str]]
+    tags: NotRequired[str]
+    type: NotRequired[GroupCreateRequestType]
+    upgrade_version: NotRequired[str]
+    worker_count: NotRequired[float]
+    worker_remote_access: NotRequired[bool]
+
+
+class GroupCreateRequest(BaseModel):
+    id: str
+
+    cloud: Optional[ConfigGroupCloud] = None
+
+    deploying_worker_count: Annotated[
+        Optional[float], pydantic.Field(alias="deployingWorkerCount")
+    ] = None
+
+    description: Optional[str] = None
+
+    estimated_ingest_rate: Annotated[
+        Annotated[
+            Optional[GroupCreateRequestEstimatedIngestRate],
+            PlainValidator(validate_open_enum(True)),
+        ],
+        pydantic.Field(alias="estimatedIngestRate"),
+    ] = None
+    r"""Maximum expected volume of data ingested by the @{group}. (This setting is available only on @{group}s consisting of Cribl-managed Cribl.Cloud @{node}s.)"""
+
+    git: Optional[GroupCreateRequestGit] = None
+
+    incompatible_worker_count: Annotated[
+        Optional[float], pydantic.Field(alias="incompatibleWorkerCount")
+    ] = None
+
+    inherits: Optional[str] = None
+
+    is_fleet: Annotated[Optional[bool], pydantic.Field(alias="isFleet")] = None
+
+    is_search: Annotated[Optional[bool], pydantic.Field(alias="isSearch")] = None
+
+    lookup_deployments: Annotated[
+        Optional[List[ConfigGroupLookups]], pydantic.Field(alias="lookupDeployments")
+    ] = None
+
+    max_worker_age: Annotated[Optional[str], pydantic.Field(alias="maxWorkerAge")] = (
+        None
+    )
+
+    name: Optional[str] = None
+
+    on_prem: Annotated[Optional[bool], pydantic.Field(alias="onPrem")] = None
+
+    provisioned: Optional[bool] = None
+
+    source_group_id: Annotated[Optional[str], pydantic.Field(alias="sourceGroupId")] = (
+        None
+    )
+
+    streamtags: Optional[List[str]] = None
+
+    tags: Optional[str] = None
+
+    type: Annotated[
+        Optional[GroupCreateRequestType], PlainValidator(validate_open_enum(False))
+    ] = None
+
+    upgrade_version: Annotated[
+        Optional[str], pydantic.Field(alias="upgradeVersion")
+    ] = None
+
+    worker_count: Annotated[Optional[float], pydantic.Field(alias="workerCount")] = None
+
+    worker_remote_access: Annotated[
+        Optional[bool], pydantic.Field(alias="workerRemoteAccess")
+    ] = None
+
+    @field_serializer("estimated_ingest_rate")
+    def serialize_estimated_ingest_rate(self, value):
+        if isinstance(value, str):
+            try:
+                return models.GroupCreateRequestEstimatedIngestRate(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.GroupCreateRequestType(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/hbcriblinfo.py

@@ -1,12 +1,15 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .appmode import AppMode
 from .hbleaderinfo import HBLeaderInfo, HBLeaderInfoTypedDict
-from .lookupversions import LookupVersions, LookupVersionsTypedDict
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
+from enum import Enum
 import pydantic
-from typing import List, Optional
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import Dict, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -34,26 +37,41 @@ class Config(BaseModel):
     version: Optional[str] = None
 
 
+class DistMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    SINGLE = "single"
+    MASTER = "master"
+    WORKER = "worker"
+    EDGE = "edge"
+    MANAGED_EDGE = "managed-edge"
+    OUTPOST = "outpost"
+    SEARCH_SUPERVISOR = "search-supervisor"
+
+
 class HBCriblInfoTypedDict(TypedDict):
     config: ConfigTypedDict
-    dist_mode: AppMode
+    dist_mode: DistMode
     group: str
     guid: str
     start_time: float
     tags: List[str]
     deployment_id: NotRequired[str]
+    disable_sni_routing: NotRequired[bool]
     edge_nodes: NotRequired[float]
     install_type: NotRequired[str]
-    lookup_versions: NotRequired[LookupVersionsTypedDict]
+    lookup_versions: NotRequired[Dict[str, Dict[str, str]]]
     master: NotRequired[HBLeaderInfoTypedDict]
     pid: NotRequired[float]
+    socks_enabled: NotRequired[bool]
     version: NotRequired[str]
 
 
 class HBCriblInfo(BaseModel):
     config: Config
 
-    dist_mode: Annotated[AppMode, pydantic.Field(alias="distMode")]
+    dist_mode: Annotated[
+        Annotated[DistMode, PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="distMode"),
+    ]
 
     group: str
 
@@ -65,16 +83,33 @@ class HBCriblInfo(BaseModel):
 
     deployment_id: Annotated[Optional[str], pydantic.Field(alias="deploymentId")] = None
 
+    disable_sni_routing: Annotated[
+        Optional[bool], pydantic.Field(alias="disableSNIRouting")
+    ] = None
+
     edge_nodes: Annotated[Optional[float], pydantic.Field(alias="edgeNodes")] = None
 
     install_type: Annotated[Optional[str], pydantic.Field(alias="installType")] = None
 
     lookup_versions: Annotated[
-        Optional[LookupVersions], pydantic.Field(alias="lookupVersions")
+        Optional[Dict[str, Dict[str, str]]], pydantic.Field(alias="lookupVersions")
     ] = None
 
     master: Optional[HBLeaderInfo] = None
 
     pid: Optional[float] = None
 
+    socks_enabled: Annotated[Optional[bool], pydantic.Field(alias="socksEnabled")] = (
+        None
+    )
+
     version: Optional[str] = None
+
+    @field_serializer("dist_mode")
+    def serialize_dist_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.DistMode(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/healthserverstatus.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane import models, 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 import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class Role(str, Enum, metaclass=utils.OpenEnumMeta):
+    STANDBY = "standby"
+    PRIMARY = "primary"
+
+
+class Status(str, Enum, metaclass=utils.OpenEnumMeta):
+    SHUTTING_DOWN = "shutting down"
+    HEALTHY = "healthy"
+    STANDBY = "standby"
+
+
+class HealthServerStatusTypedDict(TypedDict):
+    start_time: float
+    status: Status
+    role: NotRequired[Role]
+
+
+class HealthServerStatus(BaseModel):
+    start_time: Annotated[float, pydantic.Field(alias="startTime")]
+
+    status: Annotated[Status, PlainValidator(validate_open_enum(False))]
+
+    role: Annotated[Optional[Role], PlainValidator(validate_open_enum(False))] = None
+
+    @field_serializer("role")
+    def serialize_role(self, value):
+        if isinstance(value, str):
+            try:
+                return models.Role(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("status")
+    def serialize_status(self, value):
+        if isinstance(value, str):
+            try:
+                return models.Status(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/heartbeatmetadata.py

@@ -3,36 +3,70 @@
 from __future__ import annotations
 from cribl_control_plane.types import BaseModel
 import pydantic
-from typing import List, Optional
+from typing import Dict, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class HeartbeatMetadataTagsTypedDict(TypedDict):
-    pass
-
-
-class HeartbeatMetadataTags(BaseModel):
-    pass
-
-
 class HeartbeatMetadataAwsTypedDict(TypedDict):
     enabled: bool
+    instance_id: str
     region: str
     type: str
     zone: str
-    tags: NotRequired[HeartbeatMetadataTagsTypedDict]
+    tags: NotRequired[Dict[str, str]]
 
 
 class HeartbeatMetadataAws(BaseModel):
     enabled: bool
 
+    instance_id: Annotated[str, pydantic.Field(alias="instanceId")]
+
     region: str
 
     type: str
 
     zone: str
 
-    tags: Optional[HeartbeatMetadataTags] = None
+    tags: Optional[Dict[str, str]] = None
+
+
+class HeartbeatMetadataAzureTypedDict(TypedDict):
+    enabled: bool
+    hostname: NotRequired[str]
+    instance_id: NotRequired[str]
+    name: NotRequired[str]
+    region: NotRequired[str]
+    resource_group: NotRequired[str]
+    subscription_id: NotRequired[str]
+    tags: NotRequired[Dict[str, str]]
+    type: NotRequired[str]
+    zone: NotRequired[str]
+
+
+class HeartbeatMetadataAzure(BaseModel):
+    enabled: bool
+
+    hostname: Optional[str] = None
+
+    instance_id: Annotated[Optional[str], pydantic.Field(alias="instanceId")] = None
+
+    name: Optional[str] = None
+
+    region: Optional[str] = None
+
+    resource_group: Annotated[Optional[str], pydantic.Field(alias="resourceGroup")] = (
+        None
+    )
+
+    subscription_id: Annotated[
+        Optional[str], pydantic.Field(alias="subscriptionId")
+    ] = None
+
+    tags: Optional[Dict[str, str]] = None
+
+    type: Optional[str] = None
+
+    zone: Optional[str] = None
 
 
 class HeartbeatMetadataHostOsTypedDict(TypedDict):
@@ -105,6 +139,7 @@ class HeartbeatMetadataOs(BaseModel):
 
 class HeartbeatMetadataTypedDict(TypedDict):
     aws: NotRequired[HeartbeatMetadataAwsTypedDict]
+    azure: NotRequired[HeartbeatMetadataAzureTypedDict]
     host_os: NotRequired[HeartbeatMetadataHostOsTypedDict]
     kube: NotRequired[HeartbeatMetadataKubeTypedDict]
     os: NotRequired[HeartbeatMetadataOsTypedDict]
@@ -113,6 +148,8 @@ class HeartbeatMetadataTypedDict(TypedDict):
 class HeartbeatMetadata(BaseModel):
     aws: Optional[HeartbeatMetadataAws] = None
 
+    azure: Optional[HeartbeatMetadataAzure] = None
+
     host_os: Annotated[
         Optional[HeartbeatMetadataHostOs], pydantic.Field(alias="hostOs")
     ] = None

cribl_control_plane/models/input.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 from .inputappscope import InputAppscope, InputAppscopeTypedDict
 from .inputazureblob import InputAzureBlob, InputAzureBlobTypedDict
+from .inputcloudflarehec import InputCloudflareHec, InputCloudflareHecTypedDict
 from .inputcollection import InputCollection, InputCollectionTypedDict
 from .inputconfluentcloud import InputConfluentCloud, InputConfluentCloudTypedDict
 from .inputcribl import InputCribl, InputCriblTypedDict
@@ -66,68 +67,71 @@ 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(
     "InputTypedDict",
     Union[
-        InputDatagenTypedDict,
-        InputKubeEventsTypedDict,
         InputCriblTypedDict,
+        InputKubeEventsTypedDict,
+        InputDatagenTypedDict,
         InputCriblmetricsTypedDict,
         InputKubeMetricsTypedDict,
-        InputCollectionTypedDict,
         InputSystemStateTypedDict,
+        InputCollectionTypedDict,
         InputModelDrivenTelemetryTypedDict,
-        InputSystemMetricsTypedDict,
         InputWindowsMetricsTypedDict,
+        InputSystemMetricsTypedDict,
         InputJournalFilesTypedDict,
-        InputWinEventLogsTypedDict,
         InputRawUDPTypedDict,
-        InputExecTypedDict,
         InputKubeLogsTypedDict,
+        InputExecTypedDict,
         InputMetricsTypedDict,
         InputSnmpTypedDict,
+        InputWinEventLogsTypedDict,
         InputCriblTCPTypedDict,
         InputNetflowTypedDict,
-        InputTcpjsonTypedDict,
         InputGooglePubsubTypedDict,
+        InputTcpjsonTypedDict,
         InputOffice365ServiceTypedDict,
         InputWizTypedDict,
-        InputTCPTypedDict,
         InputFirehoseTypedDict,
         InputCriblHTTPTypedDict,
-        InputDatadogAgentTypedDict,
         InputOffice365MgmtTypedDict,
-        InputFileTypedDict,
+        InputDatadogAgentTypedDict,
+        InputTCPTypedDict,
         InputSplunkTypedDict,
+        InputFileTypedDict,
         InputWefTypedDict,
         InputAppscopeTypedDict,
-        InputHTTPRawTypedDict,
         InputWizWebhookTypedDict,
         InputHTTPTypedDict,
+        InputHTTPRawTypedDict,
         InputCriblLakeHTTPTypedDict,
         InputAzureBlobTypedDict,
-        InputSqsTypedDict,
         InputZscalerHecTypedDict,
-        InputKinesisTypedDict,
+        InputSqsTypedDict,
+        InputCloudflareHecTypedDict,
         InputConfluentCloudTypedDict,
-        InputEventhubTypedDict,
         InputKafkaTypedDict,
+        InputEventhubTypedDict,
+        InputKinesisTypedDict,
         InputElasticTypedDict,
         InputOffice365MsgTraceTypedDict,
         InputSplunkHecTypedDict,
         InputPrometheusRwTypedDict,
         InputLokiTypedDict,
-        InputPrometheusTypedDict,
         InputCrowdstrikeTypedDict,
         InputEdgePrometheusTypedDict,
         InputOpenTelemetryTypedDict,
         InputS3TypedDict,
         InputSecurityLakeTypedDict,
         InputMskTypedDict,
+        InputPrometheusTypedDict,
         InputS3InventoryTypedDict,
         InputSplunkSearchTypedDict,
         InputSyslogTypedDict,
@@ -136,67 +140,68 @@ 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,
-        InputPrometheusRw,
-        InputLoki,
-        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")],
+        Annotated[InputCloudflareHec, Tag("cloudflare_hec")],
     ],
-)
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]