@aws-sdk/client-eks-auth 3.458.0

package/dist-types/EKSAuthClient.d.ts

@@ -0,0 +1,171 @@
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { Credentials as __Credentials } from "@aws-sdk/types";
+import { RegionInputConfig, RegionResolvedConfig } from "@smithy/config-resolver";
+import { EndpointInputConfig, EndpointResolvedConfig } from "@smithy/middleware-endpoint";
+import { RetryInputConfig, RetryResolvedConfig } from "@smithy/middleware-retry";
+import { HttpHandler as __HttpHandler } from "@smithy/protocol-http";
+import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
+import { BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
+import { AssumeRoleForPodIdentityCommandInput, AssumeRoleForPodIdentityCommandOutput } from "./commands/AssumeRoleForPodIdentityCommand";
+import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
+import { RuntimeExtension, RuntimeExtensionsConfig } from "./runtimeExtensions";
+export { __Client };
+/**
+ * @public
+ */
+export type ServiceInputTypes = AssumeRoleForPodIdentityCommandInput;
+/**
+ * @public
+ */
+export type ServiceOutputTypes = AssumeRoleForPodIdentityCommandOutput;
+/**
+ * @public
+ */
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    /**
+     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
+     */
+    requestHandler?: __HttpHandler;
+    /**
+     * A constructor for a class implementing the {@link @smithy/types#ChecksumConstructor} interface
+     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
+     * @internal
+     */
+    sha256?: __ChecksumConstructor | __HashConstructor;
+    /**
+     * The function that will be used to convert strings into HTTP endpoints.
+     * @internal
+     */
+    urlParser?: __UrlParser;
+    /**
+     * A function that can calculate the length of a request body.
+     * @internal
+     */
+    bodyLengthChecker?: __BodyLengthCalculator;
+    /**
+     * A function that converts a stream into an array of bytes.
+     * @internal
+     */
+    streamCollector?: __StreamCollector;
+    /**
+     * The function that will be used to convert a base64-encoded string to a byte array.
+     * @internal
+     */
+    base64Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a base64-encoded string.
+     * @internal
+     */
+    base64Encoder?: __Encoder;
+    /**
+     * The function that will be used to convert a UTF8-encoded string to a byte array.
+     * @internal
+     */
+    utf8Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a UTF-8 encoded string.
+     * @internal
+     */
+    utf8Encoder?: __Encoder;
+    /**
+     * The runtime environment.
+     * @internal
+     */
+    runtime?: string;
+    /**
+     * Disable dynamically changing the endpoint of the client based on the hostPrefix
+     * trait of an operation.
+     */
+    disableHostPrefix?: boolean;
+    /**
+     * Unique service identifier.
+     * @internal
+     */
+    serviceId?: string;
+    /**
+     * Enables IPv6/IPv4 dualstack endpoint.
+     */
+    useDualstackEndpoint?: boolean | __Provider<boolean>;
+    /**
+     * Enables FIPS compatible endpoints.
+     */
+    useFipsEndpoint?: boolean | __Provider<boolean>;
+    /**
+     * The AWS region to which this client will send requests
+     */
+    region?: string | __Provider<string>;
+    /**
+     * Default credentials provider; Not available in browser runtime.
+     * @internal
+     */
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    /**
+     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
+     * @internal
+     */
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+    /**
+     * Value for how many times a request will be made at most in case of retry.
+     */
+    maxAttempts?: number | __Provider<number>;
+    /**
+     * Specifies which retry algorithm to use.
+     * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-smithy-util-retry/Enum/RETRY_MODES/
+     *
+     */
+    retryMode?: string | __Provider<string>;
+    /**
+     * Optional logger for logging debug/info/warn/error.
+     */
+    logger?: __Logger;
+    /**
+     * Optional extensions
+     */
+    extensions?: RuntimeExtension[];
+    /**
+     * The {@link @smithy/smithy-client#DefaultsMode} that will be used to determine how certain default configuration options are resolved in the SDK.
+     */
+    defaultsMode?: __DefaultsMode | __Provider<__DefaultsMode>;
+}
+/**
+ * @public
+ */
+export type EKSAuthClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointInputConfig<EndpointParameters> & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig & ClientInputEndpointParameters;
+/**
+ * @public
+ *
+ *  The configuration interface of EKSAuthClient class constructor that set the region, credentials and other options.
+ */
+export interface EKSAuthClientConfig extends EKSAuthClientConfigType {
+}
+/**
+ * @public
+ */
+export type EKSAuthClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & RegionResolvedConfig & EndpointResolvedConfig<EndpointParameters> & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig & ClientResolvedEndpointParameters;
+/**
+ * @public
+ *
+ *  The resolved configuration interface of EKSAuthClient class. This is resolved and normalized from the {@link EKSAuthClientConfig | constructor configuration interface}.
+ */
+export interface EKSAuthClientResolvedConfig extends EKSAuthClientResolvedConfigType {
+}
+/**
+ * @public
+ * <p>The Amazon EKS Auth API and the <code>AssumeRoleForPodIdentity</code> action are only
+ *             used by the EKS Pod Identity Agent.</p>
+ */
+export declare class EKSAuthClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, EKSAuthClientResolvedConfig> {
+    /**
+     * The resolved configuration of EKSAuthClient class. This is resolved and normalized from the {@link EKSAuthClientConfig | constructor configuration interface}.
+     */
+    readonly config: EKSAuthClientResolvedConfig;
+    constructor(...[configuration]: __CheckOptionalClientConfig<EKSAuthClientConfig>);
+    /**
+     * 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(): void;
+}

package/dist-types/commands/AssumeRoleForPodIdentityCommand.d.ts

@@ -0,0 +1,128 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { EKSAuthClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSAuthClient";
+import { AssumeRoleForPodIdentityRequest, AssumeRoleForPodIdentityResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link AssumeRoleForPodIdentityCommand}.
+ */
+export interface AssumeRoleForPodIdentityCommandInput extends AssumeRoleForPodIdentityRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AssumeRoleForPodIdentityCommand}.
+ */
+export interface AssumeRoleForPodIdentityCommandOutput extends AssumeRoleForPodIdentityResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>The Amazon EKS Auth API and the <code>AssumeRoleForPodIdentity</code> action are only used
+ *             by the EKS Pod Identity Agent.</p>
+ *          <p>We recommend that applications use the Amazon Web Services SDKs to connect to Amazon Web Services services; if
+ *             credentials from an EKS Pod Identity association are available in the pod, the latest versions of the
+ *             SDKs use them automatically.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EKSAuthClient, AssumeRoleForPodIdentityCommand } from "@aws-sdk/client-eks-auth"; // ES Modules import
+ * // const { EKSAuthClient, AssumeRoleForPodIdentityCommand } = require("@aws-sdk/client-eks-auth"); // CommonJS import
+ * const client = new EKSAuthClient(config);
+ * const input = { // AssumeRoleForPodIdentityRequest
+ *   clusterName: "STRING_VALUE", // required
+ *   token: "STRING_VALUE", // required
+ * };
+ * const command = new AssumeRoleForPodIdentityCommand(input);
+ * const response = await client.send(command);
+ * // { // AssumeRoleForPodIdentityResponse
+ * //   subject: { // Subject
+ * //     namespace: "STRING_VALUE", // required
+ * //     serviceAccount: "STRING_VALUE", // required
+ * //   },
+ * //   audience: "STRING_VALUE", // required
+ * //   podIdentityAssociation: { // PodIdentityAssociation
+ * //     associationArn: "STRING_VALUE", // required
+ * //     associationId: "STRING_VALUE", // required
+ * //   },
+ * //   assumedRoleUser: { // AssumedRoleUser
+ * //     arn: "STRING_VALUE", // required
+ * //     assumeRoleId: "STRING_VALUE", // required
+ * //   },
+ * //   credentials: { // Credentials
+ * //     sessionToken: "STRING_VALUE", // required
+ * //     secretAccessKey: "STRING_VALUE", // required
+ * //     accessKeyId: "STRING_VALUE", // required
+ * //     expiration: new Date("TIMESTAMP"), // required
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param AssumeRoleForPodIdentityCommandInput - {@link AssumeRoleForPodIdentityCommandInput}
+ * @returns {@link AssumeRoleForPodIdentityCommandOutput}
+ * @see {@link AssumeRoleForPodIdentityCommandInput} for command's `input` shape.
+ * @see {@link AssumeRoleForPodIdentityCommandOutput} for command's `response` shape.
+ * @see {@link EKSAuthClientResolvedConfig | config} for EKSAuthClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You don't have permissions to perform the requested operation. The IAM principal
+ *             making the request must have at least one IAM permissions policy attached
+ *             that grants the required permissions. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access
+ *                 management</a> in the <i>IAM User Guide</i>. </p>
+ *
+ * @throws {@link ExpiredTokenException} (client fault)
+ *  <p>The specified Kubernetes service account token is expired.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>These errors are usually caused by a server-side issue.</p>
+ *
+ * @throws {@link InvalidParameterException} (client fault)
+ *  <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ *
+ * @throws {@link InvalidRequestException} (client fault)
+ *  <p>This exception is thrown if the request contains a semantic error. The precise meaning
+ *             will depend on the API, and will be documented in the error message.</p>
+ *
+ * @throws {@link InvalidTokenException} (client fault)
+ *  <p>The specified Kubernetes service account token is invalid.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource could not be found.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>The service is unavailable. Back off and retry the operation.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because your request rate is too high. Reduce the frequency of requests.</p>
+ *
+ * @throws {@link EKSAuthServiceException}
+ * <p>Base exception class for all service exceptions from EKSAuth service.</p>
+ *
+ */
+export declare class AssumeRoleForPodIdentityCommand extends $Command<AssumeRoleForPodIdentityCommandInput, AssumeRoleForPodIdentityCommandOutput, EKSAuthClientResolvedConfig> {
+    readonly input: AssumeRoleForPodIdentityCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AssumeRoleForPodIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSAuthClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssumeRoleForPodIdentityCommandInput, AssumeRoleForPodIdentityCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1 @@
+export * from "./AssumeRoleForPodIdentityCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,20 @@
+import { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface ClientInputEndpointParameters {
+    region?: string | Provider<string>;
+    useFipsEndpoint?: boolean | Provider<boolean>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+}
+export type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export interface EndpointParameters extends __EndpointParameters {
+    Region?: string;
+    UseFIPS?: boolean;
+    Endpoint?: string;
+}

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,5 @@
+import { EndpointV2, Logger } from "@smithy/types";
+import { EndpointParameters } from "./EndpointParameters";
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@smithy/types";
+export declare const ruleSet: RuleSetObject;

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,8 @@
+import { AwsRegionExtensionConfiguration } from "@aws-sdk/types";
+import { HttpHandlerExtensionConfiguration } from "@smithy/protocol-http";
+import { DefaultExtensionConfiguration } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface EKSAuthExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration, AwsRegionExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * <p>The Amazon EKS Auth API and the <code>AssumeRoleForPodIdentity</code> action are only
+ *             used by the EKS Pod Identity Agent.</p>
+ *
+ * @packageDocumentation
+ */
+export * from "./EKSAuthClient";
+export * from "./EKSAuth";
+export { ClientInputEndpointParameters } from "./endpoint/EndpointParameters";
+export { RuntimeExtension } from "./runtimeExtensions";
+export { EKSAuthExtensionConfiguration } from "./extensionConfiguration";
+export * from "./commands";
+export * from "./models";
+import "@aws-sdk/util-endpoints";
+export { EKSAuthServiceException } from "./models/EKSAuthServiceException";

package/dist-types/models/EKSAuthServiceException.d.ts

@@ -0,0 +1,13 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@smithy/smithy-client";
+export { __ServiceException, __ServiceExceptionOptions };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from EKSAuth service.
+ */
+export declare class EKSAuthServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";

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

@@ -0,0 +1,273 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { EKSAuthServiceException as __BaseException } from "./EKSAuthServiceException";
+/**
+ * @public
+ * <p>You don't have permissions to perform the requested operation. The IAM principal
+ *             making the request must have at least one IAM permissions policy attached
+ *             that grants the required permissions. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access
+ *                 management</a> in the <i>IAM User Guide</i>. </p>
+ */
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+/**
+ * @public
+ * <p>An object with the permanent IAM role identity and the temporary session
+ *             name.</p>
+ */
+export interface AssumedRoleUser {
+    /**
+     * @public
+     * <p>The ARN of the IAM role that the temporary credentials authenticate to.</p>
+     */
+    arn: string | undefined;
+    /**
+     * @public
+     * <p>The session name of the temporary session requested to STS. The value
+     *             is a unique identifier that contains the role ID, a colon (<code>:</code>), and the role
+     *             session name of the role that is being assumed. The role ID is generated by IAM when
+     *             the role is created. The role session name part of the value follows this format:
+     *                     <code>eks-<i>clustername</i>-<i>podname</i>-<i>random
+     *                     UUID</i>
+     *             </code>
+     *          </p>
+     */
+    assumeRoleId: string | undefined;
+}
+/**
+ * @public
+ */
+export interface AssumeRoleForPodIdentityRequest {
+    /**
+     * @public
+     * <p>The name of the cluster for the request.</p>
+     */
+    clusterName: string | undefined;
+    /**
+     * @public
+     * <p>The token of the Kubernetes service account for the pod.</p>
+     */
+    token: string | undefined;
+}
+/**
+ * @public
+ * <p>The <i>Amazon Web Services Signature Version 4</i> type of temporary
+ *             credentials.</p>
+ */
+export interface Credentials {
+    /**
+     * @public
+     * <p>The token that applications inside the pods must pass to any service API to use the
+     *             temporary credentials.</p>
+     */
+    sessionToken: string | undefined;
+    /**
+     * @public
+     * <p>The secret access key that applications inside the pods use to sign requests.</p>
+     */
+    secretAccessKey: string | undefined;
+    /**
+     * @public
+     * <p>The access key ID that identifies the temporary security credentials.</p>
+     */
+    accessKeyId: string | undefined;
+    /**
+     * @public
+     * <p>The Unix epoch timestamp in seconds when the current credentials expire.</p>
+     */
+    expiration: Date | undefined;
+}
+/**
+ * @public
+ * <p>Amazon EKS Pod Identity associations provide the ability to manage credentials for your applications, similar to the way that Amazon EC2 instance profiles provide credentials to Amazon EC2 instances.</p>
+ */
+export interface PodIdentityAssociation {
+    /**
+     * @public
+     * <p>The Amazon Resource Name (ARN) of the EKS Pod Identity association.</p>
+     */
+    associationArn: string | undefined;
+    /**
+     * @public
+     * <p>The ID of the association.</p>
+     */
+    associationId: string | undefined;
+}
+/**
+ * @public
+ * <p>An object containing the name of the Kubernetes service account inside the cluster to
+ *             associate the IAM credentials with.</p>
+ */
+export interface Subject {
+    /**
+     * @public
+     * <p>The name of the Kubernetes namespace inside the cluster to create the association in. The
+     *             service account and the pods that use the service account must be in this
+     *             namespace.</p>
+     */
+    namespace: string | undefined;
+    /**
+     * @public
+     * <p>The name of the Kubernetes service account inside the cluster to associate the IAM
+     *             credentials with.</p>
+     */
+    serviceAccount: string | undefined;
+}
+/**
+ * @public
+ */
+export interface AssumeRoleForPodIdentityResponse {
+    /**
+     * @public
+     * <p>The name of the Kubernetes service account inside the cluster to associate the IAM
+     *             credentials with.</p>
+     */
+    subject: Subject | undefined;
+    /**
+     * @public
+     * <p>The identity that is allowed to use the credentials. This value is always
+     *                 <code>pods.eks.amazonaws.com</code>.</p>
+     */
+    audience: string | undefined;
+    /**
+     * @public
+     * <p>The Amazon Resource Name (ARN) and ID of the EKS Pod Identity association.</p>
+     */
+    podIdentityAssociation: PodIdentityAssociation | undefined;
+    /**
+     * @public
+     * <p>An object with the permanent IAM role identity and the temporary session
+     *             name.</p>
+     *          <p>The ARN of the IAM role that the temporary credentials authenticate to.</p>
+     *          <p>The session name of the temporary session requested to STS. The value
+     *             is a unique identifier that contains the role ID, a colon (<code>:</code>), and the role
+     *             session name of the role that is being assumed. The role ID is generated by IAM when
+     *             the role is created. The role session name part of the value follows this format:
+     *                     <code>eks-<i>clustername</i>-<i>podname</i>-<i>random
+     *                     UUID</i>
+     *             </code>
+     *          </p>
+     */
+    assumedRoleUser: AssumedRoleUser | undefined;
+    /**
+     * @public
+     * <p>The <i>Amazon Web Services Signature Version 4</i> type of temporary
+     *             credentials.</p>
+     */
+    credentials: Credentials | undefined;
+}
+/**
+ * @public
+ * <p>The specified Kubernetes service account token is expired.</p>
+ */
+export declare class ExpiredTokenException extends __BaseException {
+    readonly name: "ExpiredTokenException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ExpiredTokenException, __BaseException>);
+}
+/**
+ * @public
+ * <p>These errors are usually caused by a server-side issue.</p>
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * @public
+ * <p>The specified parameter is invalid. Review the available parameters for the API
+ *             request.</p>
+ */
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+/**
+ * @public
+ * <p>This exception is thrown if the request contains a semantic error. The precise meaning
+ *             will depend on the API, and will be documented in the error message.</p>
+ */
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+/**
+ * @public
+ * <p>The specified Kubernetes service account token is invalid.</p>
+ */
+export declare class InvalidTokenException extends __BaseException {
+    readonly name: "InvalidTokenException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidTokenException, __BaseException>);
+}
+/**
+ * @public
+ * <p>The specified resource could not be found.</p>
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * @public
+ * <p>The service is unavailable. Back off and retry the operation.</p>
+ */
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+/**
+ * @public
+ * <p>The request was denied because your request rate is too high. Reduce the frequency of requests.</p>
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * @internal
+ */
+export declare const AssumeRoleForPodIdentityRequestFilterSensitiveLog: (obj: AssumeRoleForPodIdentityRequest) => any;
+/**
+ * @internal
+ */
+export declare const CredentialsFilterSensitiveLog: (obj: Credentials) => any;
+/**
+ * @internal
+ */
+export declare const AssumeRoleForPodIdentityResponseFilterSensitiveLog: (obj: AssumeRoleForPodIdentityResponse) => any;

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,11 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+import { SerdeContext as __SerdeContext } from "@smithy/types";
+import { AssumeRoleForPodIdentityCommandInput, AssumeRoleForPodIdentityCommandOutput } from "../commands/AssumeRoleForPodIdentityCommand";
+/**
+ * serializeAws_restJson1AssumeRoleForPodIdentityCommand
+ */
+export declare const se_AssumeRoleForPodIdentityCommand: (input: AssumeRoleForPodIdentityCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * deserializeAws_restJson1AssumeRoleForPodIdentityCommand
+ */
+export declare const de_AssumeRoleForPodIdentityCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<AssumeRoleForPodIdentityCommandOutput>;