cribl-control-plane 0.3.0b2__py3-none-any.whl → 0.3.0b4__py3-none-any.whl

cribl_control_plane/models/authtoken.py

@@ -3,18 +3,15 @@
 from __future__ import annotations
 from cribl_control_plane.types import BaseModel
 import pydantic
-from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import Annotated, TypedDict
 
 
 class AuthTokenTypedDict(TypedDict):
+    force_password_change: bool
     token: str
-    force_password_change: NotRequired[bool]
 
 
 class AuthToken(BaseModel):
-    token: str
+    force_password_change: Annotated[bool, pydantic.Field(alias="forcePasswordChange")]
 
-    force_password_change: Annotated[
-        Optional[bool], pydantic.Field(alias="forcePasswordChange")
-    ] = None
+    token: str

cribl_control_plane/models/configgroup.py

@@ -14,7 +14,7 @@ from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class EstimatedIngestRate(int, Enum, metaclass=utils.OpenEnumMeta):
+class ConfigGroupEstimatedIngestRate(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
@@ -37,13 +37,13 @@ class EstimatedIngestRate(int, Enum, metaclass=utils.OpenEnumMeta):
     RATE180_MB_PER_SEC = 15360
 
 
-class GitTypedDict(TypedDict):
+class ConfigGroupGitTypedDict(TypedDict):
     commit: NotRequired[str]
     local_changes: NotRequired[float]
     log: NotRequired[List[CommitTypedDict]]
 
 
-class Git(BaseModel):
+class ConfigGroupGit(BaseModel):
     commit: Optional[str] = None
 
     local_changes: Annotated[Optional[float], pydantic.Field(alias="localChanges")] = (
@@ -63,9 +63,9 @@ class ConfigGroupTypedDict(TypedDict):
     config_version: NotRequired[str]
     deploying_worker_count: NotRequired[float]
     description: NotRequired[str]
-    estimated_ingest_rate: NotRequired[EstimatedIngestRate]
+    estimated_ingest_rate: NotRequired[ConfigGroupEstimatedIngestRate]
     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[GitTypedDict]
+    git: NotRequired[ConfigGroupGitTypedDict]
     incompatible_worker_count: NotRequired[float]
     inherits: NotRequired[str]
     is_fleet: NotRequired[bool]
@@ -100,13 +100,14 @@ class ConfigGroup(BaseModel):
 
     estimated_ingest_rate: Annotated[
         Annotated[
-            Optional[EstimatedIngestRate], PlainValidator(validate_open_enum(True))
+            Optional[ConfigGroupEstimatedIngestRate],
+            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[Git] = None
+    git: Optional[ConfigGroupGit] = None
 
     incompatible_worker_count: Annotated[
         Optional[float], pydantic.Field(alias="incompatibleWorkerCount")

cribl_control_plane/models/createconfiggroupbyproductop.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .configgroup import ConfigGroup, ConfigGroupTypedDict
+from .groupcreaterequest import GroupCreateRequest, GroupCreateRequestTypedDict
 from .productscore import ProductsCore
 from cribl_control_plane.types import BaseModel
 from cribl_control_plane.utils import (
@@ -18,8 +19,8 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 class CreateConfigGroupByProductRequestTypedDict(TypedDict):
     product: ProductsCore
     r"""Name of the Cribl product to add the Worker Group or Edge Fleet to."""
-    config_group: ConfigGroupTypedDict
-    r"""ConfigGroup object"""
+    group_create_request: GroupCreateRequestTypedDict
+    r"""GroupCreateRequest object"""
 
 
 class CreateConfigGroupByProductRequest(BaseModel):
@@ -29,11 +30,11 @@ class CreateConfigGroupByProductRequest(BaseModel):
     ]
     r"""Name of the Cribl product to add the Worker Group or Edge Fleet to."""
 
-    config_group: Annotated[
-        ConfigGroup,
+    group_create_request: Annotated[
+        GroupCreateRequest,
         FieldMetadata(request=RequestMetadata(media_type="application/json")),
     ]
-    r"""ConfigGroup object"""
+    r"""GroupCreateRequest object"""
 
 
 class CreateConfigGroupByProductResponseTypedDict(TypedDict):

cribl_control_plane/models/createroutesappendbyidop.py

@@ -11,7 +11,7 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class CreateRoutesAppendByIDRequestTypedDict(TypedDict):
     id: str
-    r"""The <code>id</code> of the Routing table to append the Route to. The supported value is <code>default</code>."""
+    r"""The <code>id</code> of the Routing table to add the Route to. The supported value is <code>default</code>."""
     request_body: List[RouteConfTypedDict]
     r"""RouteDefinitions object"""
 
@@ -20,7 +20,7 @@ class CreateRoutesAppendByIDRequest(BaseModel):
     id: Annotated[
         str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
     ]
-    r"""The <code>id</code> of the Routing table to append the Route to. The supported value is <code>default</code>."""
+    r"""The <code>id</code> of the Routing table to add the Route to. The supported value is <code>default</code>."""
 
     request_body: Annotated[
         List[RouteConf],

cribl_control_plane/models/deleteoutputpqbyidop.py

@@ -20,7 +20,7 @@ class DeleteOutputPqByIDRequest(BaseModel):
 
 
 class DeleteOutputPqByIDResponseTypedDict(TypedDict):
-    r"""a list of string objects"""
+    r"""A list of job ids for the background job that clears the persistent queue"""
 
     count: NotRequired[int]
     r"""number of items present in the items array"""
@@ -28,7 +28,7 @@ class DeleteOutputPqByIDResponseTypedDict(TypedDict):
 
 
 class DeleteOutputPqByIDResponse(BaseModel):
-    r"""a list of string objects"""
+    r"""A list of job ids for the background job that clears the persistent queue"""
 
     count: Optional[int] = None
     r"""number of items present in the items array"""

cribl_control_plane/models/groupcreaterequest.py

@@ -0,0 +1,152 @@
+"""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 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 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):
+    LAKE_ACCESS = "lake_access"
+
+
+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

cribl_control_plane/models/{healthstatus.py → healthserverstatus.py}

@@ -12,25 +12,25 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class Role(str, Enum, metaclass=utils.OpenEnumMeta):
-    PRIMARY = "primary"
     STANDBY = "standby"
+    PRIMARY = "primary"
 
 
 class Status(str, Enum, metaclass=utils.OpenEnumMeta):
-    HEALTHY = "healthy"
     SHUTTING_DOWN = "shutting down"
+    HEALTHY = "healthy"
     STANDBY = "standby"
 
 
-class HealthStatusTypedDict(TypedDict):
-    status: Status
+class HealthServerStatusTypedDict(TypedDict):
     start_time: float
+    status: Status
     role: NotRequired[Role]
 
 
-class HealthStatus(BaseModel):
-    status: Annotated[Status, PlainValidator(validate_open_enum(False))]
-
+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

cribl_control_plane/models/input.py

@@ -75,59 +75,59 @@ from typing_extensions import Annotated, TypeAliasType
 InputTypedDict = TypeAliasType(
     "InputTypedDict",
     Union[
-        InputDatagenTypedDict,
-        InputKubeEventsTypedDict,
         InputCriblTypedDict,
+        InputKubeEventsTypedDict,
+        InputDatagenTypedDict,
         InputCriblmetricsTypedDict,
         InputKubeMetricsTypedDict,
-        InputCollectionTypedDict,
         InputSystemStateTypedDict,
+        InputCollectionTypedDict,
         InputModelDrivenTelemetryTypedDict,
         InputSystemMetricsTypedDict,
         InputWindowsMetricsTypedDict,
         InputJournalFilesTypedDict,
-        InputWinEventLogsTypedDict,
         InputRawUDPTypedDict,
-        InputExecTypedDict,
         InputKubeLogsTypedDict,
-        InputMetricsTypedDict,
+        InputExecTypedDict,
         InputSnmpTypedDict,
+        InputMetricsTypedDict,
+        InputWinEventLogsTypedDict,
         InputCriblTCPTypedDict,
         InputNetflowTypedDict,
         InputTcpjsonTypedDict,
         InputGooglePubsubTypedDict,
         InputOffice365ServiceTypedDict,
         InputWizTypedDict,
-        InputTCPTypedDict,
         InputFirehoseTypedDict,
         InputCriblHTTPTypedDict,
         InputDatadogAgentTypedDict,
         InputOffice365MgmtTypedDict,
-        InputFileTypedDict,
+        InputTCPTypedDict,
         InputSplunkTypedDict,
-        InputWefTypedDict,
+        InputFileTypedDict,
         InputAppscopeTypedDict,
+        InputWefTypedDict,
         InputHTTPRawTypedDict,
         InputWizWebhookTypedDict,
-        InputHTTPTypedDict,
         InputCriblLakeHTTPTypedDict,
-        InputAzureBlobTypedDict,
-        InputSqsTypedDict,
+        InputHTTPTypedDict,
         InputZscalerHecTypedDict,
+        InputSqsTypedDict,
+        InputAzureBlobTypedDict,
         InputKinesisTypedDict,
         InputConfluentCloudTypedDict,
         InputEventhubTypedDict,
         InputKafkaTypedDict,
         InputElasticTypedDict,
-        InputOffice365MsgTraceTypedDict,
         InputSplunkHecTypedDict,
+        InputOffice365MsgTraceTypedDict,
         InputLokiTypedDict,
         InputPrometheusRwTypedDict,
-        InputPrometheusTypedDict,
         InputCrowdstrikeTypedDict,
-        InputEdgePrometheusTypedDict,
+        InputPrometheusTypedDict,
         InputOpenTelemetryTypedDict,
         InputS3TypedDict,
+        InputEdgePrometheusTypedDict,
         InputSecurityLakeTypedDict,
         InputMskTypedDict,
         InputS3InventoryTypedDict,

cribl_control_plane/models/inputappscope.py

@@ -7,7 +7,7 @@ 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 import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -221,6 +221,12 @@ class InputAppscopeMaximumTLSVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 
 class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
     disabled: NotRequired[bool]
+    request_cert: NotRequired[bool]
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+    reject_unauthorized: NotRequired[bool]
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+    common_name_regex: NotRequired[str]
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
     certificate_name: NotRequired[str]
     r"""The name of the predefined certificate"""
     priv_key_path: NotRequired[str]
@@ -231,10 +237,6 @@ class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
     r"""Path on server containing certificates to use. PEM format. Can reference $ENV_VARS."""
     ca_path: NotRequired[str]
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
-    request_cert: NotRequired[bool]
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-    reject_unauthorized: NotRequired[Any]
-    common_name_regex: NotRequired[Any]
     min_version: NotRequired[InputAppscopeMinimumTLSVersion]
     max_version: NotRequired[InputAppscopeMaximumTLSVersion]
 
@@ -242,6 +244,19 @@ class InputAppscopeTLSSettingsServerSideTypedDict(TypedDict):
 class InputAppscopeTLSSettingsServerSide(BaseModel):
     disabled: Optional[bool] = True
 
+    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
+    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
+
+    reject_unauthorized: Annotated[
+        Optional[bool], pydantic.Field(alias="rejectUnauthorized")
+    ] = True
+    r"""Reject certificates not authorized by a CA in the CA certificate path or by another trusted CA (such as the system's)"""
+
+    common_name_regex: Annotated[
+        Optional[str], pydantic.Field(alias="commonNameRegex")
+    ] = "/.*/"
+    r"""Regex matching allowable common names in peer certificates' subject attribute"""
+
     certificate_name: Annotated[
         Optional[str], pydantic.Field(alias="certificateName")
     ] = None
@@ -259,17 +274,6 @@ class InputAppscopeTLSSettingsServerSide(BaseModel):
     ca_path: Annotated[Optional[str], pydantic.Field(alias="caPath")] = None
     r"""Path on server containing CA certificates to use. PEM format. Can reference $ENV_VARS."""
 
-    request_cert: Annotated[Optional[bool], pydantic.Field(alias="requestCert")] = False
-    r"""Require clients to present their certificates. Used to perform client authentication using SSL certs."""
-
-    reject_unauthorized: Annotated[
-        Optional[Any], pydantic.Field(alias="rejectUnauthorized")
-    ] = None
-
-    common_name_regex: Annotated[
-        Optional[Any], pydantic.Field(alias="commonNameRegex")
-    ] = None
-
     min_version: Annotated[
         Annotated[
             Optional[InputAppscopeMinimumTLSVersion],

cribl_control_plane/models/inputconfluentcloud.py

@@ -341,6 +341,13 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     tls: Optional[InputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide] = None
 
 
+class InputConfluentCloudAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Enter credentials directly, or select a stored secret"""
+
+    MANUAL = "manual"
+    SECRET = "secret"
+
+
 class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     # PLAIN
     PLAIN = "plain"
@@ -352,13 +359,58 @@ class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
     KERBEROS = "kerberos"
 
 
+class InputConfluentCloudOauthParamTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputConfluentCloudOauthParam(BaseModel):
+    name: str
+
+    value: str
+
+
+class InputConfluentCloudSaslExtensionTypedDict(TypedDict):
+    name: str
+    value: str
+
+
+class InputConfluentCloudSaslExtension(BaseModel):
+    name: str
+
+    value: str
+
+
 class InputConfluentCloudAuthenticationTypedDict(TypedDict):
     r"""Authentication parameters to use when connecting to brokers. Using TLS is highly recommended."""
 
     disabled: NotRequired[bool]
+    username: NotRequired[str]
+    password: NotRequired[str]
+    auth_type: NotRequired[InputConfluentCloudAuthenticationMethod]
+    r"""Enter credentials directly, or select a stored secret"""
+    credentials_secret: NotRequired[str]
+    r"""Select or create a secret that references your credentials"""
     mechanism: NotRequired[InputConfluentCloudSASLMechanism]
+    keytab_location: NotRequired[str]
+    r"""Location of keytab file for authentication principal"""
+    principal: NotRequired[str]
+    r"""Authentication principal, such as `kafka_user@example.com`"""
+    broker_service_class: NotRequired[str]
+    r"""Kerberos service class for Kafka brokers, such as `kafka`"""
     oauth_enabled: NotRequired[bool]
     r"""Enable OAuth authentication"""
+    token_url: NotRequired[str]
+    r"""URL of the token endpoint to use for OAuth authentication"""
+    client_id: NotRequired[str]
+    r"""Client ID to use for OAuth authentication"""
+    oauth_secret_type: NotRequired[str]
+    client_text_secret: NotRequired[str]
+    r"""Select or create a stored text secret"""
+    oauth_params: NotRequired[List[InputConfluentCloudOauthParamTypedDict]]
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+    sasl_extensions: NotRequired[List[InputConfluentCloudSaslExtensionTypedDict]]
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
 
 
 class InputConfluentCloudAuthentication(BaseModel):
@@ -366,16 +418,74 @@ class InputConfluentCloudAuthentication(BaseModel):
 
     disabled: Optional[bool] = True
 
+    username: Optional[str] = None
+
+    password: Optional[str] = None
+
+    auth_type: Annotated[
+        Annotated[
+            Optional[InputConfluentCloudAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
+    ] = InputConfluentCloudAuthenticationMethod.MANUAL
+    r"""Enter credentials directly, or select a stored secret"""
+
+    credentials_secret: Annotated[
+        Optional[str], pydantic.Field(alias="credentialsSecret")
+    ] = None
+    r"""Select or create a secret that references your credentials"""
+
     mechanism: Annotated[
         Optional[InputConfluentCloudSASLMechanism],
         PlainValidator(validate_open_enum(False)),
     ] = InputConfluentCloudSASLMechanism.PLAIN
 
+    keytab_location: Annotated[
+        Optional[str], pydantic.Field(alias="keytabLocation")
+    ] = None
+    r"""Location of keytab file for authentication principal"""
+
+    principal: Optional[str] = None
+    r"""Authentication principal, such as `kafka_user@example.com`"""
+
+    broker_service_class: Annotated[
+        Optional[str], pydantic.Field(alias="brokerServiceClass")
+    ] = None
+    r"""Kerberos service class for Kafka brokers, such as `kafka`"""
+
     oauth_enabled: Annotated[Optional[bool], pydantic.Field(alias="oauthEnabled")] = (
         False
     )
     r"""Enable OAuth authentication"""
 
+    token_url: Annotated[Optional[str], pydantic.Field(alias="tokenUrl")] = None
+    r"""URL of the token endpoint to use for OAuth authentication"""
+
+    client_id: Annotated[Optional[str], pydantic.Field(alias="clientId")] = None
+    r"""Client ID to use for OAuth authentication"""
+
+    oauth_secret_type: Annotated[
+        Optional[str], pydantic.Field(alias="oauthSecretType")
+    ] = "secret"
+
+    client_text_secret: Annotated[
+        Optional[str], pydantic.Field(alias="clientTextSecret")
+    ] = None
+    r"""Select or create a stored text secret"""
+
+    oauth_params: Annotated[
+        Optional[List[InputConfluentCloudOauthParam]],
+        pydantic.Field(alias="oauthParams"),
+    ] = None
+    r"""Additional fields to send to the token endpoint, such as scope or audience"""
+
+    sasl_extensions: Annotated[
+        Optional[List[InputConfluentCloudSaslExtension]],
+        pydantic.Field(alias="saslExtensions"),
+    ] = None
+    r"""Additional SASL extension fields, such as Confluent's logicalCluster or identityPoolId"""
+
 
 class InputConfluentCloudMetadatumTypedDict(TypedDict):
     name: str