@aws-sdk/client-eks 3.441.0 → 3.448.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,5 +1,5 @@
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { EKSServiceException as __BaseException } from "../models/EKSServiceException";
 import { AccessDeniedException, BadRequestException, ClientException, InvalidParameterException, InvalidRequestException, NotFoundException, ResourceInUseException, ResourceLimitExceededException, ResourceNotFoundException, ResourcePropagationDelayException, ServerException, ServiceUnavailableException, UnsupportedAvailabilityZoneException, } from "../models/models_0";
@@ -106,6 +106,32 @@ export const se_CreateClusterCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateEksAnywhereSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/eks-anywhere-subscriptions";
+    let body;
+    body = JSON.stringify(take(input, {
+        autoRenew: [],
+        clientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
+        licenseQuantity: [],
+        licenseType: [],
+        name: [],
+        tags: (_) => _json(_),
+        term: (_) => _json(_),
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -207,6 +233,22 @@ export const se_DeleteClusterCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteEksAnywhereSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/eks-anywhere-subscriptions/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DeleteFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -338,6 +380,22 @@ export const se_DescribeClusterCommand = async (input, context) => {
         body,
     });
 };
+export const se_DescribeEksAnywhereSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/eks-anywhere-subscriptions/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeFargateProfileCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -483,6 +541,30 @@ export const se_ListClustersCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListEksAnywhereSubscriptionsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/eks-anywhere-subscriptions";
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+        includeStatus: [
+            () => input.includeStatus !== void 0,
+            () => (input.includeStatus || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListFargateProfilesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -725,6 +807,28 @@ export const se_UpdateClusterVersionCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateEksAnywhereSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/eks-anywhere-subscriptions/{id}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        autoRenew: [],
+        clientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_UpdateNodegroupConfigCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -975,6 +1079,51 @@ const de_CreateClusterCommandError = async (output, context) => {
             });
     }
 };
+export const de_CreateEksAnywhereSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateEksAnywhereSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        subscription: (_) => de_EksAnywhereSubscription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateEksAnywhereSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientException":
+        case "com.amazonaws.eks#ClientException":
+            throw await de_ClientExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.eks#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "ResourceLimitExceededException":
+        case "com.amazonaws.eks#ResourceLimitExceededException":
+            throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+        case "ServerException":
+        case "com.amazonaws.eks#ServerException":
+            throw await de_ServerExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.eks#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateFargateProfileCommandError(output, context);
@@ -1164,6 +1313,48 @@ const de_DeleteClusterCommandError = async (output, context) => {
             });
     }
 };
+export const de_DeleteEksAnywhereSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteEksAnywhereSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        subscription: (_) => de_EksAnywhereSubscription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeleteEksAnywhereSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientException":
+        case "com.amazonaws.eks#ClientException":
+            throw await de_ClientExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.eks#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.eks#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServerException":
+        case "com.amazonaws.eks#ServerException":
+            throw await de_ServerExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DeleteFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DeleteFargateProfileCommandError(output, context);
@@ -1470,6 +1661,48 @@ const de_DescribeClusterCommandError = async (output, context) => {
             });
     }
 };
+export const de_DescribeEksAnywhereSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeEksAnywhereSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        subscription: (_) => de_EksAnywhereSubscription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DescribeEksAnywhereSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientException":
+        case "com.amazonaws.eks#ClientException":
+            throw await de_ClientExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.eks#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServerException":
+        case "com.amazonaws.eks#ServerException":
+            throw await de_ServerExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.eks#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DescribeFargateProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DescribeFargateProfileCommandError(output, context);
@@ -1781,6 +2014,49 @@ const de_ListClustersCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListEksAnywhereSubscriptionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListEksAnywhereSubscriptionsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        subscriptions: (_) => de_EksAnywhereSubscriptionList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListEksAnywhereSubscriptionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientException":
+        case "com.amazonaws.eks#ClientException":
+            throw await de_ClientExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.eks#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "ServerException":
+        case "com.amazonaws.eks#ServerException":
+            throw await de_ServerExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.eks#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListFargateProfilesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListFargateProfilesCommandError(output, context);
@@ -2257,6 +2533,51 @@ const de_UpdateClusterVersionCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateEksAnywhereSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateEksAnywhereSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        subscription: (_) => de_EksAnywhereSubscription(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateEksAnywhereSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClientException":
+        case "com.amazonaws.eks#ClientException":
+            throw await de_ClientExceptionRes(parsedOutput, context);
+        case "InvalidParameterException":
+        case "com.amazonaws.eks#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+        case "InvalidRequestException":
+        case "com.amazonaws.eks#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.eks#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServerException":
+        case "com.amazonaws.eks#ServerException":
+            throw await de_ServerExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateNodegroupConfigCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateNodegroupConfigCommandError(output, context);
@@ -2388,6 +2709,7 @@ const de_ClientExceptionRes = async (parsedOutput, context) => {
         clusterName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new ClientException({
@@ -2405,6 +2727,7 @@ const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
         fargateProfileName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new InvalidParameterException({
@@ -2421,6 +2744,7 @@ const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
         clusterName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new InvalidRequestException({
@@ -2465,6 +2789,7 @@ const de_ResourceLimitExceededExceptionRes = async (parsedOutput, context) => {
         clusterName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new ResourceLimitExceededException({
@@ -2482,6 +2807,7 @@ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
         fargateProfileName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new ResourceNotFoundException({
@@ -2511,6 +2837,7 @@ const de_ServerExceptionRes = async (parsedOutput, context) => {
         clusterName: __expectString,
         message: __expectString,
         nodegroupName: __expectString,
+        subscriptionId: __expectString,
     });
     Object.assign(contents, doc);
     const exception = new ServerException({
@@ -2599,6 +2926,30 @@ const de_ConnectorConfigResponse = (output, context) => {
         roleArn: __expectString,
     });
 };
+const de_EksAnywhereSubscription = (output, context) => {
+    return take(output, {
+        arn: __expectString,
+        autoRenew: __expectBoolean,
+        createdAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        effectiveDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        expirationDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        id: __expectString,
+        licenseArns: _json,
+        licenseQuantity: __expectInt32,
+        licenseType: __expectString,
+        status: __expectString,
+        tags: _json,
+        term: _json,
+    });
+};
+const de_EksAnywhereSubscriptionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_EksAnywhereSubscription(entry, context);
+    });
+    return retVal;
+};
 const de_FargateProfile = (output, context) => {
     return take(output, {
         clusterName: __expectString,

package/dist-types/EKS.d.ts

@@ -3,10 +3,12 @@ import { AssociateEncryptionConfigCommandInput, AssociateEncryptionConfigCommand
 import { AssociateIdentityProviderConfigCommandInput, AssociateIdentityProviderConfigCommandOutput } from "./commands/AssociateIdentityProviderConfigCommand";
 import { CreateAddonCommandInput, CreateAddonCommandOutput } from "./commands/CreateAddonCommand";
 import { CreateClusterCommandInput, CreateClusterCommandOutput } from "./commands/CreateClusterCommand";
+import { CreateEksAnywhereSubscriptionCommandInput, CreateEksAnywhereSubscriptionCommandOutput } from "./commands/CreateEksAnywhereSubscriptionCommand";
 import { CreateFargateProfileCommandInput, CreateFargateProfileCommandOutput } from "./commands/CreateFargateProfileCommand";
 import { CreateNodegroupCommandInput, CreateNodegroupCommandOutput } from "./commands/CreateNodegroupCommand";
 import { DeleteAddonCommandInput, DeleteAddonCommandOutput } from "./commands/DeleteAddonCommand";
 import { DeleteClusterCommandInput, DeleteClusterCommandOutput } from "./commands/DeleteClusterCommand";
+import { DeleteEksAnywhereSubscriptionCommandInput, DeleteEksAnywhereSubscriptionCommandOutput } from "./commands/DeleteEksAnywhereSubscriptionCommand";
 import { DeleteFargateProfileCommandInput, DeleteFargateProfileCommandOutput } from "./commands/DeleteFargateProfileCommand";
 import { DeleteNodegroupCommandInput, DeleteNodegroupCommandOutput } from "./commands/DeleteNodegroupCommand";
 import { DeregisterClusterCommandInput, DeregisterClusterCommandOutput } from "./commands/DeregisterClusterCommand";
@@ -14,6 +16,7 @@ import { DescribeAddonCommandInput, DescribeAddonCommandOutput } from "./command
 import { DescribeAddonConfigurationCommandInput, DescribeAddonConfigurationCommandOutput } from "./commands/DescribeAddonConfigurationCommand";
 import { DescribeAddonVersionsCommandInput, DescribeAddonVersionsCommandOutput } from "./commands/DescribeAddonVersionsCommand";
 import { DescribeClusterCommandInput, DescribeClusterCommandOutput } from "./commands/DescribeClusterCommand";
+import { DescribeEksAnywhereSubscriptionCommandInput, DescribeEksAnywhereSubscriptionCommandOutput } from "./commands/DescribeEksAnywhereSubscriptionCommand";
 import { DescribeFargateProfileCommandInput, DescribeFargateProfileCommandOutput } from "./commands/DescribeFargateProfileCommand";
 import { DescribeIdentityProviderConfigCommandInput, DescribeIdentityProviderConfigCommandOutput } from "./commands/DescribeIdentityProviderConfigCommand";
 import { DescribeNodegroupCommandInput, DescribeNodegroupCommandOutput } from "./commands/DescribeNodegroupCommand";
@@ -21,6 +24,7 @@ import { DescribeUpdateCommandInput, DescribeUpdateCommandOutput } from "./comma
 import { DisassociateIdentityProviderConfigCommandInput, DisassociateIdentityProviderConfigCommandOutput } from "./commands/DisassociateIdentityProviderConfigCommand";
 import { ListAddonsCommandInput, ListAddonsCommandOutput } from "./commands/ListAddonsCommand";
 import { ListClustersCommandInput, ListClustersCommandOutput } from "./commands/ListClustersCommand";
+import { ListEksAnywhereSubscriptionsCommandInput, ListEksAnywhereSubscriptionsCommandOutput } from "./commands/ListEksAnywhereSubscriptionsCommand";
 import { ListFargateProfilesCommandInput, ListFargateProfilesCommandOutput } from "./commands/ListFargateProfilesCommand";
 import { ListIdentityProviderConfigsCommandInput, ListIdentityProviderConfigsCommandOutput } from "./commands/ListIdentityProviderConfigsCommand";
 import { ListNodegroupsCommandInput, ListNodegroupsCommandOutput } from "./commands/ListNodegroupsCommand";
@@ -32,6 +36,7 @@ import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./command
 import { UpdateAddonCommandInput, UpdateAddonCommandOutput } from "./commands/UpdateAddonCommand";
 import { UpdateClusterConfigCommandInput, UpdateClusterConfigCommandOutput } from "./commands/UpdateClusterConfigCommand";
 import { UpdateClusterVersionCommandInput, UpdateClusterVersionCommandOutput } from "./commands/UpdateClusterVersionCommand";
+import { UpdateEksAnywhereSubscriptionCommandInput, UpdateEksAnywhereSubscriptionCommandOutput } from "./commands/UpdateEksAnywhereSubscriptionCommand";
 import { UpdateNodegroupConfigCommandInput, UpdateNodegroupConfigCommandOutput } from "./commands/UpdateNodegroupConfigCommand";
 import { UpdateNodegroupVersionCommandInput, UpdateNodegroupVersionCommandOutput } from "./commands/UpdateNodegroupVersionCommand";
 import { EKSClient } from "./EKSClient";
@@ -60,6 +65,12 @@ export interface EKS {
     createCluster(args: CreateClusterCommandInput, options?: __HttpHandlerOptions): Promise<CreateClusterCommandOutput>;
     createCluster(args: CreateClusterCommandInput, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
     createCluster(args: CreateClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
+    /**
+     * @see {@link CreateEksAnywhereSubscriptionCommand}
+     */
+    createEksAnywhereSubscription(args: CreateEksAnywhereSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<CreateEksAnywhereSubscriptionCommandOutput>;
+    createEksAnywhereSubscription(args: CreateEksAnywhereSubscriptionCommandInput, cb: (err: any, data?: CreateEksAnywhereSubscriptionCommandOutput) => void): void;
+    createEksAnywhereSubscription(args: CreateEksAnywhereSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateEksAnywhereSubscriptionCommandOutput) => void): void;
     /**
      * @see {@link CreateFargateProfileCommand}
      */
@@ -84,6 +95,12 @@ export interface EKS {
     deleteCluster(args: DeleteClusterCommandInput, options?: __HttpHandlerOptions): Promise<DeleteClusterCommandOutput>;
     deleteCluster(args: DeleteClusterCommandInput, cb: (err: any, data?: DeleteClusterCommandOutput) => void): void;
     deleteCluster(args: DeleteClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteClusterCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteEksAnywhereSubscriptionCommand}
+     */
+    deleteEksAnywhereSubscription(args: DeleteEksAnywhereSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<DeleteEksAnywhereSubscriptionCommandOutput>;
+    deleteEksAnywhereSubscription(args: DeleteEksAnywhereSubscriptionCommandInput, cb: (err: any, data?: DeleteEksAnywhereSubscriptionCommandOutput) => void): void;
+    deleteEksAnywhereSubscription(args: DeleteEksAnywhereSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteEksAnywhereSubscriptionCommandOutput) => void): void;
     /**
      * @see {@link DeleteFargateProfileCommand}
      */
@@ -126,6 +143,12 @@ export interface EKS {
     describeCluster(args: DescribeClusterCommandInput, options?: __HttpHandlerOptions): Promise<DescribeClusterCommandOutput>;
     describeCluster(args: DescribeClusterCommandInput, cb: (err: any, data?: DescribeClusterCommandOutput) => void): void;
     describeCluster(args: DescribeClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeClusterCommandOutput) => void): void;
+    /**
+     * @see {@link DescribeEksAnywhereSubscriptionCommand}
+     */
+    describeEksAnywhereSubscription(args: DescribeEksAnywhereSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<DescribeEksAnywhereSubscriptionCommandOutput>;
+    describeEksAnywhereSubscription(args: DescribeEksAnywhereSubscriptionCommandInput, cb: (err: any, data?: DescribeEksAnywhereSubscriptionCommandOutput) => void): void;
+    describeEksAnywhereSubscription(args: DescribeEksAnywhereSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeEksAnywhereSubscriptionCommandOutput) => void): void;
     /**
      * @see {@link DescribeFargateProfileCommand}
      */
@@ -168,6 +191,12 @@ export interface EKS {
     listClusters(args: ListClustersCommandInput, options?: __HttpHandlerOptions): Promise<ListClustersCommandOutput>;
     listClusters(args: ListClustersCommandInput, cb: (err: any, data?: ListClustersCommandOutput) => void): void;
     listClusters(args: ListClustersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListClustersCommandOutput) => void): void;
+    /**
+     * @see {@link ListEksAnywhereSubscriptionsCommand}
+     */
+    listEksAnywhereSubscriptions(args: ListEksAnywhereSubscriptionsCommandInput, options?: __HttpHandlerOptions): Promise<ListEksAnywhereSubscriptionsCommandOutput>;
+    listEksAnywhereSubscriptions(args: ListEksAnywhereSubscriptionsCommandInput, cb: (err: any, data?: ListEksAnywhereSubscriptionsCommandOutput) => void): void;
+    listEksAnywhereSubscriptions(args: ListEksAnywhereSubscriptionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListEksAnywhereSubscriptionsCommandOutput) => void): void;
     /**
      * @see {@link ListFargateProfilesCommand}
      */
@@ -234,6 +263,12 @@ export interface EKS {
     updateClusterVersion(args: UpdateClusterVersionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateClusterVersionCommandOutput>;
     updateClusterVersion(args: UpdateClusterVersionCommandInput, cb: (err: any, data?: UpdateClusterVersionCommandOutput) => void): void;
     updateClusterVersion(args: UpdateClusterVersionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateClusterVersionCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateEksAnywhereSubscriptionCommand}
+     */
+    updateEksAnywhereSubscription(args: UpdateEksAnywhereSubscriptionCommandInput, options?: __HttpHandlerOptions): Promise<UpdateEksAnywhereSubscriptionCommandOutput>;
+    updateEksAnywhereSubscription(args: UpdateEksAnywhereSubscriptionCommandInput, cb: (err: any, data?: UpdateEksAnywhereSubscriptionCommandOutput) => void): void;
+    updateEksAnywhereSubscription(args: UpdateEksAnywhereSubscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateEksAnywhereSubscriptionCommandOutput) => void): void;
     /**
      * @see {@link UpdateNodegroupConfigCommand}
      */
@@ -250,15 +285,14 @@ export interface EKS {
 /**
  * @public
  * <p>Amazon Elastic Kubernetes Service (Amazon EKS) is a managed service that makes it easy
- *             for you to run Kubernetes on Amazon Web Services without needing to stand up or maintain
- *             your own Kubernetes control plane. Kubernetes is an open-source system for automating
- *             the deployment, scaling, and management of containerized applications. </p>
- *          <p>Amazon EKS runs up-to-date versions of the open-source Kubernetes software, so
- *             you can use all the existing plugins and tooling from the Kubernetes community.
- *             Applications running on Amazon EKS are fully compatible with applications
- *             running on any standard Kubernetes environment, whether running in on-premises data
- *             centers or public clouds. This means that you can easily migrate any standard Kubernetes
- *             application to Amazon EKS without any code modification required.</p>
+ *             for you to run Kubernetes on Amazon Web Services without needing to stand up or maintain your
+ *             own Kubernetes control plane. Kubernetes is an open-source system for automating the deployment,
+ *             scaling, and management of containerized applications. </p>
+ *          <p>Amazon EKS runs up-to-date versions of the open-source Kubernetes software, so you
+ *             can use all the existing plugins and tooling from the Kubernetes community. Applications
+ *             running on Amazon EKS are fully compatible with applications running on any
+ *             standard Kubernetes environment, whether running in on-premises data centers or public
+ *             clouds. This means that you can easily migrate any standard Kubernetes application to Amazon EKS without any code modification required.</p>
  */
 export declare class EKS extends EKSClient implements EKS {
 }