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

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

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AMITypes: () => AMITypes,
  AccessDeniedException: () => AccessDeniedException,
  AccessScopeType: () => AccessScopeType,
  AddonIssueCode: () => AddonIssueCode,
  AddonStatus: () => AddonStatus,
  AssociateAccessPolicyCommand: () => AssociateAccessPolicyCommand,
  AssociateEncryptionConfigCommand: () => AssociateEncryptionConfigCommand,
  AssociateIdentityProviderConfigCommand: () => AssociateIdentityProviderConfigCommand,
  AuthenticationMode: () => AuthenticationMode,
  BadRequestException: () => BadRequestException,
  CapacityTypes: () => CapacityTypes,
  Category: () => Category,
  ClientException: () => ClientException,
  ClusterIssueCode: () => ClusterIssueCode,
  ClusterStatus: () => ClusterStatus,
  ClusterVersionStatus: () => ClusterVersionStatus,
  ConfigStatus: () => ConfigStatus,
  ConnectorConfigProvider: () => ConnectorConfigProvider,
  CreateAccessEntryCommand: () => CreateAccessEntryCommand,
  CreateAddonCommand: () => CreateAddonCommand,
  CreateClusterCommand: () => CreateClusterCommand,
  CreateEksAnywhereSubscriptionCommand: () => CreateEksAnywhereSubscriptionCommand,
  CreateFargateProfileCommand: () => CreateFargateProfileCommand,
  CreateNodegroupCommand: () => CreateNodegroupCommand,
  CreatePodIdentityAssociationCommand: () => CreatePodIdentityAssociationCommand,
  DeleteAccessEntryCommand: () => DeleteAccessEntryCommand,
  DeleteAddonCommand: () => DeleteAddonCommand,
  DeleteClusterCommand: () => DeleteClusterCommand,
  DeleteEksAnywhereSubscriptionCommand: () => DeleteEksAnywhereSubscriptionCommand,
  DeleteFargateProfileCommand: () => DeleteFargateProfileCommand,
  DeleteNodegroupCommand: () => DeleteNodegroupCommand,
  DeletePodIdentityAssociationCommand: () => DeletePodIdentityAssociationCommand,
  DeregisterClusterCommand: () => DeregisterClusterCommand,
  DescribeAccessEntryCommand: () => DescribeAccessEntryCommand,
  DescribeAddonCommand: () => DescribeAddonCommand,
  DescribeAddonConfigurationCommand: () => DescribeAddonConfigurationCommand,
  DescribeAddonVersionsCommand: () => DescribeAddonVersionsCommand,
  DescribeClusterCommand: () => DescribeClusterCommand,
  DescribeClusterVersionsCommand: () => DescribeClusterVersionsCommand,
  DescribeEksAnywhereSubscriptionCommand: () => DescribeEksAnywhereSubscriptionCommand,
  DescribeFargateProfileCommand: () => DescribeFargateProfileCommand,
  DescribeIdentityProviderConfigCommand: () => DescribeIdentityProviderConfigCommand,
  DescribeInsightCommand: () => DescribeInsightCommand,
  DescribeNodegroupCommand: () => DescribeNodegroupCommand,
  DescribePodIdentityAssociationCommand: () => DescribePodIdentityAssociationCommand,
  DescribeUpdateCommand: () => DescribeUpdateCommand,
  DisassociateAccessPolicyCommand: () => DisassociateAccessPolicyCommand,
  DisassociateIdentityProviderConfigCommand: () => DisassociateIdentityProviderConfigCommand,
  EKS: () => EKS,
  EKSClient: () => EKSClient,
  EKSServiceException: () => EKSServiceException,
  EksAnywhereSubscriptionLicenseType: () => EksAnywhereSubscriptionLicenseType,
  EksAnywhereSubscriptionStatus: () => EksAnywhereSubscriptionStatus,
  EksAnywhereSubscriptionTermUnit: () => EksAnywhereSubscriptionTermUnit,
  ErrorCode: () => ErrorCode,
  FargateProfileIssueCode: () => FargateProfileIssueCode,
  FargateProfileStatus: () => FargateProfileStatus,
  InsightStatusValue: () => InsightStatusValue,
  InvalidParameterException: () => InvalidParameterException,
  InvalidRequestException: () => InvalidRequestException,
  IpFamily: () => IpFamily,
  ListAccessEntriesCommand: () => ListAccessEntriesCommand,
  ListAccessPoliciesCommand: () => ListAccessPoliciesCommand,
  ListAddonsCommand: () => ListAddonsCommand,
  ListAssociatedAccessPoliciesCommand: () => ListAssociatedAccessPoliciesCommand,
  ListClustersCommand: () => ListClustersCommand,
  ListEksAnywhereSubscriptionsCommand: () => ListEksAnywhereSubscriptionsCommand,
  ListFargateProfilesCommand: () => ListFargateProfilesCommand,
  ListIdentityProviderConfigsCommand: () => ListIdentityProviderConfigsCommand,
  ListInsightsCommand: () => ListInsightsCommand,
  ListNodegroupsCommand: () => ListNodegroupsCommand,
  ListPodIdentityAssociationsCommand: () => ListPodIdentityAssociationsCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ListUpdatesCommand: () => ListUpdatesCommand,
  LogType: () => LogType,
  NodegroupIssueCode: () => NodegroupIssueCode,
  NodegroupStatus: () => NodegroupStatus,
  NodegroupUpdateStrategies: () => NodegroupUpdateStrategies,
  NotFoundException: () => NotFoundException,
  RegisterClusterCommand: () => RegisterClusterCommand,
  ResolveConflicts: () => ResolveConflicts,
  ResourceInUseException: () => ResourceInUseException,
  ResourceLimitExceededException: () => ResourceLimitExceededException,
  ResourceNotFoundException: () => ResourceNotFoundException,
  ResourcePropagationDelayException: () => ResourcePropagationDelayException,
  ServerException: () => ServerException,
  ServiceUnavailableException: () => ServiceUnavailableException,
  SupportType: () => SupportType,
  TagResourceCommand: () => TagResourceCommand,
  TaintEffect: () => TaintEffect,
  UnsupportedAvailabilityZoneException: () => UnsupportedAvailabilityZoneException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateAccessEntryCommand: () => UpdateAccessEntryCommand,
  UpdateAddonCommand: () => UpdateAddonCommand,
  UpdateClusterConfigCommand: () => UpdateClusterConfigCommand,
  UpdateClusterVersionCommand: () => UpdateClusterVersionCommand,
  UpdateEksAnywhereSubscriptionCommand: () => UpdateEksAnywhereSubscriptionCommand,
  UpdateNodegroupConfigCommand: () => UpdateNodegroupConfigCommand,
  UpdateNodegroupVersionCommand: () => UpdateNodegroupVersionCommand,
  UpdateParamType: () => UpdateParamType,
  UpdatePodIdentityAssociationCommand: () => UpdatePodIdentityAssociationCommand,
  UpdateStatus: () => UpdateStatus,
  UpdateType: () => UpdateType,
  VersionStatus: () => VersionStatus,
  __Client: () => import_smithy_client.Client,
  paginateDescribeAddonVersions: () => paginateDescribeAddonVersions,
  paginateDescribeClusterVersions: () => paginateDescribeClusterVersions,
  paginateListAccessEntries: () => paginateListAccessEntries,
  paginateListAccessPolicies: () => paginateListAccessPolicies,
  paginateListAddons: () => paginateListAddons,
  paginateListAssociatedAccessPolicies: () => paginateListAssociatedAccessPolicies,
  paginateListClusters: () => paginateListClusters,
  paginateListEksAnywhereSubscriptions: () => paginateListEksAnywhereSubscriptions,
  paginateListFargateProfiles: () => paginateListFargateProfiles,
  paginateListIdentityProviderConfigs: () => paginateListIdentityProviderConfigs,
  paginateListInsights: () => paginateListInsights,
  paginateListNodegroups: () => paginateListNodegroups,
  paginateListPodIdentityAssociations: () => paginateListPodIdentityAssociations,
  paginateListUpdates: () => paginateListUpdates,
  waitForAddonActive: () => waitForAddonActive,
  waitForAddonDeleted: () => waitForAddonDeleted,
  waitForClusterActive: () => waitForClusterActive,
  waitForClusterDeleted: () => waitForClusterDeleted,
  waitForFargateProfileActive: () => waitForFargateProfileActive,
  waitForFargateProfileDeleted: () => waitForFargateProfileDeleted,
  waitForNodegroupActive: () => waitForNodegroupActive,
  waitForNodegroupDeleted: () => waitForNodegroupDeleted,
  waitUntilAddonActive: () => waitUntilAddonActive,
  waitUntilAddonDeleted: () => waitUntilAddonDeleted,
  waitUntilClusterActive: () => waitUntilClusterActive,
  waitUntilClusterDeleted: () => waitUntilClusterDeleted,
  waitUntilFargateProfileActive: () => waitUntilFargateProfileActive,
  waitUntilFargateProfileDeleted: () => waitUntilFargateProfileDeleted,
  waitUntilNodegroupActive: () => waitUntilNodegroupActive,
  waitUntilNodegroupDeleted: () => waitUntilNodegroupDeleted
});
module.exports = __toCommonJS(src_exports);

// src/EKSClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "eks"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/EKSClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((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;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = {
    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
  };
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return {
    ...runtimeConfig,
    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/EKSClient.ts
var EKSClient = class extends import_smithy_client.Client {
  static {
    __name(this, "EKSClient");
  }
  /**
   * The resolved configuration of EKSClient class. This is resolved and normalized from the {@link EKSClientConfig | constructor configuration interface}.
   */
  config;
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
    super(_config_8);
    this.config = _config_8;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultEKSHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        })
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};

// src/EKS.ts


// src/commands/AssociateAccessPolicyCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_restJson1.ts
var import_core2 = require("@aws-sdk/core");


var import_uuid = require("uuid");

// src/models/EKSServiceException.ts

var EKSServiceException = class _EKSServiceException extends import_smithy_client.ServiceException {
  static {
    __name(this, "EKSServiceException");
  }
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _EKSServiceException.prototype);
  }
};

// src/models/models_0.ts
var AuthenticationMode = {
  API: "API",
  API_AND_CONFIG_MAP: "API_AND_CONFIG_MAP",
  CONFIG_MAP: "CONFIG_MAP"
};
var AccessDeniedException = class _AccessDeniedException extends EKSServiceException {
  static {
    __name(this, "AccessDeniedException");
  }
  name = "AccessDeniedException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AccessDeniedException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
  }
};
var AccessScopeType = {
  cluster: "cluster",
  namespace: "namespace"
};
var 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"
};
var AddonStatus = {
  ACTIVE: "ACTIVE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATING: "CREATING",
  DEGRADED: "DEGRADED",
  DELETE_FAILED: "DELETE_FAILED",
  DELETING: "DELETING",
  UPDATE_FAILED: "UPDATE_FAILED",
  UPDATING: "UPDATING"
};
var AMITypes = {
  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_NVIDIA: "BOTTLEROCKET_ARM_64_NVIDIA",
  BOTTLEROCKET_x86_64: "BOTTLEROCKET_x86_64",
  BOTTLEROCKET_x86_64_NVIDIA: "BOTTLEROCKET_x86_64_NVIDIA",
  CUSTOM: "CUSTOM",
  WINDOWS_CORE_2019_x86_64: "WINDOWS_CORE_2019_x86_64",
  WINDOWS_CORE_2022_x86_64: "WINDOWS_CORE_2022_x86_64",
  WINDOWS_FULL_2019_x86_64: "WINDOWS_FULL_2019_x86_64",
  WINDOWS_FULL_2022_x86_64: "WINDOWS_FULL_2022_x86_64"
};
var InvalidParameterException = class _InvalidParameterException extends EKSServiceException {
  static {
    __name(this, "InvalidParameterException");
  }
  name = "InvalidParameterException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The Fargate profile associated with the exception.</p>
   * @public
   */
  fargateProfileName;
  /**
   * <p>The specified parameter for the add-on name is invalid. Review the available
   *             parameters for the API request</p>
   * @public
   */
  addonName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.fargateProfileName = opts.fargateProfileName;
    this.addonName = opts.addonName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var InvalidRequestException = class _InvalidRequestException extends EKSServiceException {
  static {
    __name(this, "InvalidRequestException");
  }
  name = "InvalidRequestException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The request is invalid given the state of the add-on name. Check the state of the
   *             cluster and the associated operations.</p>
   * @public
   */
  addonName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidRequestException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.addonName = opts.addonName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var ResourceNotFoundException = class _ResourceNotFoundException extends EKSServiceException {
  static {
    __name(this, "ResourceNotFoundException");
  }
  name = "ResourceNotFoundException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The Fargate profile associated with the exception.</p>
   * @public
   */
  fargateProfileName;
  /**
   * <p>The Amazon EKS add-on name associated with the exception.</p>
   * @public
   */
  addonName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.fargateProfileName = opts.fargateProfileName;
    this.addonName = opts.addonName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var ServerException = class _ServerException extends EKSServiceException {
  static {
    __name(this, "ServerException");
  }
  name = "ServerException";
  $fault = "server";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The Amazon EKS add-on name associated with the exception.</p>
   * @public
   */
  addonName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServerException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ServerException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.addonName = opts.addonName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var 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"
};
var UpdateParamType = {
  ADDON_VERSION: "AddonVersion",
  AUTHENTICATION_MODE: "AuthenticationMode",
  CLUSTER_LOGGING: "ClusterLogging",
  COMPUTE_CONFIG: "ComputeConfig",
  CONFIGURATION_VALUES: "ConfigurationValues",
  DESIRED_SIZE: "DesiredSize",
  ENCRYPTION_CONFIG: "EncryptionConfig",
  ENDPOINT_PRIVATE_ACCESS: "EndpointPrivateAccess",
  ENDPOINT_PUBLIC_ACCESS: "EndpointPublicAccess",
  IDENTITY_PROVIDER_CONFIG: "IdentityProviderConfig",
  KUBERNETES_NETWORK_CONFIG: "KubernetesNetworkConfig",
  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",
  NODE_REPAIR_ENABLED: "NodeRepairEnabled",
  PLATFORM_VERSION: "PlatformVersion",
  POD_IDENTITY_ASSOCIATIONS: "PodIdentityAssociations",
  PUBLIC_ACCESS_CIDRS: "PublicAccessCidrs",
  RELEASE_VERSION: "ReleaseVersion",
  RESOLVE_CONFLICTS: "ResolveConflicts",
  SECURITY_GROUPS: "SecurityGroups",
  SERVICE_ACCOUNT_ROLE_ARN: "ServiceAccountRoleArn",
  STORAGE_CONFIG: "StorageConfig",
  SUBNETS: "Subnets",
  TAINTS_TO_ADD: "TaintsToAdd",
  TAINTS_TO_REMOVE: "TaintsToRemove",
  UPDATE_STRATEGY: "UpdateStrategy",
  UPGRADE_POLICY: "UpgradePolicy",
  VERSION: "Version",
  ZONAL_SHIFT_CONFIG: "ZonalShiftConfig"
};
var UpdateStatus = {
  CANCELLED: "Cancelled",
  FAILED: "Failed",
  IN_PROGRESS: "InProgress",
  SUCCESSFUL: "Successful"
};
var UpdateType = {
  ACCESS_CONFIG_UPDATE: "AccessConfigUpdate",
  ADDON_UPDATE: "AddonUpdate",
  ASSOCIATE_ENCRYPTION_CONFIG: "AssociateEncryptionConfig",
  ASSOCIATE_IDENTITY_PROVIDER_CONFIG: "AssociateIdentityProviderConfig",
  AUTO_MODE_UPDATE: "AutoModeUpdate",
  CONFIG_UPDATE: "ConfigUpdate",
  DISASSOCIATE_IDENTITY_PROVIDER_CONFIG: "DisassociateIdentityProviderConfig",
  ENDPOINT_ACCESS_UPDATE: "EndpointAccessUpdate",
  LOGGING_UPDATE: "LoggingUpdate",
  UPGRADE_POLICY_UPDATE: "UpgradePolicyUpdate",
  VERSION_UPDATE: "VersionUpdate",
  VPC_CONFIG_UPDATE: "VpcConfigUpdate",
  ZONAL_SHIFT_CONFIG_UPDATE: "ZonalShiftConfigUpdate"
};
var ClientException = class _ClientException extends EKSServiceException {
  static {
    __name(this, "ClientException");
  }
  name = "ClientException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The Amazon EKS add-on name associated with the exception.</p>
   * @public
   */
  addonName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ClientException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ClientException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.addonName = opts.addonName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var ResourceInUseException = class _ResourceInUseException extends EKSServiceException {
  static {
    __name(this, "ResourceInUseException");
  }
  name = "ResourceInUseException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The specified add-on name is in use.</p>
   * @public
   */
  addonName;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceInUseException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.addonName = opts.addonName;
  }
};
var ResourceLimitExceededException = class _ResourceLimitExceededException extends EKSServiceException {
  static {
    __name(this, "ResourceLimitExceededException");
  }
  name = "ResourceLimitExceededException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The Amazon EKS subscription ID with the exception.</p>
   * @public
   */
  subscriptionId;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceLimitExceededException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourceLimitExceededException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.subscriptionId = opts.subscriptionId;
  }
};
var ResolveConflicts = {
  NONE: "NONE",
  OVERWRITE: "OVERWRITE",
  PRESERVE: "PRESERVE"
};
var IpFamily = {
  IPV4: "ipv4",
  IPV6: "ipv6"
};
var LogType = {
  API: "api",
  AUDIT: "audit",
  AUTHENTICATOR: "authenticator",
  CONTROLLER_MANAGER: "controllerManager",
  SCHEDULER: "scheduler"
};
var SupportType = {
  EXTENDED: "EXTENDED",
  STANDARD: "STANDARD"
};
var ClusterIssueCode = {
  ACCESS_DENIED: "AccessDenied",
  CLUSTER_UNREACHABLE: "ClusterUnreachable",
  CONFIGURATION_CONFLICT: "ConfigurationConflict",
  EC2_SECURITY_GROUP_NOT_FOUND: "Ec2SecurityGroupNotFound",
  EC2_SERVICE_NOT_SUBSCRIBED: "Ec2ServiceNotSubscribed",
  EC2_SUBNET_NOT_FOUND: "Ec2SubnetNotFound",
  IAM_ROLE_NOT_FOUND: "IamRoleNotFound",
  INSUFFICIENT_FREE_ADDRESSES: "InsufficientFreeAddresses",
  INTERNAL_FAILURE: "InternalFailure",
  KMS_GRANT_REVOKED: "KmsGrantRevoked",
  KMS_KEY_DISABLED: "KmsKeyDisabled",
  KMS_KEY_MARKED_FOR_DELETION: "KmsKeyMarkedForDeletion",
  KMS_KEY_NOT_FOUND: "KmsKeyNotFound",
  OTHER: "Other",
  RESOURCE_LIMIT_EXCEEDED: "ResourceLimitExceeded",
  RESOURCE_NOT_FOUND: "ResourceNotFound",
  STS_REGIONAL_ENDPOINT_DISABLED: "StsRegionalEndpointDisabled",
  UNSUPPORTED_VERSION: "UnsupportedVersion",
  VPC_NOT_FOUND: "VpcNotFound"
};
var ClusterStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING",
  FAILED: "FAILED",
  PENDING: "PENDING",
  UPDATING: "UPDATING"
};
var ServiceUnavailableException = class _ServiceUnavailableException extends EKSServiceException {
  static {
    __name(this, "ServiceUnavailableException");
  }
  name = "ServiceUnavailableException";
  $fault = "server";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceUnavailableException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
  }
};
var UnsupportedAvailabilityZoneException = class _UnsupportedAvailabilityZoneException extends EKSServiceException {
  static {
    __name(this, "UnsupportedAvailabilityZoneException");
  }
  name = "UnsupportedAvailabilityZoneException";
  $fault = "client";
  /**
   * <p>The Amazon EKS cluster associated with the exception.</p>
   * @public
   */
  clusterName;
  /**
   * <p>The Amazon EKS managed node group associated with the exception.</p>
   * @public
   */
  nodegroupName;
  /**
   * <p>The supported Availability Zones for your account. Choose subnets in these Availability Zones for your
   *             cluster.</p>
   * @public
   */
  validZones;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedAvailabilityZoneException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _UnsupportedAvailabilityZoneException.prototype);
    this.clusterName = opts.clusterName;
    this.nodegroupName = opts.nodegroupName;
    this.validZones = opts.validZones;
  }
};
var EksAnywhereSubscriptionLicenseType = {
  Cluster: "Cluster"
};
var EksAnywhereSubscriptionTermUnit = {
  MONTHS: "MONTHS"
};
var FargateProfileIssueCode = {
  ACCESS_DENIED: "AccessDenied",
  CLUSTER_UNREACHABLE: "ClusterUnreachable",
  INTERNAL_FAILURE: "InternalFailure",
  POD_EXECUTION_ROLE_ALREADY_IN_USE: "PodExecutionRoleAlreadyInUse"
};
var FargateProfileStatus = {
  ACTIVE: "ACTIVE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATING: "CREATING",
  DELETE_FAILED: "DELETE_FAILED",
  DELETING: "DELETING"
};
var CapacityTypes = {
  CAPACITY_BLOCK: "CAPACITY_BLOCK",
  ON_DEMAND: "ON_DEMAND",
  SPOT: "SPOT"
};
var TaintEffect = {
  NO_EXECUTE: "NO_EXECUTE",
  NO_SCHEDULE: "NO_SCHEDULE",
  PREFER_NO_SCHEDULE: "PREFER_NO_SCHEDULE"
};
var NodegroupUpdateStrategies = {
  DEFAULT: "DEFAULT",
  MINIMAL: "MINIMAL"
};
var NodegroupIssueCode = {
  ACCESS_DENIED: "AccessDenied",
  AMI_ID_NOT_FOUND: "AmiIdNotFound",
  ASG_INSTANCE_LAUNCH_FAILURES: "AsgInstanceLaunchFailures",
  AUTO_SCALING_GROUP_INSTANCE_REFRESH_ACTIVE: "AutoScalingGroupInstanceRefreshActive",
  AUTO_SCALING_GROUP_INVALID_CONFIGURATION: "AutoScalingGroupInvalidConfiguration",
  AUTO_SCALING_GROUP_NOT_FOUND: "AutoScalingGroupNotFound",
  AUTO_SCALING_GROUP_OPT_IN_REQUIRED: "AutoScalingGroupOptInRequired",
  AUTO_SCALING_GROUP_RATE_LIMIT_EXCEEDED: "AutoScalingGroupRateLimitExceeded",
  CLUSTER_UNREACHABLE: "ClusterUnreachable",
  EC2_INSTANCE_TYPE_DOES_NOT_EXIST: "Ec2InstanceTypeDoesNotExist",
  EC2_LAUNCH_TEMPLATE_DELETION_FAILURE: "Ec2LaunchTemplateDeletionFailure",
  EC2_LAUNCH_TEMPLATE_INVALID_CONFIGURATION: "Ec2LaunchTemplateInvalidConfiguration",
  EC2_LAUNCH_TEMPLATE_MAX_LIMIT_EXCEEDED: "Ec2LaunchTemplateMaxLimitExceeded",
  EC2_LAUNCH_TEMPLATE_NOT_FOUND: "Ec2LaunchTemplateNotFound",
  EC2_LAUNCH_TEMPLATE_VERSION_MAX_LIMIT_EXCEEDED: "Ec2LaunchTemplateVersionMaxLimitExceeded",
  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_LIST_TOO_LONG: "Ec2SubnetListTooLong",
  EC2_SUBNET_MISSING_IPV6_ASSIGNMENT: "Ec2SubnetMissingIpv6Assignment",
  EC2_SUBNET_NOT_FOUND: "Ec2SubnetNotFound",
  IAM_INSTANCE_PROFILE_NOT_FOUND: "IamInstanceProfileNotFound",
  IAM_LIMIT_EXCEEDED: "IamLimitExceeded",
  IAM_NODE_ROLE_NOT_FOUND: "IamNodeRoleNotFound",
  IAM_THROTTLING: "IamThrottling",
  INSTANCE_LIMIT_EXCEEDED: "InstanceLimitExceeded",
  INSUFFICIENT_FREE_ADDRESSES: "InsufficientFreeAddresses",
  INTERNAL_FAILURE: "InternalFailure",
  KUBERNETES_LABEL_INVALID: "KubernetesLabelInvalid",
  LIMIT_EXCEEDED: "LimitExceeded",
  NODE_CREATION_FAILURE: "NodeCreationFailure",
  NODE_TERMINATION_FAILURE: "NodeTerminationFailure",
  POD_EVICTION_FAILURE: "PodEvictionFailure",
  SOURCE_EC2_LAUNCH_TEMPLATE_NOT_FOUND: "SourceEc2LaunchTemplateNotFound",
  UNKNOWN: "Unknown"
};
var NodegroupStatus = {
  ACTIVE: "ACTIVE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATING: "CREATING",
  DEGRADED: "DEGRADED",
  DELETE_FAILED: "DELETE_FAILED",
  DELETING: "DELETING",
  UPDATING: "UPDATING"
};
var ClusterVersionStatus = {
  extended_support: "extended-support",
  standard_support: "standard-support",
  unsupported: "unsupported"
};
var VersionStatus = {
  EXTENDED_SUPPORT: "EXTENDED_SUPPORT",
  STANDARD_SUPPORT: "STANDARD_SUPPORT",
  UNSUPPORTED: "UNSUPPORTED"
};
var ConfigStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING"
};
var Category = {
  UPGRADE_READINESS: "UPGRADE_READINESS"
};
var InsightStatusValue = {
  ERROR: "ERROR",
  PASSING: "PASSING",
  UNKNOWN: "UNKNOWN",
  WARNING: "WARNING"
};
var EksAnywhereSubscriptionStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING",
  EXPIRED: "EXPIRED",
  EXPIRING: "EXPIRING",
  UPDATING: "UPDATING"
};
var BadRequestException = class _BadRequestException extends EKSServiceException {
  static {
    __name(this, "BadRequestException");
  }
  name = "BadRequestException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BadRequestException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _BadRequestException.prototype);
  }
};
var NotFoundException = class _NotFoundException extends EKSServiceException {
  static {
    __name(this, "NotFoundException");
  }
  name = "NotFoundException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _NotFoundException.prototype);
  }
};
var ConnectorConfigProvider = {
  AKS: "AKS",
  ANTHOS: "ANTHOS",
  EC2: "EC2",
  EKS_ANYWHERE: "EKS_ANYWHERE",
  GKE: "GKE",
  OPENSHIFT: "OPENSHIFT",
  OTHER: "OTHER",
  RANCHER: "RANCHER",
  TANZU: "TANZU"
};
var ResourcePropagationDelayException = class _ResourcePropagationDelayException extends EKSServiceException {
  static {
    __name(this, "ResourcePropagationDelayException");
  }
  name = "ResourcePropagationDelayException";
  $fault = "client";
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourcePropagationDelayException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ResourcePropagationDelayException.prototype);
  }
};

// src/protocols/Aws_restJson1.ts
var se_AssociateAccessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/access-entries/{principalArn}/access-policies");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("principalArn", () => input.principalArn, "{principalArn}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      accessScope: (_) => (0, import_smithy_client._json)(_),
      policyArn: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_AssociateAccessPolicyCommand");
var se_AssociateEncryptionConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/encryption-config/associate");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      encryptionConfig: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_AssociateEncryptionConfigCommand");
var se_AssociateIdentityProviderConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/identity-provider-configs/associate");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      oidc: (_) => (0, import_smithy_client._json)(_),
      tags: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_AssociateIdentityProviderConfigCommand");
var se_CreateAccessEntryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/access-entries");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      kubernetesGroups: (_) => (0, import_smithy_client._json)(_),
      principalArn: [],
      tags: (_) => (0, import_smithy_client._json)(_),
      type: [],
      username: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateAccessEntryCommand");
var se_CreateAddonCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/addons");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      addonName: [],
      addonVersion: [],
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      configurationValues: [],
      podIdentityAssociations: (_) => (0, import_smithy_client._json)(_),
      resolveConflicts: [],
      serviceAccountRoleArn: [],
      tags: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateAddonCommand");
var se_CreateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      accessConfig: (_) => (0, import_smithy_client._json)(_),
      bootstrapSelfManagedAddons: [],
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      computeConfig: (_) => (0, import_smithy_client._json)(_),
      encryptionConfig: (_) => (0, import_smithy_client._json)(_),
      kubernetesNetworkConfig: (_) => (0, import_smithy_client._json)(_),
      logging: (_) => (0, import_smithy_client._json)(_),
      name: [],
      outpostConfig: (_) => (0, import_smithy_client._json)(_),
      remoteNetworkConfig: (_) => (0, import_smithy_client._json)(_),
      resourcesVpcConfig: (_) => (0, import_smithy_client._json)(_),
      roleArn: [],
      storageConfig: (_) => (0, import_smithy_client._json)(_),
      tags: (_) => (0, import_smithy_client._json)(_),
      upgradePolicy: (_) => (0, import_smithy_client._json)(_),
      version: [],
      zonalShiftConfig: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateClusterCommand");
var se_CreateEksAnywhereSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/eks-anywhere-subscriptions");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      autoRenew: [],
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      licenseQuantity: [],
      licenseType: [],
      name: [],
      tags: (_) => (0, import_smithy_client._json)(_),
      term: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateEksAnywhereSubscriptionCommand");
var se_CreateFargateProfileCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/fargate-profiles");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      fargateProfileName: [],
      podExecutionRoleArn: [],
      selectors: (_) => (0, import_smithy_client._json)(_),
      subnets: (_) => (0, import_smithy_client._json)(_),
      tags: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateFargateProfileCommand");
var se_CreateNodegroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/node-groups");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      amiType: [],
      capacityType: [],
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      diskSize: [],
      instanceTypes: (_) => (0, import_smithy_client._json)(_),
      labels: (_) => (0, import_smithy_client._json)(_),
      launchTemplate: (_) => (0, import_smithy_client._json)(_),
      nodeRepairConfig: (_) => (0, import_smithy_client._json)(_),
      nodeRole: [],
      nodegroupName: [],
      releaseVersion: [],
      remoteAccess: (_) => (0, import_smithy_client._json)(_),
      scalingConfig: (_) => (0, import_smithy_client._json)(_),
      subnets: (_) => (0, import_smithy_client._json)(_),
      tags: (_) => (0, import_smithy_client._json)(_),
      taints: (_) => (0, import_smithy_client._json)(_),
      updateConfig: (_) => (0, import_smithy_client._json)(_),
      version: []
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateNodegroupCommand");
var se_CreatePodIdentityAssociationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/clusters/{clusterName}/pod-identity-associations");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      clientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
      namespace: [],
      roleArn: [],
      serviceAccount: [],
      tags: (_) => (0, import_smithy_client._json)(_)
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreatePodIdentityAssociationCommand");
var se_DeleteAccessEntryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/access-entries/{principalArn}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("principalArn", () => input.principalArn, "{principalArn}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteAccessEntryCommand");
var se_DeleteAddonCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/addons/{addonName}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("addonName", () => input.addonName, "{addonName}", false);
  const query = (0, import_smithy_client.map)({
    [_p]: [() => input.preserve !== void 0, () => input[_p].toString()]
  });
  let body;
  b.m("DELETE").h(headers).q(query).b(body);
  return b.build();
}, "se_DeleteAddonCommand");
var se_DeleteClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{name}");
  b.p("name", () => input.name, "{name}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteClusterCommand");
var se_DeleteEksAnywhereSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/eks-anywhere-subscriptions/{id}");
  b.p("id", () => input.id, "{id}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteEksAnywhereSubscriptionCommand");
var se_DeleteFargateProfileCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/fargate-profiles/{fargateProfileName}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("fargateProfileName", () => input.fargateProfileName, "{fargateProfileName}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteFargateProfileCommand");
var se_DeleteNodegroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/node-groups/{nodegroupName}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("nodegroupName", () => input.nodegroupName, "{nodegroupName}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteNodegroupCommand");
var se_DeletePodIdentityAssociationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/pod-identity-associations/{associationId}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("associationId", () => input.associationId, "{associationId}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeletePodIdentityAssociationCommand");
var se_DeregisterClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/cluster-registrations/{name}");
  b.p("name", () => input.name, "{name}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeregisterClusterCommand");
var se_DescribeAccessEntryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/clusters/{clusterName}/access-entries/{principalArn}");
  b.p("clusterName", () => input.clusterName, "{clusterName}", false);
  b.p("principalArn", () => input.principalArn, "{principalArn}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_DescribeAccessEntryCommand");
var se_DescribeAddonCommand = /* @__PURE__ */ __name(