@aws-sdk/client-eks 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1663 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message?: string;
+}
+export declare enum AddonIssueCode {
+    ACCESS_DENIED = "AccessDenied",
+    ADMISSION_REQUEST_DENIED = "AdmissionRequestDenied",
+    CLUSTER_UNREACHABLE = "ClusterUnreachable",
+    CONFIGURATION_CONFLICT = "ConfigurationConflict",
+    INSUFFICIENT_NUMBER_OF_REPLICAS = "InsufficientNumberOfReplicas",
+    INTERNAL_FAILURE = "InternalFailure",
+    K8S_RESOURCE_NOT_FOUND = "K8sResourceNotFound",
+    UNSUPPORTED_ADDON_MODIFICATION = "UnsupportedAddonModification"
+}
+
+export interface AddonIssue {
+    
+    code?: AddonIssueCode | string;
+    
+    message?: string;
+    
+    resourceIds?: string[];
+}
+export declare namespace AddonIssue {
+    
+    const filterSensitiveLog: (obj: AddonIssue) => any;
+}
+
+export interface AddonHealth {
+    
+    issues?: AddonIssue[];
+}
+export declare namespace AddonHealth {
+    
+    const filterSensitiveLog: (obj: AddonHealth) => any;
+}
+export declare type AddonStatus = "ACTIVE" | "CREATE_FAILED" | "CREATING" | "DEGRADED" | "DELETE_FAILED" | "DELETING" | "UPDATING";
+
+export interface Addon {
+    
+    addonName?: string;
+    
+    clusterName?: string;
+    
+    status?: AddonStatus | string;
+    
+    addonVersion?: string;
+    
+    health?: AddonHealth;
+    
+    addonArn?: string;
+    
+    createdAt?: Date;
+    
+    modifiedAt?: Date;
+    
+    serviceAccountRoleArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Addon {
+    
+    const filterSensitiveLog: (obj: Addon) => any;
+}
+
+export interface Compatibility {
+    
+    clusterVersion?: string;
+    
+    platformVersions?: string[];
+    
+    defaultVersion?: boolean;
+}
+export declare namespace Compatibility {
+    
+    const filterSensitiveLog: (obj: Compatibility) => any;
+}
+
+export interface AddonVersionInfo {
+    
+    addonVersion?: string;
+    
+    architecture?: string[];
+    
+    compatibilities?: Compatibility[];
+}
+export declare namespace AddonVersionInfo {
+    
+    const filterSensitiveLog: (obj: AddonVersionInfo) => any;
+}
+
+export interface AddonInfo {
+    
+    addonName?: string;
+    
+    type?: string;
+    
+    addonVersions?: AddonVersionInfo[];
+}
+export declare namespace AddonInfo {
+    
+    const filterSensitiveLog: (obj: AddonInfo) => any;
+}
+export declare type AMITypes = "AL2_ARM_64" | "AL2_x86_64" | "AL2_x86_64_GPU" | "BOTTLEROCKET_ARM_64" | "BOTTLEROCKET_x86_64" | "CUSTOM";
+
+export interface Provider {
+    
+    keyArn?: string;
+}
+export declare namespace Provider {
+    
+    const filterSensitiveLog: (obj: Provider) => any;
+}
+
+export interface EncryptionConfig {
+    
+    resources?: string[];
+    
+    provider?: Provider;
+}
+export declare namespace EncryptionConfig {
+    
+    const filterSensitiveLog: (obj: EncryptionConfig) => any;
+}
+export interface AssociateEncryptionConfigRequest {
+    
+    clusterName: string | undefined;
+    
+    encryptionConfig: EncryptionConfig[] | undefined;
+    
+    clientRequestToken?: string;
+}
+export declare namespace AssociateEncryptionConfigRequest {
+    
+    const filterSensitiveLog: (obj: AssociateEncryptionConfigRequest) => any;
+}
+export declare enum ErrorCode {
+    ACCESS_DENIED = "AccessDenied",
+    ADMISSION_REQUEST_DENIED = "AdmissionRequestDenied",
+    CLUSTER_UNREACHABLE = "ClusterUnreachable",
+    CONFIGURATION_CONFLICT = "ConfigurationConflict",
+    ENI_LIMIT_REACHED = "EniLimitReached",
+    INSUFFICIENT_FREE_ADDRESSES = "InsufficientFreeAddresses",
+    INSUFFICIENT_NUMBER_OF_REPLICAS = "InsufficientNumberOfReplicas",
+    IP_NOT_AVAILABLE = "IpNotAvailable",
+    K8S_RESOURCE_NOT_FOUND = "K8sResourceNotFound",
+    NODE_CREATION_FAILURE = "NodeCreationFailure",
+    OPERATION_NOT_PERMITTED = "OperationNotPermitted",
+    POD_EVICTION_FAILURE = "PodEvictionFailure",
+    SECURITY_GROUP_NOT_FOUND = "SecurityGroupNotFound",
+    SUBNET_NOT_FOUND = "SubnetNotFound",
+    UNKNOWN = "Unknown",
+    UNSUPPORTED_ADDON_MODIFICATION = "UnsupportedAddonModification",
+    VPC_ID_NOT_FOUND = "VpcIdNotFound"
+}
+
+export interface ErrorDetail {
+    
+    errorCode?: ErrorCode | string;
+    
+    errorMessage?: string;
+    
+    resourceIds?: string[];
+}
+export declare namespace ErrorDetail {
+    
+    const filterSensitiveLog: (obj: ErrorDetail) => any;
+}
+export declare enum UpdateParamType {
+    ADDON_VERSION = "AddonVersion",
+    CLUSTER_LOGGING = "ClusterLogging",
+    DESIRED_SIZE = "DesiredSize",
+    ENCRYPTION_CONFIG = "EncryptionConfig",
+    ENDPOINT_PRIVATE_ACCESS = "EndpointPrivateAccess",
+    ENDPOINT_PUBLIC_ACCESS = "EndpointPublicAccess",
+    IDENTITY_PROVIDER_CONFIG = "IdentityProviderConfig",
+    LABELS_TO_ADD = "LabelsToAdd",
+    LABELS_TO_REMOVE = "LabelsToRemove",
+    LAUNCH_TEMPLATE_NAME = "LaunchTemplateName",
+    LAUNCH_TEMPLATE_VERSION = "LaunchTemplateVersion",
+    MAX_SIZE = "MaxSize",
+    MAX_UNAVAILABLE = "MaxUnavailable",
+    MAX_UNAVAILABLE_PERCENTAGE = "MaxUnavailablePercentage",
+    MIN_SIZE = "MinSize",
+    PLATFORM_VERSION = "PlatformVersion",
+    PUBLIC_ACCESS_CIDRS = "PublicAccessCidrs",
+    RELEASE_VERSION = "ReleaseVersion",
+    RESOLVE_CONFLICTS = "ResolveConflicts",
+    SERVICE_ACCOUNT_ROLE_ARN = "ServiceAccountRoleArn",
+    TAINTS_TO_ADD = "TaintsToAdd",
+    TAINTS_TO_REMOVE = "TaintsToRemove",
+    VERSION = "Version"
+}
+
+export interface UpdateParam {
+    
+    type?: UpdateParamType | string;
+    
+    value?: string;
+}
+export declare namespace UpdateParam {
+    
+    const filterSensitiveLog: (obj: UpdateParam) => any;
+}
+export declare enum UpdateStatus {
+    CANCELLED = "Cancelled",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    SUCCESSFUL = "Successful"
+}
+export declare enum UpdateType {
+    ADDON_UPDATE = "AddonUpdate",
+    ASSOCIATE_ENCRYPTION_CONFIG = "AssociateEncryptionConfig",
+    ASSOCIATE_IDENTITY_PROVIDER_CONFIG = "AssociateIdentityProviderConfig",
+    CONFIG_UPDATE = "ConfigUpdate",
+    DISASSOCIATE_IDENTITY_PROVIDER_CONFIG = "DisassociateIdentityProviderConfig",
+    ENDPOINT_ACCESS_UPDATE = "EndpointAccessUpdate",
+    LOGGING_UPDATE = "LoggingUpdate",
+    VERSION_UPDATE = "VersionUpdate"
+}
+
+export interface Update {
+    
+    id?: string;
+    
+    status?: UpdateStatus | string;
+    
+    type?: UpdateType | string;
+    
+    params?: UpdateParam[];
+    
+    createdAt?: Date;
+    
+    errors?: ErrorDetail[];
+}
+export declare namespace Update {
+    
+    const filterSensitiveLog: (obj: Update) => any;
+}
+export interface AssociateEncryptionConfigResponse {
+    
+    update?: Update;
+}
+export declare namespace AssociateEncryptionConfigResponse {
+    
+    const filterSensitiveLog: (obj: AssociateEncryptionConfigResponse) => any;
+}
+
+export interface ClientException extends __SmithyException, $MetadataBearer {
+    name: "ClientException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    
+    fargateProfileName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    
+    fargateProfileName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface ServerException extends __SmithyException, $MetadataBearer {
+    name: "ServerException";
+    $fault: "server";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    addonName?: string;
+    message?: string;
+}
+
+export interface OidcIdentityProviderConfigRequest {
+    
+    identityProviderConfigName: string | undefined;
+    
+    issuerUrl: string | undefined;
+    
+    clientId: string | undefined;
+    
+    usernameClaim?: string;
+    
+    usernamePrefix?: string;
+    
+    groupsClaim?: string;
+    
+    groupsPrefix?: string;
+    
+    requiredClaims?: {
+        [key: string]: string;
+    };
+}
+export declare namespace OidcIdentityProviderConfigRequest {
+    
+    const filterSensitiveLog: (obj: OidcIdentityProviderConfigRequest) => any;
+}
+export interface AssociateIdentityProviderConfigRequest {
+    
+    clusterName: string | undefined;
+    
+    oidc: OidcIdentityProviderConfigRequest | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientRequestToken?: string;
+}
+export declare namespace AssociateIdentityProviderConfigRequest {
+    
+    const filterSensitiveLog: (obj: AssociateIdentityProviderConfigRequest) => any;
+}
+export interface AssociateIdentityProviderConfigResponse {
+    
+    update?: Update;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AssociateIdentityProviderConfigResponse {
+    
+    const filterSensitiveLog: (obj: AssociateIdentityProviderConfigResponse) => any;
+}
+
+export interface AutoScalingGroup {
+    
+    name?: string;
+}
+export declare namespace AutoScalingGroup {
+    
+    const filterSensitiveLog: (obj: AutoScalingGroup) => any;
+}
+export declare type ResolveConflicts = "NONE" | "OVERWRITE";
+export interface CreateAddonRequest {
+    
+    clusterName: string | undefined;
+    
+    addonName: string | undefined;
+    
+    addonVersion?: string;
+    
+    serviceAccountRoleArn?: string;
+    
+    resolveConflicts?: ResolveConflicts | string;
+    
+    clientRequestToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateAddonRequest {
+    
+    const filterSensitiveLog: (obj: CreateAddonRequest) => any;
+}
+export interface CreateAddonResponse {
+    
+    addon?: Addon;
+}
+export declare namespace CreateAddonResponse {
+    
+    const filterSensitiveLog: (obj: CreateAddonResponse) => any;
+}
+export declare enum IpFamily {
+    IPV4 = "ipv4",
+    IPV6 = "ipv6"
+}
+
+export interface KubernetesNetworkConfigRequest {
+    
+    serviceIpv4Cidr?: string;
+    
+    ipFamily?: IpFamily | string;
+}
+export declare namespace KubernetesNetworkConfigRequest {
+    
+    const filterSensitiveLog: (obj: KubernetesNetworkConfigRequest) => any;
+}
+export declare enum LogType {
+    API = "api",
+    AUDIT = "audit",
+    AUTHENTICATOR = "authenticator",
+    CONTROLLER_MANAGER = "controllerManager",
+    SCHEDULER = "scheduler"
+}
+
+export interface LogSetup {
+    
+    types?: (LogType | string)[];
+    
+    enabled?: boolean;
+}
+export declare namespace LogSetup {
+    
+    const filterSensitiveLog: (obj: LogSetup) => any;
+}
+
+export interface Logging {
+    
+    clusterLogging?: LogSetup[];
+}
+export declare namespace Logging {
+    
+    const filterSensitiveLog: (obj: Logging) => any;
+}
+
+export interface VpcConfigRequest {
+    
+    subnetIds?: string[];
+    
+    securityGroupIds?: string[];
+    
+    endpointPublicAccess?: boolean;
+    
+    endpointPrivateAccess?: boolean;
+    
+    publicAccessCidrs?: string[];
+}
+export declare namespace VpcConfigRequest {
+    
+    const filterSensitiveLog: (obj: VpcConfigRequest) => any;
+}
+export interface CreateClusterRequest {
+    
+    name: string | undefined;
+    
+    version?: string;
+    
+    roleArn: string | undefined;
+    
+    resourcesVpcConfig: VpcConfigRequest | undefined;
+    
+    kubernetesNetworkConfig?: KubernetesNetworkConfigRequest;
+    
+    logging?: Logging;
+    
+    clientRequestToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    encryptionConfig?: EncryptionConfig[];
+}
+export declare namespace CreateClusterRequest {
+    
+    const filterSensitiveLog: (obj: CreateClusterRequest) => any;
+}
+
+export interface Certificate {
+    
+    data?: string;
+}
+export declare namespace Certificate {
+    
+    const filterSensitiveLog: (obj: Certificate) => any;
+}
+
+export interface ConnectorConfigResponse {
+    
+    activationId?: string;
+    
+    activationCode?: string;
+    
+    activationExpiry?: Date;
+    
+    provider?: string;
+    
+    roleArn?: string;
+}
+export declare namespace ConnectorConfigResponse {
+    
+    const filterSensitiveLog: (obj: ConnectorConfigResponse) => any;
+}
+
+export interface OIDC {
+    
+    issuer?: string;
+}
+export declare namespace OIDC {
+    
+    const filterSensitiveLog: (obj: OIDC) => any;
+}
+
+export interface Identity {
+    
+    oidc?: OIDC;
+}
+export declare namespace Identity {
+    
+    const filterSensitiveLog: (obj: Identity) => any;
+}
+
+export interface KubernetesNetworkConfigResponse {
+    
+    serviceIpv4Cidr?: string;
+    
+    serviceIpv6Cidr?: string;
+    
+    ipFamily?: IpFamily | string;
+}
+export declare namespace KubernetesNetworkConfigResponse {
+    
+    const filterSensitiveLog: (obj: KubernetesNetworkConfigResponse) => any;
+}
+
+export interface VpcConfigResponse {
+    
+    subnetIds?: string[];
+    
+    securityGroupIds?: string[];
+    
+    clusterSecurityGroupId?: string;
+    
+    vpcId?: string;
+    
+    endpointPublicAccess?: boolean;
+    
+    endpointPrivateAccess?: boolean;
+    
+    publicAccessCidrs?: string[];
+}
+export declare namespace VpcConfigResponse {
+    
+    const filterSensitiveLog: (obj: VpcConfigResponse) => any;
+}
+export declare type ClusterStatus = "ACTIVE" | "CREATING" | "DELETING" | "FAILED" | "PENDING" | "UPDATING";
+
+export interface Cluster {
+    
+    name?: string;
+    
+    arn?: string;
+    
+    createdAt?: Date;
+    
+    version?: string;
+    
+    endpoint?: string;
+    
+    roleArn?: string;
+    
+    resourcesVpcConfig?: VpcConfigResponse;
+    
+    kubernetesNetworkConfig?: KubernetesNetworkConfigResponse;
+    
+    logging?: Logging;
+    
+    identity?: Identity;
+    
+    status?: ClusterStatus | string;
+    
+    certificateAuthority?: Certificate;
+    
+    clientRequestToken?: string;
+    
+    platformVersion?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    encryptionConfig?: EncryptionConfig[];
+    
+    connectorConfig?: ConnectorConfigResponse;
+}
+export declare namespace Cluster {
+    
+    const filterSensitiveLog: (obj: Cluster) => any;
+}
+export interface CreateClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace CreateClusterResponse {
+    
+    const filterSensitiveLog: (obj: CreateClusterResponse) => any;
+}
+
+export interface ResourceLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceLimitExceededException";
+    $fault: "client";
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    message?: string;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    message?: string;
+}
+
+export interface UnsupportedAvailabilityZoneException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedAvailabilityZoneException";
+    $fault: "client";
+    message?: string;
+    
+    clusterName?: string;
+    
+    nodegroupName?: string;
+    
+    validZones?: string[];
+}
+
+export interface FargateProfileSelector {
+    
+    namespace?: string;
+    
+    labels?: {
+        [key: string]: string;
+    };
+}
+export declare namespace FargateProfileSelector {
+    
+    const filterSensitiveLog: (obj: FargateProfileSelector) => any;
+}
+export interface CreateFargateProfileRequest {
+    
+    fargateProfileName: string | undefined;
+    
+    clusterName: string | undefined;
+    
+    podExecutionRoleArn: string | undefined;
+    
+    subnets?: string[];
+    
+    selectors?: FargateProfileSelector[];
+    
+    clientRequestToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateFargateProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateFargateProfileRequest) => any;
+}
+export declare type FargateProfileStatus = "ACTIVE" | "CREATE_FAILED" | "CREATING" | "DELETE_FAILED" | "DELETING";
+
+export interface FargateProfile {
+    
+    fargateProfileName?: string;
+    
+    fargateProfileArn?: string;
+    
+    clusterName?: string;
+    
+    createdAt?: Date;
+    
+    podExecutionRoleArn?: string;
+    
+    subnets?: string[];
+    
+    selectors?: FargateProfileSelector[];
+    
+    status?: FargateProfileStatus | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace FargateProfile {
+    
+    const filterSensitiveLog: (obj: FargateProfile) => any;
+}
+export interface CreateFargateProfileResponse {
+    
+    fargateProfile?: FargateProfile;
+}
+export declare namespace CreateFargateProfileResponse {
+    
+    const filterSensitiveLog: (obj: CreateFargateProfileResponse) => any;
+}
+export declare type CapacityTypes = "ON_DEMAND" | "SPOT";
+
+export interface LaunchTemplateSpecification {
+    
+    name?: string;
+    
+    version?: string;
+    
+    id?: string;
+}
+export declare namespace LaunchTemplateSpecification {
+    
+    const filterSensitiveLog: (obj: LaunchTemplateSpecification) => any;
+}
+
+export interface RemoteAccessConfig {
+    
+    ec2SshKey?: string;
+    
+    sourceSecurityGroups?: string[];
+}
+export declare namespace RemoteAccessConfig {
+    
+    const filterSensitiveLog: (obj: RemoteAccessConfig) => any;
+}
+
+export interface NodegroupScalingConfig {
+    
+    minSize?: number;
+    
+    maxSize?: number;
+    
+    desiredSize?: number;
+}
+export declare namespace NodegroupScalingConfig {
+    
+    const filterSensitiveLog: (obj: NodegroupScalingConfig) => any;
+}
+export declare enum TaintEffect {
+    NO_EXECUTE = "NO_EXECUTE",
+    NO_SCHEDULE = "NO_SCHEDULE",
+    PREFER_NO_SCHEDULE = "PREFER_NO_SCHEDULE"
+}
+
+export interface Taint {
+    
+    key?: string;
+    
+    value?: string;
+    
+    effect?: TaintEffect | string;
+}
+export declare namespace Taint {
+    
+    const filterSensitiveLog: (obj: Taint) => any;
+}
+
+export interface NodegroupUpdateConfig {
+    
+    maxUnavailable?: number;
+    
+    maxUnavailablePercentage?: number;
+}
+export declare namespace NodegroupUpdateConfig {
+    
+    const filterSensitiveLog: (obj: NodegroupUpdateConfig) => any;
+}
+export interface CreateNodegroupRequest {
+    
+    clusterName: string | undefined;
+    
+    nodegroupName: string | undefined;
+    
+    scalingConfig?: NodegroupScalingConfig;
+    
+    diskSize?: number;
+    
+    subnets: string[] | undefined;
+    
+    instanceTypes?: string[];
+    
+    amiType?: AMITypes | string;
+    
+    remoteAccess?: RemoteAccessConfig;
+    
+    nodeRole: string | undefined;
+    
+    labels?: {
+        [key: string]: string;
+    };
+    
+    taints?: Taint[];
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    clientRequestToken?: string;
+    
+    launchTemplate?: LaunchTemplateSpecification;
+    
+    updateConfig?: NodegroupUpdateConfig;
+    
+    capacityType?: CapacityTypes | string;
+    
+    version?: string;
+    
+    releaseVersion?: string;
+}
+export declare namespace CreateNodegroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateNodegroupRequest) => any;
+}
+export declare enum NodegroupIssueCode {
+    ACCESS_DENIED = "AccessDenied",
+    ASG_INSTANCE_LAUNCH_FAILURES = "AsgInstanceLaunchFailures",
+    AUTO_SCALING_GROUP_INVALID_CONFIGURATION = "AutoScalingGroupInvalidConfiguration",
+    AUTO_SCALING_GROUP_NOT_FOUND = "AutoScalingGroupNotFound",
+    CLUSTER_UNREACHABLE = "ClusterUnreachable",
+    EC2_LAUNCH_TEMPLATE_NOT_FOUND = "Ec2LaunchTemplateNotFound",
+    EC2_LAUNCH_TEMPLATE_VERSION_MISMATCH = "Ec2LaunchTemplateVersionMismatch",
+    EC2_SECURITY_GROUP_DELETION_FAILURE = "Ec2SecurityGroupDeletionFailure",
+    EC2_SECURITY_GROUP_NOT_FOUND = "Ec2SecurityGroupNotFound",
+    EC2_SUBNET_INVALID_CONFIGURATION = "Ec2SubnetInvalidConfiguration",
+    EC2_SUBNET_NOT_FOUND = "Ec2SubnetNotFound",
+    IAM_INSTANCE_PROFILE_NOT_FOUND = "IamInstanceProfileNotFound",
+    IAM_LIMIT_EXCEEDED = "IamLimitExceeded",
+    IAM_NODE_ROLE_NOT_FOUND = "IamNodeRoleNotFound",
+    INSTANCE_LIMIT_EXCEEDED = "InstanceLimitExceeded",
+    INSUFFICIENT_FREE_ADDRESSES = "InsufficientFreeAddresses",
+    INTERNAL_FAILURE = "InternalFailure",
+    NODE_CREATION_FAILURE = "NodeCreationFailure"
+}
+
+export interface Issue {
+    
+    code?: NodegroupIssueCode | string;
+    
+    message?: string;
+    
+    resourceIds?: string[];
+}
+export declare namespace Issue {
+    
+    const filterSensitiveLog: (obj: Issue) => any;
+}
+
+export interface NodegroupHealth {
+    
+    issues?: Issue[];
+}
+export declare namespace NodegroupHealth {
+    
+    const filterSensitiveLog: (obj: NodegroupHealth) => any;
+}
+
+export interface NodegroupResources {
+    
+    autoScalingGroups?: AutoScalingGroup[];
+    
+    remoteAccessSecurityGroup?: string;
+}
+export declare namespace NodegroupResources {
+    
+    const filterSensitiveLog: (obj: NodegroupResources) => any;
+}
+export declare type NodegroupStatus = "ACTIVE" | "CREATE_FAILED" | "CREATING" | "DEGRADED" | "DELETE_FAILED" | "DELETING" | "UPDATING";
+
+export interface Nodegroup {
+    
+    nodegroupName?: string;
+    
+    nodegroupArn?: string;
+    
+    clusterName?: string;
+    
+    version?: string;
+    
+    releaseVersion?: string;
+    
+    createdAt?: Date;
+    
+    modifiedAt?: Date;
+    
+    status?: NodegroupStatus | string;
+    
+    capacityType?: CapacityTypes | string;
+    
+    scalingConfig?: NodegroupScalingConfig;
+    
+    instanceTypes?: string[];
+    
+    subnets?: string[];
+    
+    remoteAccess?: RemoteAccessConfig;
+    
+    amiType?: AMITypes | string;
+    
+    nodeRole?: string;
+    
+    labels?: {
+        [key: string]: string;
+    };
+    
+    taints?: Taint[];
+    
+    resources?: NodegroupResources;
+    
+    diskSize?: number;
+    
+    health?: NodegroupHealth;
+    
+    updateConfig?: NodegroupUpdateConfig;
+    
+    launchTemplate?: LaunchTemplateSpecification;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Nodegroup {
+    
+    const filterSensitiveLog: (obj: Nodegroup) => any;
+}
+export interface CreateNodegroupResponse {
+    
+    nodegroup?: Nodegroup;
+}
+export declare namespace CreateNodegroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateNodegroupResponse) => any;
+}
+export interface DeleteAddonRequest {
+    
+    clusterName: string | undefined;
+    
+    addonName: string | undefined;
+    
+    preserve?: boolean;
+}
+export declare namespace DeleteAddonRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAddonRequest) => any;
+}
+export interface DeleteAddonResponse {
+    
+    addon?: Addon;
+}
+export declare namespace DeleteAddonResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAddonResponse) => any;
+}
+export interface DeleteClusterRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteClusterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteClusterRequest) => any;
+}
+export interface DeleteClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace DeleteClusterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteClusterResponse) => any;
+}
+export interface DeleteFargateProfileRequest {
+    
+    clusterName: string | undefined;
+    
+    fargateProfileName: string | undefined;
+}
+export declare namespace DeleteFargateProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFargateProfileRequest) => any;
+}
+export interface DeleteFargateProfileResponse {
+    
+    fargateProfile?: FargateProfile;
+}
+export declare namespace DeleteFargateProfileResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFargateProfileResponse) => any;
+}
+export interface DeleteNodegroupRequest {
+    
+    clusterName: string | undefined;
+    
+    nodegroupName: string | undefined;
+}
+export declare namespace DeleteNodegroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNodegroupRequest) => any;
+}
+export interface DeleteNodegroupResponse {
+    
+    nodegroup?: Nodegroup;
+}
+export declare namespace DeleteNodegroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteNodegroupResponse) => any;
+}
+export interface DeregisterClusterRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DeregisterClusterRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterClusterRequest) => any;
+}
+export interface DeregisterClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace DeregisterClusterResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterClusterResponse) => any;
+}
+export interface DescribeAddonRequest {
+    
+    clusterName: string | undefined;
+    
+    addonName: string | undefined;
+}
+export declare namespace DescribeAddonRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAddonRequest) => any;
+}
+export interface DescribeAddonResponse {
+    
+    addon?: Addon;
+}
+export declare namespace DescribeAddonResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAddonResponse) => any;
+}
+export interface DescribeAddonVersionsRequest {
+    
+    kubernetesVersion?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    addonName?: string;
+}
+export declare namespace DescribeAddonVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAddonVersionsRequest) => any;
+}
+export interface DescribeAddonVersionsResponse {
+    
+    addons?: AddonInfo[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeAddonVersionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAddonVersionsResponse) => any;
+}
+export interface DescribeClusterRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DescribeClusterRequest {
+    
+    const filterSensitiveLog: (obj: DescribeClusterRequest) => any;
+}
+export interface DescribeClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace DescribeClusterResponse {
+    
+    const filterSensitiveLog: (obj: DescribeClusterResponse) => any;
+}
+export interface DescribeFargateProfileRequest {
+    
+    clusterName: string | undefined;
+    
+    fargateProfileName: string | undefined;
+}
+export declare namespace DescribeFargateProfileRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFargateProfileRequest) => any;
+}
+export interface DescribeFargateProfileResponse {
+    
+    fargateProfile?: FargateProfile;
+}
+export declare namespace DescribeFargateProfileResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFargateProfileResponse) => any;
+}
+
+export interface IdentityProviderConfig {
+    
+    type: string | undefined;
+    
+    name: string | undefined;
+}
+export declare namespace IdentityProviderConfig {
+    
+    const filterSensitiveLog: (obj: IdentityProviderConfig) => any;
+}
+export interface DescribeIdentityProviderConfigRequest {
+    
+    clusterName: string | undefined;
+    
+    identityProviderConfig: IdentityProviderConfig | undefined;
+}
+export declare namespace DescribeIdentityProviderConfigRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityProviderConfigRequest) => any;
+}
+export declare enum ConfigStatus {
+    ACTIVE = "ACTIVE",
+    CREATING = "CREATING",
+    DELETING = "DELETING"
+}
+
+export interface OidcIdentityProviderConfig {
+    
+    identityProviderConfigName?: string;
+    
+    identityProviderConfigArn?: string;
+    
+    clusterName?: string;
+    
+    issuerUrl?: string;
+    
+    clientId?: string;
+    
+    usernameClaim?: string;
+    
+    usernamePrefix?: string;
+    
+    groupsClaim?: string;
+    
+    groupsPrefix?: string;
+    
+    requiredClaims?: {
+        [key: string]: string;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    status?: ConfigStatus | string;
+}
+export declare namespace OidcIdentityProviderConfig {
+    
+    const filterSensitiveLog: (obj: OidcIdentityProviderConfig) => any;
+}
+
+export interface IdentityProviderConfigResponse {
+    
+    oidc?: OidcIdentityProviderConfig;
+}
+export declare namespace IdentityProviderConfigResponse {
+    
+    const filterSensitiveLog: (obj: IdentityProviderConfigResponse) => any;
+}
+export interface DescribeIdentityProviderConfigResponse {
+    
+    identityProviderConfig?: IdentityProviderConfigResponse;
+}
+export declare namespace DescribeIdentityProviderConfigResponse {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityProviderConfigResponse) => any;
+}
+export interface DescribeNodegroupRequest {
+    
+    clusterName: string | undefined;
+    
+    nodegroupName: string | undefined;
+}
+export declare namespace DescribeNodegroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeNodegroupRequest) => any;
+}
+export interface DescribeNodegroupResponse {
+    
+    nodegroup?: Nodegroup;
+}
+export declare namespace DescribeNodegroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeNodegroupResponse) => any;
+}
+export interface DescribeUpdateRequest {
+    
+    name: string | undefined;
+    
+    updateId: string | undefined;
+    
+    nodegroupName?: string;
+    
+    addonName?: string;
+}
+export declare namespace DescribeUpdateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUpdateRequest) => any;
+}
+export interface DescribeUpdateResponse {
+    
+    update?: Update;
+}
+export declare namespace DescribeUpdateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUpdateResponse) => any;
+}
+export interface DisassociateIdentityProviderConfigRequest {
+    
+    clusterName: string | undefined;
+    
+    identityProviderConfig: IdentityProviderConfig | undefined;
+    
+    clientRequestToken?: string;
+}
+export declare namespace DisassociateIdentityProviderConfigRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateIdentityProviderConfigRequest) => any;
+}
+export interface DisassociateIdentityProviderConfigResponse {
+    
+    update?: Update;
+}
+export declare namespace DisassociateIdentityProviderConfigResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateIdentityProviderConfigResponse) => any;
+}
+export interface ListAddonsRequest {
+    
+    clusterName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListAddonsRequest {
+    
+    const filterSensitiveLog: (obj: ListAddonsRequest) => any;
+}
+export interface ListAddonsResponse {
+    
+    addons?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAddonsResponse {
+    
+    const filterSensitiveLog: (obj: ListAddonsResponse) => any;
+}
+export interface ListClustersRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    include?: string[];
+}
+export declare namespace ListClustersRequest {
+    
+    const filterSensitiveLog: (obj: ListClustersRequest) => any;
+}
+export interface ListClustersResponse {
+    
+    clusters?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListClustersResponse {
+    
+    const filterSensitiveLog: (obj: ListClustersResponse) => any;
+}
+export interface ListFargateProfilesRequest {
+    
+    clusterName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListFargateProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListFargateProfilesRequest) => any;
+}
+export interface ListFargateProfilesResponse {
+    
+    fargateProfileNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListFargateProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListFargateProfilesResponse) => any;
+}
+export interface ListIdentityProviderConfigsRequest {
+    
+    clusterName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListIdentityProviderConfigsRequest {
+    
+    const filterSensitiveLog: (obj: ListIdentityProviderConfigsRequest) => any;
+}
+export interface ListIdentityProviderConfigsResponse {
+    
+    identityProviderConfigs?: IdentityProviderConfig[];
+    
+    nextToken?: string;
+}
+export declare namespace ListIdentityProviderConfigsResponse {
+    
+    const filterSensitiveLog: (obj: ListIdentityProviderConfigsResponse) => any;
+}
+export interface ListNodegroupsRequest {
+    
+    clusterName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListNodegroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListNodegroupsRequest) => any;
+}
+export interface ListNodegroupsResponse {
+    
+    nodegroups?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListNodegroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListNodegroupsResponse) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    message?: string;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export interface ListUpdatesRequest {
+    
+    name: string | undefined;
+    
+    nodegroupName?: string;
+    
+    addonName?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListUpdatesRequest {
+    
+    const filterSensitiveLog: (obj: ListUpdatesRequest) => any;
+}
+export interface ListUpdatesResponse {
+    
+    updateIds?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListUpdatesResponse {
+    
+    const filterSensitiveLog: (obj: ListUpdatesResponse) => any;
+}
+export declare enum ConnectorConfigProvider {
+    AKS = "AKS",
+    ANTHOS = "ANTHOS",
+    EC2 = "EC2",
+    EKS_ANYWHERE = "EKS_ANYWHERE",
+    GKE = "GKE",
+    OPENSHIFT = "OPENSHIFT",
+    OTHER = "OTHER",
+    RANCHER = "RANCHER",
+    TANZU = "TANZU"
+}
+
+export interface ConnectorConfigRequest {
+    
+    roleArn: string | undefined;
+    
+    provider: ConnectorConfigProvider | string | undefined;
+}
+export declare namespace ConnectorConfigRequest {
+    
+    const filterSensitiveLog: (obj: ConnectorConfigRequest) => any;
+}
+export interface RegisterClusterRequest {
+    
+    name: string | undefined;
+    
+    connectorConfig: ConnectorConfigRequest | undefined;
+    
+    clientRequestToken?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace RegisterClusterRequest {
+    
+    const filterSensitiveLog: (obj: RegisterClusterRequest) => any;
+}
+export interface RegisterClusterResponse {
+    
+    cluster?: Cluster;
+}
+export declare namespace RegisterClusterResponse {
+    
+    const filterSensitiveLog: (obj: RegisterClusterResponse) => any;
+}
+
+export interface ResourcePropagationDelayException extends __SmithyException, $MetadataBearer {
+    name: "ResourcePropagationDelayException";
+    $fault: "client";
+    message?: string;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateAddonRequest {
+    
+    clusterName: string | undefined;
+    
+    addonName: string | undefined;
+    
+    addonVersion?: string;
+    
+    serviceAccountRoleArn?: string;
+    
+    resolveConflicts?: ResolveConflicts | string;
+    
+    clientRequestToken?: string;
+}
+export declare namespace UpdateAddonRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAddonRequest) => any;
+}
+export interface UpdateAddonResponse {
+    
+    update?: Update;
+}
+export declare namespace UpdateAddonResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAddonResponse) => any;
+}
+export interface UpdateClusterConfigRequest {
+    
+    name: string | undefined;
+    
+    resourcesVpcConfig?: VpcConfigRequest;
+    
+    logging?: Logging;
+    
+    clientRequestToken?: string;
+}
+export declare namespace UpdateClusterConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterConfigRequest) => any;
+}
+export interface UpdateClusterConfigResponse {
+    
+    update?: Update;
+}
+export declare namespace UpdateClusterConfigResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterConfigResponse) => any;
+}
+export interface UpdateClusterVersionRequest {
+    
+    name: string | undefined;
+    
+    version: string | undefined;
+    
+    clientRequestToken?: string;
+}
+export declare namespace UpdateClusterVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClusterVersionRequest) => any;
+}
+export interface UpdateClusterVersionResponse {
+    
+    update?: Update;
+}
+export declare namespace UpdateClusterVersionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClusterVersionResponse) => any;
+}
+
+export interface UpdateLabelsPayload {
+    
+    addOrUpdateLabels?: {
+        [key: string]: string;
+    };
+    
+    removeLabels?: string[];
+}
+export declare namespace UpdateLabelsPayload {
+    
+    const filterSensitiveLog: (obj: UpdateLabelsPayload) => any;
+}
+
+export interface UpdateTaintsPayload {
+    
+    addOrUpdateTaints?: Taint[];
+    
+    removeTaints?: Taint[];
+}
+export declare namespace UpdateTaintsPayload {
+    
+    const filterSensitiveLog: (obj: UpdateTaintsPayload) => any;
+}
+export interface UpdateNodegroupConfigRequest {
+    
+    clusterName: string | undefined;
+    
+    nodegroupName: string | undefined;
+    
+    labels?: UpdateLabelsPayload;
+    
+    taints?: UpdateTaintsPayload;
+    
+    scalingConfig?: NodegroupScalingConfig;
+    
+    updateConfig?: NodegroupUpdateConfig;
+    
+    clientRequestToken?: string;
+}
+export declare namespace UpdateNodegroupConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNodegroupConfigRequest) => any;
+}
+export interface UpdateNodegroupConfigResponse {
+    
+    update?: Update;
+}
+export declare namespace UpdateNodegroupConfigResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNodegroupConfigResponse) => any;
+}
+export interface UpdateNodegroupVersionRequest {
+    
+    clusterName: string | undefined;
+    
+    nodegroupName: string | undefined;
+    
+    version?: string;
+    
+    releaseVersion?: string;
+    
+    launchTemplate?: LaunchTemplateSpecification;
+    
+    force?: boolean;
+    
+    clientRequestToken?: string;
+}
+export declare namespace UpdateNodegroupVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNodegroupVersionRequest) => any;
+}
+export interface UpdateNodegroupVersionResponse {
+    
+    update?: Update;
+}
+export declare namespace UpdateNodegroupVersionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNodegroupVersionResponse) => any;
+}