@aws-sdk/client-eks/dist-cjs/index.js

AWS SDK for JavaScript Eks Client for Node.js, Browser and React Native

'use strict';

var client$1 = require('@aws-sdk/core/client');
var core = require('@smithy/core');
var client = require('@smithy/core/client');
var config = require('@smithy/core/config');
var endpoints = require('@smithy/core/endpoints');
var protocols = require('@smithy/core/protocols');
var retry = require('@smithy/core/retry');
var schema = require('@smithy/core/schema');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var schemas_0 = require('./schemas/schemas_0');
var errors = require('./models/errors');
var EKSServiceException = require('./models/EKSServiceException');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "eks",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class EKSClient extends client.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
        const _config_3 = retry.resolveRetryConfig(_config_2);
        const _config_4 = config.resolveRegionConfig(_config_3);
        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
        this.middlewareStack.use(retry.getRetryPlugin(this.config));
        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultEKSHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class AssociateAccessPolicyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "AssociateAccessPolicy", {})
    .n("EKSClient", "AssociateAccessPolicyCommand")
    .sc(schemas_0.AssociateAccessPolicy$)
    .build() {
}

class AssociateEncryptionConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "AssociateEncryptionConfig", {})
    .n("EKSClient", "AssociateEncryptionConfigCommand")
    .sc(schemas_0.AssociateEncryptionConfig$)
    .build() {
}

class AssociateIdentityProviderConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "AssociateIdentityProviderConfig", {})
    .n("EKSClient", "AssociateIdentityProviderConfigCommand")
    .sc(schemas_0.AssociateIdentityProviderConfig$)
    .build() {
}

class CreateAccessEntryCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateAccessEntry", {})
    .n("EKSClient", "CreateAccessEntryCommand")
    .sc(schemas_0.CreateAccessEntry$)
    .build() {
}

class CreateAddonCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateAddon", {})
    .n("EKSClient", "CreateAddonCommand")
    .sc(schemas_0.CreateAddon$)
    .build() {
}

class CreateCapabilityCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateCapability", {})
    .n("EKSClient", "CreateCapabilityCommand")
    .sc(schemas_0.CreateCapability$)
    .build() {
}

class CreateClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateCluster", {})
    .n("EKSClient", "CreateClusterCommand")
    .sc(schemas_0.CreateCluster$)
    .build() {
}

class CreateEksAnywhereSubscriptionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateEksAnywhereSubscription", {})
    .n("EKSClient", "CreateEksAnywhereSubscriptionCommand")
    .sc(schemas_0.CreateEksAnywhereSubscription$)
    .build() {
}

class CreateFargateProfileCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateFargateProfile", {})
    .n("EKSClient", "CreateFargateProfileCommand")
    .sc(schemas_0.CreateFargateProfile$)
    .build() {
}

class CreateNodegroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreateNodegroup", {})
    .n("EKSClient", "CreateNodegroupCommand")
    .sc(schemas_0.CreateNodegroup$)
    .build() {
}

class CreatePodIdentityAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "CreatePodIdentityAssociation", {})
    .n("EKSClient", "CreatePodIdentityAssociationCommand")
    .sc(schemas_0.CreatePodIdentityAssociation$)
    .build() {
}

class DeleteAccessEntryCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteAccessEntry", {})
    .n("EKSClient", "DeleteAccessEntryCommand")
    .sc(schemas_0.DeleteAccessEntry$)
    .build() {
}

class DeleteAddonCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteAddon", {})
    .n("EKSClient", "DeleteAddonCommand")
    .sc(schemas_0.DeleteAddon$)
    .build() {
}

class DeleteCapabilityCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteCapability", {})
    .n("EKSClient", "DeleteCapabilityCommand")
    .sc(schemas_0.DeleteCapability$)
    .build() {
}

class DeleteClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteCluster", {})
    .n("EKSClient", "DeleteClusterCommand")
    .sc(schemas_0.DeleteCluster$)
    .build() {
}

class DeleteEksAnywhereSubscriptionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteEksAnywhereSubscription", {})
    .n("EKSClient", "DeleteEksAnywhereSubscriptionCommand")
    .sc(schemas_0.DeleteEksAnywhereSubscription$)
    .build() {
}

class DeleteFargateProfileCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteFargateProfile", {})
    .n("EKSClient", "DeleteFargateProfileCommand")
    .sc(schemas_0.DeleteFargateProfile$)
    .build() {
}

class DeleteNodegroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeleteNodegroup", {})
    .n("EKSClient", "DeleteNodegroupCommand")
    .sc(schemas_0.DeleteNodegroup$)
    .build() {
}

class DeletePodIdentityAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeletePodIdentityAssociation", {})
    .n("EKSClient", "DeletePodIdentityAssociationCommand")
    .sc(schemas_0.DeletePodIdentityAssociation$)
    .build() {
}

class DeregisterClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DeregisterCluster", {})
    .n("EKSClient", "DeregisterClusterCommand")
    .sc(schemas_0.DeregisterCluster$)
    .build() {
}

class DescribeAccessEntryCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeAccessEntry", {})
    .n("EKSClient", "DescribeAccessEntryCommand")
    .sc(schemas_0.DescribeAccessEntry$)
    .build() {
}

class DescribeAddonCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeAddon", {})
    .n("EKSClient", "DescribeAddonCommand")
    .sc(schemas_0.DescribeAddon$)
    .build() {
}

class DescribeAddonConfigurationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeAddonConfiguration", {})
    .n("EKSClient", "DescribeAddonConfigurationCommand")
    .sc(schemas_0.DescribeAddonConfiguration$)
    .build() {
}

class DescribeAddonVersionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeAddonVersions", {})
    .n("EKSClient", "DescribeAddonVersionsCommand")
    .sc(schemas_0.DescribeAddonVersions$)
    .build() {
}

class DescribeCapabilityCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeCapability", {})
    .n("EKSClient", "DescribeCapabilityCommand")
    .sc(schemas_0.DescribeCapability$)
    .build() {
}

class DescribeClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeCluster", {})
    .n("EKSClient", "DescribeClusterCommand")
    .sc(schemas_0.DescribeCluster$)
    .build() {
}

class DescribeClusterVersionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeClusterVersions", {})
    .n("EKSClient", "DescribeClusterVersionsCommand")
    .sc(schemas_0.DescribeClusterVersions$)
    .build() {
}

class DescribeEksAnywhereSubscriptionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeEksAnywhereSubscription", {})
    .n("EKSClient", "DescribeEksAnywhereSubscriptionCommand")
    .sc(schemas_0.DescribeEksAnywhereSubscription$)
    .build() {
}

class DescribeFargateProfileCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeFargateProfile", {})
    .n("EKSClient", "DescribeFargateProfileCommand")
    .sc(schemas_0.DescribeFargateProfile$)
    .build() {
}

class DescribeIdentityProviderConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeIdentityProviderConfig", {})
    .n("EKSClient", "DescribeIdentityProviderConfigCommand")
    .sc(schemas_0.DescribeIdentityProviderConfig$)
    .build() {
}

class DescribeInsightCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeInsight", {})
    .n("EKSClient", "DescribeInsightCommand")
    .sc(schemas_0.DescribeInsight$)
    .build() {
}

class DescribeInsightsRefreshCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeInsightsRefresh", {})
    .n("EKSClient", "DescribeInsightsRefreshCommand")
    .sc(schemas_0.DescribeInsightsRefresh$)
    .build() {
}

class DescribeNodegroupCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeNodegroup", {})
    .n("EKSClient", "DescribeNodegroupCommand")
    .sc(schemas_0.DescribeNodegroup$)
    .build() {
}

class DescribePodIdentityAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribePodIdentityAssociation", {})
    .n("EKSClient", "DescribePodIdentityAssociationCommand")
    .sc(schemas_0.DescribePodIdentityAssociation$)
    .build() {
}

class DescribeUpdateCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DescribeUpdate", {})
    .n("EKSClient", "DescribeUpdateCommand")
    .sc(schemas_0.DescribeUpdate$)
    .build() {
}

class DisassociateAccessPolicyCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DisassociateAccessPolicy", {})
    .n("EKSClient", "DisassociateAccessPolicyCommand")
    .sc(schemas_0.DisassociateAccessPolicy$)
    .build() {
}

class DisassociateIdentityProviderConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "DisassociateIdentityProviderConfig", {})
    .n("EKSClient", "DisassociateIdentityProviderConfigCommand")
    .sc(schemas_0.DisassociateIdentityProviderConfig$)
    .build() {
}

class ListAccessEntriesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListAccessEntries", {})
    .n("EKSClient", "ListAccessEntriesCommand")
    .sc(schemas_0.ListAccessEntries$)
    .build() {
}

class ListAccessPoliciesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListAccessPolicies", {})
    .n("EKSClient", "ListAccessPoliciesCommand")
    .sc(schemas_0.ListAccessPolicies$)
    .build() {
}

class ListAddonsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListAddons", {})
    .n("EKSClient", "ListAddonsCommand")
    .sc(schemas_0.ListAddons$)
    .build() {
}

class ListAssociatedAccessPoliciesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListAssociatedAccessPolicies", {})
    .n("EKSClient", "ListAssociatedAccessPoliciesCommand")
    .sc(schemas_0.ListAssociatedAccessPolicies$)
    .build() {
}

class ListCapabilitiesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListCapabilities", {})
    .n("EKSClient", "ListCapabilitiesCommand")
    .sc(schemas_0.ListCapabilities$)
    .build() {
}

class ListClustersCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListClusters", {})
    .n("EKSClient", "ListClustersCommand")
    .sc(schemas_0.ListClusters$)
    .build() {
}

class ListEksAnywhereSubscriptionsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListEksAnywhereSubscriptions", {})
    .n("EKSClient", "ListEksAnywhereSubscriptionsCommand")
    .sc(schemas_0.ListEksAnywhereSubscriptions$)
    .build() {
}

class ListFargateProfilesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListFargateProfiles", {})
    .n("EKSClient", "ListFargateProfilesCommand")
    .sc(schemas_0.ListFargateProfiles$)
    .build() {
}

class ListIdentityProviderConfigsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListIdentityProviderConfigs", {})
    .n("EKSClient", "ListIdentityProviderConfigsCommand")
    .sc(schemas_0.ListIdentityProviderConfigs$)
    .build() {
}

class ListInsightsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListInsights", {})
    .n("EKSClient", "ListInsightsCommand")
    .sc(schemas_0.ListInsights$)
    .build() {
}

class ListNodegroupsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListNodegroups", {})
    .n("EKSClient", "ListNodegroupsCommand")
    .sc(schemas_0.ListNodegroups$)
    .build() {
}

class ListPodIdentityAssociationsCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListPodIdentityAssociations", {})
    .n("EKSClient", "ListPodIdentityAssociationsCommand")
    .sc(schemas_0.ListPodIdentityAssociations$)
    .build() {
}

class ListTagsForResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListTagsForResource", {})
    .n("EKSClient", "ListTagsForResourceCommand")
    .sc(schemas_0.ListTagsForResource$)
    .build() {
}

class ListUpdatesCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "ListUpdates", {})
    .n("EKSClient", "ListUpdatesCommand")
    .sc(schemas_0.ListUpdates$)
    .build() {
}

class RegisterClusterCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "RegisterCluster", {})
    .n("EKSClient", "RegisterClusterCommand")
    .sc(schemas_0.RegisterCluster$)
    .build() {
}

class StartInsightsRefreshCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "StartInsightsRefresh", {})
    .n("EKSClient", "StartInsightsRefreshCommand")
    .sc(schemas_0.StartInsightsRefresh$)
    .build() {
}

class TagResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "TagResource", {})
    .n("EKSClient", "TagResourceCommand")
    .sc(schemas_0.TagResource$)
    .build() {
}

class UntagResourceCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UntagResource", {})
    .n("EKSClient", "UntagResourceCommand")
    .sc(schemas_0.UntagResource$)
    .build() {
}

class UpdateAccessEntryCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateAccessEntry", {})
    .n("EKSClient", "UpdateAccessEntryCommand")
    .sc(schemas_0.UpdateAccessEntry$)
    .build() {
}

class UpdateAddonCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateAddon", {})
    .n("EKSClient", "UpdateAddonCommand")
    .sc(schemas_0.UpdateAddon$)
    .build() {
}

class UpdateCapabilityCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateCapability", {})
    .n("EKSClient", "UpdateCapabilityCommand")
    .sc(schemas_0.UpdateCapability$)
    .build() {
}

class UpdateClusterConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateClusterConfig", {})
    .n("EKSClient", "UpdateClusterConfigCommand")
    .sc(schemas_0.UpdateClusterConfig$)
    .build() {
}

class UpdateClusterVersionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateClusterVersion", {})
    .n("EKSClient", "UpdateClusterVersionCommand")
    .sc(schemas_0.UpdateClusterVersion$)
    .build() {
}

class UpdateEksAnywhereSubscriptionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateEksAnywhereSubscription", {})
    .n("EKSClient", "UpdateEksAnywhereSubscriptionCommand")
    .sc(schemas_0.UpdateEksAnywhereSubscription$)
    .build() {
}

class UpdateNodegroupConfigCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateNodegroupConfig", {})
    .n("EKSClient", "UpdateNodegroupConfigCommand")
    .sc(schemas_0.UpdateNodegroupConfig$)
    .build() {
}

class UpdateNodegroupVersionCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdateNodegroupVersion", {})
    .n("EKSClient", "UpdateNodegroupVersionCommand")
    .sc(schemas_0.UpdateNodegroupVersion$)
    .build() {
}

class UpdatePodIdentityAssociationCommand extends client.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AWSWesleyFrontend", "UpdatePodIdentityAssociation", {})
    .n("EKSClient", "UpdatePodIdentityAssociationCommand")
    .sc(schemas_0.UpdatePodIdentityAssociation$)
    .build() {
}

const paginateDescribeAddonVersions = core.createPaginator(EKSClient, DescribeAddonVersionsCommand, "nextToken", "nextToken", "maxResults");

const paginateDescribeClusterVersions = core.createPaginator(EKSClient, DescribeClusterVersionsCommand, "nextToken", "nextToken", "maxResults");

const paginateListAccessEntries = core.createPaginator(EKSClient, ListAccessEntriesCommand, "nextToken", "nextToken", "maxResults");

const paginateListAccessPolicies = core.createPaginator(EKSClient, ListAccessPoliciesCommand, "nextToken", "nextToken", "maxResults");

const paginateListAddons = core.createPaginator(EKSClient, ListAddonsCommand, "nextToken", "nextToken", "maxResults");

const paginateListAssociatedAccessPolicies = core.createPaginator(EKSClient, ListAssociatedAccessPoliciesCommand, "nextToken", "nextToken", "maxResults");

const paginateListCapabilities = core.createPaginator(EKSClient, ListCapabilitiesCommand, "nextToken", "nextToken", "maxResults");

const paginateListClusters = core.createPaginator(EKSClient, ListClustersCommand, "nextToken", "nextToken", "maxResults");

const paginateListEksAnywhereSubscriptions = core.createPaginator(EKSClient, ListEksAnywhereSubscriptionsCommand, "nextToken", "nextToken", "maxResults");

const paginateListFargateProfiles = core.createPaginator(EKSClient, ListFargateProfilesCommand, "nextToken", "nextToken", "maxResults");

const paginateListIdentityProviderConfigs = core.createPaginator(EKSClient, ListIdentityProviderConfigsCommand, "nextToken", "nextToken", "maxResults");

const paginateListInsights = core.createPaginator(EKSClient, ListInsightsCommand, "nextToken", "nextToken", "maxResults");

const paginateListNodegroups = core.createPaginator(EKSClient, ListNodegroupsCommand, "nextToken", "nextToken", "maxResults");

const paginateListPodIdentityAssociations = core.createPaginator(EKSClient, ListPodIdentityAssociationsCommand, "nextToken", "nextToken", "maxResults");

const paginateListUpdates = core.createPaginator(EKSClient, ListUpdatesCommand, "nextToken", "nextToken", "maxResults");

const checkState$7 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeAddonCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.addon.status;
            };
            if (returnComparator() === "CREATE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.addon.status;
            };
            if (returnComparator() === "DEGRADED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.addon.status;
            };
            if (returnComparator() === "ACTIVE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForAddonActive = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
};
const waitUntilAddonActive = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
    return client.checkExceptions(result);
};

const checkState$6 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeAddonCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.addon.status;
            };
            if (returnComparator() === "DELETE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ResourceNotFoundException") {
            return { state: client.WaiterState.SUCCESS, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForAddonDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
};
const waitUntilAddonDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
    return client.checkExceptions(result);
};

const checkState$5 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeClusterCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "DELETING") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "ACTIVE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForClusterActive = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
};
const waitUntilClusterActive = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
    return client.checkExceptions(result);
};

const checkState$4 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeClusterCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "ACTIVE") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "CREATING") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.cluster.status;
            };
            if (returnComparator() === "PENDING") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ResourceNotFoundException") {
            return { state: client.WaiterState.SUCCESS, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForClusterDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
};
const waitUntilClusterDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
    return client.checkExceptions(result);
};

const checkState$3 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeFargateProfileCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.fargateProfile.status;
            };
            if (returnComparator() === "CREATE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.fargateProfile.status;
            };
            if (returnComparator() === "ACTIVE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForFargateProfileActive = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
};
const waitUntilFargateProfileActive = async (params, input) => {
    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
    return client.checkExceptions(result);
};

const checkState$2 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeFargateProfileCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.fargateProfile.status;
            };
            if (returnComparator() === "DELETE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ResourceNotFoundException") {
            return { state: client.WaiterState.SUCCESS, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForFargateProfileDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
};
const waitUntilFargateProfileDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
    return client.checkExceptions(result);
};

const checkState$1 = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeNodegroupCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.nodegroup.status;
            };
            if (returnComparator() === "CREATE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
        try {
            const returnComparator = () => {
                return result.nodegroup.status;
            };
            if (returnComparator() === "ACTIVE") {
                return { state: client.WaiterState.SUCCESS, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForNodegroupActive = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
};
const waitUntilNodegroupActive = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
    return client.checkExceptions(result);
};

const checkState = async (client$1, input) => {
    let reason;
    try {
        let result = await client$1.send(new DescribeNodegroupCommand(input));
        reason = result;
        try {
            const returnComparator = () => {
                return result.nodegroup.status;
            };
            if (returnComparator() === "DELETE_FAILED") {
                return { state: client.WaiterState.FAILURE, reason };
            }
        }
        catch (e) { }
    }
    catch (exception) {
        reason = exception;
        if (exception.name === "ResourceNotFoundException") {
            return { state: client.WaiterState.SUCCESS, reason };
        }
    }
    return { state: client.WaiterState.RETRY, reason };
};
const waitForNodegroupDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
};
const waitUntilNodegroupDeleted = async (params, input) => {
    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
    return client.checkExceptions(result);
};

const commands = {
    AssociateAccessPolicyCommand,
    AssociateEncryptionConfigCommand,
    AssociateIdentityProviderConfigCommand,
    CreateAccessEntryCommand,
    CreateAddonCommand,
    CreateCapabilityCommand,
    CreateClusterCommand,
    CreateEksAnywhereSubscriptionCommand,
    CreateFargateProfileCommand,
    CreateNodegroupCommand,
    CreatePodIdentityAssociationCommand,
    DeleteAccessEntryCommand,
    DeleteAddonCommand,
    DeleteCapabilityCommand,
    DeleteClusterCommand,
    DeleteEksAnywhereSubscriptionCommand,
    DeleteFargateProfileCommand,
    DeleteNodegroupCommand,
    DeletePodIdentityAssociationCommand,
    DeregisterClusterCommand,
    DescribeAccessEntryCommand,
    DescribeAddonCommand,
    DescribeAddonConfigurationCommand,
    DescribeAddonVersionsCommand,
    DescribeCapabilityCommand,
    DescribeClusterCommand,
    DescribeClusterVersionsCommand,
    DescribeEksAnywhereSubscriptionCommand,
    DescribeFargateProfileCommand,
    DescribeIdentityProviderConfigCommand,
    DescribeInsightCommand,
    DescribeInsightsRefreshCommand,
    DescribeNodegroupCommand,
    DescribePodIdentityAssociationCommand,
    DescribeUpdateCommand,
    DisassociateAccessPolicyCommand,
    DisassociateIdentityProviderConfigCommand,
    ListAccessEntriesCommand,
    ListAccessPoliciesCommand,
    ListAddonsCommand,
    ListAssociatedAccessPoliciesCommand,
    ListCapabilitiesCommand,
    ListClustersCommand,
    ListEksAnywhereSubscriptionsCommand,
    ListFargateProfilesCommand,
    ListIdentityProviderConfigsCommand,
    ListInsightsCommand,
    ListNodegroupsCommand,
    ListPodIdentityAssociationsCommand,
    ListTagsForResourceCommand,
    ListUpdatesCommand,
    RegisterClusterCommand,
    StartInsightsRefreshCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateAccessEntryCommand,
    UpdateAddonCommand,
    UpdateCapabilityCommand,
    UpdateClusterConfigCommand,
    UpdateClusterVersionCommand,
    UpdateEksAnywhereSubscriptionCommand,
    UpdateNodegroupConfigCommand,
    UpdateNodegroupVersionCommand,
    UpdatePodIdentityAssociationCommand,
};
const paginators = {
    paginateDescribeAddonVersions,
    paginateDescribeClusterVersions,
    paginateListAccessEntries,
    paginateListAccessPolicies,
    paginateListAddons,
    paginateListAssociatedAccessPolicies,
    paginateListCapabilities,
    paginateListClusters,
    paginateListEksAnywhereSubscriptions,
    paginateListFargateProfiles,
    paginateListIdentityProviderConfigs,
    paginateListInsights,
    paginateListNodegroups,
    paginateListPodIdentityAssociations,
    paginateListUpdates,
};
const waiters = {
    waitUntilAddonActive,
    waitUntilAddonDeleted,
    waitUntilClusterActive,
    waitUntilClusterDeleted,
    waitUntilFargateProfileActive,
    waitUntilFargateProfileDeleted,
    waitUntilNodegroupActive,
    waitUntilNodegroupDeleted,
};
class EKS extends EKSClient {
}
client.createAggregatedClient(commands, EKS, { paginators, waiters });

const AuthenticationMode = {
    API: "API",
    API_AND_CONFIG_MAP: "API_AND_CONFIG_MAP",
    CONFIG_MAP: "CONFIG_MAP",
};
const AccessScopeType = {
    cluster: "cluster",
    namespace: "namespace",
};
const AddonIssueCode = {
    ACCESS_DENIED: "AccessDenied",
    ADDON_PERMISSION_FAILURE: "AddonPermissionFailure",
    ADDON_SUBSCRIPTION_NEEDED: "AddonSubscriptionNeeded",
    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",
};
const AddonStatus = {
    ACTIVE: "ACTIVE",
    CREATE_FAILED: "CREATE_FAILED",
    CREATING: "CREATING",
    DEGRADED: "DEGRADED",
    DELETE_FAILED: "DELETE_FAILED",
    DELETING: "DELETING",
    UPDATE_FAILED: "UPDATE_FAILED",
    UPDATING: "UPDATING",
};
const AMITypes = {
    AL2023_ARM_64_NVIDIA: "AL2023_ARM_64_NVIDIA",
    AL2023_ARM_64_STANDARD: "AL2023_ARM_64_STANDARD",
    AL2023_x86_64_NEURON: "AL2023_x86_64_NEURON",
    AL2023_x86_64_NVIDIA: "AL2023_x86_64_NVIDIA",
    AL2023_x86_64_STANDARD: "AL2023_x86_64_STANDARD",
    AL2_ARM_64: "AL2_ARM_64",
    AL2_x86_64: "AL2_x86_64",
    AL2_x86_64_GPU: "AL2_x86_64_GPU",
    BOTTLEROCKET_ARM_64: "BOTTLEROCKET_ARM_64",
    BOTTLEROCKET_ARM_64_FIPS: "BOTTLEROCKET_ARM_64_FIPS",
    BOTTLEROCKET_ARM_64_NVIDIA: "BOTTLEROCKET_ARM_64_NVIDIA",
    BOTTLEROCKET_ARM_64_NVIDIA_FIPS: "BOTTLEROCKET_ARM_64_NVIDIA_FIPS",
    BOTTLEROCKET_x86_64: "BOTTLEROCKET_x86_64",
    BOTTLEROCKET_x86_64_FIPS: "BOTTLEROCKET_x86_64_FIPS",
    BOTTLEROCKET_x86_64_NVIDIA: "BOTTLEROCKET_x86_64_NVIDIA",
    BOTTLEROCKET_x86_64_NVIDIA_FIPS: "BOTTLEROCKET_x86_64_NVIDIA_FIPS",
    CUSTOM: "CUSTOM",
    WINDOWS_CORE_2019_x86_64: "WINDOWS_CORE_2019_x86_64",
    WINDOWS_CORE_2022_x86_64: "WINDOWS_CORE_2022_x86_64",
    WINDOWS_CORE_2025_x86_64: "WINDOWS_CORE_2025_x86_64",
    WINDOWS_FULL_2019_x86_64: "WINDOWS_FULL_2019_x86_64",
    WINDOWS_FULL_2022_x86_64: "WINDOWS_FULL_2022_x86_64",
    WINDOWS_FULL_2025_x86_64: "WINDOWS_FULL_2025_x86_64",
};
const SsoIdentityType = {
    SSO_GROUP: "SSO_GROUP",
    SSO_USER: "SSO_USER",
};
const ArgoCdRole = {
    ADMIN: "ADMIN",
    EDITOR: "EDITOR",
    VIEWER: "VIEWE