@aws-sdk/client-kms 3.32.0 → 3.36.0

package/commands/GetParametersForImportCommand.ts

@@ -1,129 +0,0 @@
-import { KMSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KMSClient";
-import { GetParametersForImportRequest, GetParametersForImportResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1GetParametersForImportCommand,
-  serializeAws_json1_1GetParametersForImportCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface GetParametersForImportCommandInput extends GetParametersForImportRequest {}
-export interface GetParametersForImportCommandOutput extends GetParametersForImportResponse, __MetadataBearer {}
-
-/**
- * <p>Returns the items you need to import key material into a symmetric, customer managed
- *       KMS key. For more information about importing key material into KMS, see
- *         <a href="https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html">Importing Key
- *         Material</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>This operation returns a public key and an import token. Use the public key to encrypt the
- *       symmetric key material. Store the import token to send with a subsequent <a>ImportKeyMaterial</a> request.</p>
- *          <p>You must specify the key ID of the symmetric KMS key into which you will import key material.
- *       This KMS key's <code>Origin</code> must be <code>EXTERNAL</code>. You must also specify the
- *       wrapping algorithm and type of wrapping key (public key) that you will use to encrypt the key
- *       material. You cannot perform this operation on an asymmetric KMS key or on any KMS key in a different Amazon Web Services account.</p>
- *          <p>To import key material, you must use the public key and import token from the same
- *       response. These items are valid for 24 hours. The expiration date and time appear in the
- *         <code>GetParametersForImport</code> response. You cannot use an expired token in an <a>ImportKeyMaterial</a> request. If your key and token expire, send another
- *         <code>GetParametersForImport</code> request.</p>
- *          <p>The KMS key that you use for this operation must be in a compatible key state. For
- * details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html">Key state: Effect on your KMS key</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>
- *             <b>Cross-account use</b>: No. You cannot perform this operation on a KMS key in a different Amazon Web Services account.</p>
- *
- *          <p>
- *             <b>Required permissions</b>: <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html">kms:GetParametersForImport</a> (key policy)</p>
- *          <p>
- *             <b>Related operations:</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ImportKeyMaterial</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteImportedKeyMaterial</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KMSClient, GetParametersForImportCommand } from "@aws-sdk/client-kms"; // ES Modules import
- * // const { KMSClient, GetParametersForImportCommand } = require("@aws-sdk/client-kms"); // CommonJS import
- * const client = new KMSClient(config);
- * const command = new GetParametersForImportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetParametersForImportCommandInput} for command's `input` shape.
- * @see {@link GetParametersForImportCommandOutput} for command's `response` shape.
- * @see {@link KMSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class GetParametersForImportCommand extends $Command<
-  GetParametersForImportCommandInput,
-  GetParametersForImportCommandOutput,
-  KMSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetParametersForImportCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: KMSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetParametersForImportCommandInput, GetParametersForImportCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "KMSClient";
-    const commandName = "GetParametersForImportCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetParametersForImportRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetParametersForImportResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetParametersForImportCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1GetParametersForImportCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetParametersForImportCommandOutput> {
-    return deserializeAws_json1_1GetParametersForImportCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/GetPublicKeyCommand.ts

@@ -1,138 +0,0 @@
-import { KMSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KMSClient";
-import { GetPublicKeyRequest, GetPublicKeyResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1GetPublicKeyCommand,
-  serializeAws_json1_1GetPublicKeyCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface GetPublicKeyCommandInput extends GetPublicKeyRequest {}
-export interface GetPublicKeyCommandOutput extends GetPublicKeyResponse, __MetadataBearer {}
-
-/**
- * <p>Returns the public key of an asymmetric KMS key. Unlike the private key of a asymmetric KMS key,
- *       which never leaves KMS unencrypted, callers with <code>kms:GetPublicKey</code> permission
- *       can download the public key of an asymmetric KMS key. You can share the public key to allow others
- *       to encrypt messages and verify signatures outside of KMS. For information about symmetric and asymmetric KMS keys, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Using Symmetric and Asymmetric KMS keys</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>You do not need to download the public key. Instead, you can use the public key within
- *       KMS by calling the <a>Encrypt</a>, <a>ReEncrypt</a>, or <a>Verify</a> operations with the identifier of an asymmetric KMS key. When you use the
- *       public key within KMS, you benefit from the authentication, authorization, and logging that
- *       are part of every KMS operation. You also reduce of risk of encrypting data that cannot be
- *       decrypted. These features are not effective outside of KMS. For details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/download-public-key.html#download-public-key-considerations">Special
- *         Considerations for Downloading Public Keys</a>.</p>
- *          <p>To help you use the public key safely outside of KMS, <code>GetPublicKey</code> returns
- *       important information about the public key in the response, including:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html#KMS-GetPublicKey-response-KeySpec">KeySpec</a>: The type of key material in the public key, such as
- *             <code>RSA_4096</code> or <code>ECC_NIST_P521</code>.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html#KMS-GetPublicKey-response-KeyUsage">KeyUsage</a>: Whether the key is used for encryption or signing.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html#KMS-GetPublicKey-response-EncryptionAlgorithms">EncryptionAlgorithms</a> or <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html#KMS-GetPublicKey-response-SigningAlgorithms">SigningAlgorithms</a>: A list of the encryption algorithms or the signing
- *           algorithms for the key.</p>
- *             </li>
- *          </ul>
- *          <p>Although KMS cannot enforce these restrictions on external operations, it is crucial
- *       that you use this information to prevent the public key from being used improperly. For
- *       example, you can prevent a public signing key from being used encrypt data, or prevent a
- *       public key from being used with an encryption algorithm that is not supported by KMS. You
- *       can also avoid errors, such as using the wrong signing algorithm in a verification
- *       operation.</p>
- *          <p>The KMS key that you use for this operation must be in a compatible key state. For
- * details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html">Key state: Effect on your KMS key</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>
- *             <b>Cross-account use</b>: Yes. To perform this operation with a KMS key in a different Amazon Web Services account, specify
- *   the key ARN or alias ARN in the value of the <code>KeyId</code> parameter.</p>
- *
- *          <p>
- *             <b>Required permissions</b>: <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html">kms:GetPublicKey</a> (key policy)</p>
- *          <p>
- *             <b>Related operations</b>: <a>CreateKey</a>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KMSClient, GetPublicKeyCommand } from "@aws-sdk/client-kms"; // ES Modules import
- * // const { KMSClient, GetPublicKeyCommand } = require("@aws-sdk/client-kms"); // CommonJS import
- * const client = new KMSClient(config);
- * const command = new GetPublicKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPublicKeyCommandInput} for command's `input` shape.
- * @see {@link GetPublicKeyCommandOutput} for command's `response` shape.
- * @see {@link KMSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class GetPublicKeyCommand extends $Command<
-  GetPublicKeyCommandInput,
-  GetPublicKeyCommandOutput,
-  KMSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: GetPublicKeyCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: KMSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetPublicKeyCommandInput, GetPublicKeyCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "KMSClient";
-    const commandName = "GetPublicKeyCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: GetPublicKeyRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: GetPublicKeyResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: GetPublicKeyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1GetPublicKeyCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetPublicKeyCommandOutput> {
-    return deserializeAws_json1_1GetPublicKeyCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/ImportKeyMaterialCommand.ts

@@ -1,157 +0,0 @@
-import { KMSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KMSClient";
-import { ImportKeyMaterialRequest, ImportKeyMaterialResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1ImportKeyMaterialCommand,
-  serializeAws_json1_1ImportKeyMaterialCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface ImportKeyMaterialCommandInput extends ImportKeyMaterialRequest {}
-export interface ImportKeyMaterialCommandOutput extends ImportKeyMaterialResponse, __MetadataBearer {}
-
-/**
- * <p>Imports key material into an existing symmetric KMS KMS key that was
- *       created without key material. After you successfully import key material into a KMS key, you can
- *         <a href="https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html#reimport-key-material">reimport the same key material</a> into that KMS key, but you cannot import different key
- *       material. </p>
- *          <p>You cannot perform this operation on an asymmetric KMS key or on any KMS key in a different Amazon Web Services account. For more information about creating KMS keys with no key material and
- *       then importing key material, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html">Importing Key Material</a> in the
- *       <i>Key Management Service Developer Guide</i>.</p>
- *          <p>Before using this operation, call <a>GetParametersForImport</a>. Its response
- *       includes a public key and an import token. Use the public key to encrypt the key material.
- *       Then, submit the import token from the same <code>GetParametersForImport</code>
- *       response.</p>
- *          <p>When calling this operation, you must specify the following values:</p>
- *          <ul>
- *             <li>
- *                <p>The key ID or key ARN of a KMS key with no key material. Its <code>Origin</code> must be
- *             <code>EXTERNAL</code>.</p>
- *                <p>To create a KMS key with no key material, call <a>CreateKey</a> and set the
- *           value of its <code>Origin</code> parameter to <code>EXTERNAL</code>. To get the
- *             <code>Origin</code> of a KMS key, call <a>DescribeKey</a>.)</p>
- *             </li>
- *             <li>
- *                <p>The encrypted key material. To get the public key to encrypt the key material, call
- *             <a>GetParametersForImport</a>.</p>
- *             </li>
- *             <li>
- *                <p>The import token that <a>GetParametersForImport</a> returned. You must use
- *           a public key and token from the same <code>GetParametersForImport</code> response.</p>
- *             </li>
- *             <li>
- *                <p>Whether the key material expires and if so, when. If you set an expiration date, KMS
- *           deletes the key material from the KMS key on the specified date, and the KMS key becomes unusable.
- *           To use the KMS key again, you must reimport the same key material. The only way to change an
- *           expiration date is by reimporting the same key material and specifying a new expiration
- *           date. </p>
- *             </li>
- *          </ul>
- *          <p>When this operation is successful, the key state of the KMS key changes from
- *         <code>PendingImport</code> to <code>Enabled</code>, and you can use the KMS key.</p>
- *          <p>If this operation fails, use the exception to help determine the problem. If the error is
- *       related to the key material, the import token, or wrapping key, use <a>GetParametersForImport</a> to get a new public key and import token for the KMS key and
- *       repeat the import procedure. For help, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html#importing-keys-overview">How To Import Key
- *         Material</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>The KMS key that you use for this operation must be in a compatible key state. For
- * details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html">Key state: Effect on your KMS key</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>
- *             <b>Cross-account use</b>: No. You cannot perform this operation on a KMS key in a different Amazon Web Services account.</p>
- *
- *          <p>
- *             <b>Required permissions</b>: <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html">kms:ImportKeyMaterial</a> (key policy)</p>
- *          <p>
- *             <b>Related operations:</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>DeleteImportedKeyMaterial</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>GetParametersForImport</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KMSClient, ImportKeyMaterialCommand } from "@aws-sdk/client-kms"; // ES Modules import
- * // const { KMSClient, ImportKeyMaterialCommand } = require("@aws-sdk/client-kms"); // CommonJS import
- * const client = new KMSClient(config);
- * const command = new ImportKeyMaterialCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportKeyMaterialCommandInput} for command's `input` shape.
- * @see {@link ImportKeyMaterialCommandOutput} for command's `response` shape.
- * @see {@link KMSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ImportKeyMaterialCommand extends $Command<
-  ImportKeyMaterialCommandInput,
-  ImportKeyMaterialCommandOutput,
-  KMSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ImportKeyMaterialCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: KMSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ImportKeyMaterialCommandInput, ImportKeyMaterialCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "KMSClient";
-    const commandName = "ImportKeyMaterialCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ImportKeyMaterialRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: ImportKeyMaterialResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ImportKeyMaterialCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1ImportKeyMaterialCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ImportKeyMaterialCommandOutput> {
-    return deserializeAws_json1_1ImportKeyMaterialCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/ListAliasesCommand.ts

@@ -1,133 +0,0 @@
-import { KMSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KMSClient";
-import { ListAliasesRequest, ListAliasesResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1ListAliasesCommand,
-  serializeAws_json1_1ListAliasesCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface ListAliasesCommandInput extends ListAliasesRequest {}
-export interface ListAliasesCommandOutput extends ListAliasesResponse, __MetadataBearer {}
-
-/**
- * <p>Gets a list of aliases in the caller's Amazon Web Services account and region. For more information about
- *       aliases, see <a>CreateAlias</a>.</p>
- *          <p>By default, the <code>ListAliases</code> operation returns all aliases in the account and
- *       region. To get only the aliases associated with a particular KMS key, use
- *       the <code>KeyId</code> parameter.</p>
- *          <p>The <code>ListAliases</code> response can include aliases that you created and associated
- *       with your customer managed keys, and aliases that Amazon Web Services created and associated with Amazon Web Services managed keys in your account. You can recognize Amazon Web Services aliases because their names have the format
- *         <code>aws/<service-name></code>, such as <code>aws/dynamodb</code>.</p>
- *          <p>The response might also include aliases that have no <code>TargetKeyId</code> field. These
- *       are predefined aliases that Amazon Web Services has created but has not yet associated with a KMS key. Aliases
- *       that Amazon Web Services creates in your account, including predefined aliases, do not count against your
- *         <a href="https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#aliases-limit">KMS aliases
- *         quota</a>.</p>
- *          <p>
- *             <b>Cross-account use</b>: No. <code>ListAliases</code> does not
- *       return aliases in other Amazon Web Services accounts.</p>
- *
- *          <p>
- *             <b>Required permissions</b>: <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html">kms:ListAliases</a> (IAM policy)</p>
- *          <p>For details, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html#alias-access">Controlling access to aliases</a> in the <i>Key Management Service Developer Guide</i>.</p>
- *          <p>
- *             <b>Related operations:</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>CreateAlias</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteAlias</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>UpdateAlias</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KMSClient, ListAliasesCommand } from "@aws-sdk/client-kms"; // ES Modules import
- * // const { KMSClient, ListAliasesCommand } = require("@aws-sdk/client-kms"); // CommonJS import
- * const client = new KMSClient(config);
- * const command = new ListAliasesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAliasesCommandInput} for command's `input` shape.
- * @see {@link ListAliasesCommandOutput} for command's `response` shape.
- * @see {@link KMSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListAliasesCommand extends $Command<
-  ListAliasesCommandInput,
-  ListAliasesCommandOutput,
-  KMSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListAliasesCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: KMSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListAliasesCommandInput, ListAliasesCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "KMSClient";
-    const commandName = "ListAliasesCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListAliasesRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: ListAliasesResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListAliasesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1ListAliasesCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListAliasesCommandOutput> {
-    return deserializeAws_json1_1ListAliasesCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}