@aws-sdk/client-ec2 3.309.0 → 3.310.1

package/dist-types/ts3.4/commands/AssociateVpcCidrBlockCommand.d.ts

@@ -1,41 +1,80 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  EC2ClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../EC2Client";
-import {
-  AssociateVpcCidrBlockRequest,
-  AssociateVpcCidrBlockResult,
-} from "../models/models_0";
-export interface AssociateVpcCidrBlockCommandInput
-  extends AssociateVpcCidrBlockRequest {}
-export interface AssociateVpcCidrBlockCommandOutput
-  extends AssociateVpcCidrBlockResult,
-    __MetadataBearer {}
-export declare class AssociateVpcCidrBlockCommand extends $Command<
-  AssociateVpcCidrBlockCommandInput,
-  AssociateVpcCidrBlockCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AssociateVpcCidrBlockCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AssociateVpcCidrBlockCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AssociateVpcCidrBlockCommandInput,
-    AssociateVpcCidrBlockCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { AssociateVpcCidrBlockRequest, AssociateVpcCidrBlockResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AssociateVpcCidrBlockCommand}.
+ */
+export interface AssociateVpcCidrBlockCommandInput extends AssociateVpcCidrBlockRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AssociateVpcCidrBlockCommand}.
+ */
+export interface AssociateVpcCidrBlockCommandOutput extends AssociateVpcCidrBlockResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Associates a CIDR block with your VPC. You can associate a secondary IPv4 CIDR block,
+ *             an Amazon-provided IPv6 CIDR block, or an IPv6 CIDR block from an IPv6 address pool that
+ *             you provisioned through bring your own IP addresses (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>). The IPv6 CIDR block size is fixed
+ *             at /56.</p>
+ *          <p>You must specify one of the following in the request: an IPv4 CIDR block, an IPv6
+ *             pool, or an Amazon-provided IPv6 CIDR block.</p>
+ *          <p>For more information about associating CIDR blocks with your VPC and applicable
+ *             restrictions, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#VPC_Sizing">VPC and subnet sizing</a> in the
+ *                 <i>Amazon Virtual Private Cloud User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AssociateVpcCidrBlockCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AssociateVpcCidrBlockCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AssociateVpcCidrBlockRequest
+ *   AmazonProvidedIpv6CidrBlock: true || false,
+ *   CidrBlock: "STRING_VALUE",
+ *   VpcId: "STRING_VALUE", // required
+ *   Ipv6CidrBlockNetworkBorderGroup: "STRING_VALUE",
+ *   Ipv6Pool: "STRING_VALUE",
+ *   Ipv6CidrBlock: "STRING_VALUE",
+ *   Ipv4IpamPoolId: "STRING_VALUE",
+ *   Ipv4NetmaskLength: Number("int"),
+ *   Ipv6IpamPoolId: "STRING_VALUE",
+ *   Ipv6NetmaskLength: Number("int"),
+ * };
+ * const command = new AssociateVpcCidrBlockCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AssociateVpcCidrBlockCommandInput - {@link AssociateVpcCidrBlockCommandInput}
+ * @returns {@link AssociateVpcCidrBlockCommandOutput}
+ * @see {@link AssociateVpcCidrBlockCommandInput} for command's `input` shape.
+ * @see {@link AssociateVpcCidrBlockCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AssociateVpcCidrBlockCommand extends $Command<AssociateVpcCidrBlockCommandInput, AssociateVpcCidrBlockCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AssociateVpcCidrBlockCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AssociateVpcCidrBlockCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateVpcCidrBlockCommandInput, AssociateVpcCidrBlockCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AttachClassicLinkVpcCommand.d.ts

@@ -1,41 +1,77 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  EC2ClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../EC2Client";
-import {
-  AttachClassicLinkVpcRequest,
-  AttachClassicLinkVpcResult,
-} from "../models/models_0";
-export interface AttachClassicLinkVpcCommandInput
-  extends AttachClassicLinkVpcRequest {}
-export interface AttachClassicLinkVpcCommandOutput
-  extends AttachClassicLinkVpcResult,
-    __MetadataBearer {}
-export declare class AttachClassicLinkVpcCommand extends $Command<
-  AttachClassicLinkVpcCommandInput,
-  AttachClassicLinkVpcCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AttachClassicLinkVpcCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AttachClassicLinkVpcCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AttachClassicLinkVpcCommandInput,
-    AttachClassicLinkVpcCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { AttachClassicLinkVpcRequest, AttachClassicLinkVpcResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AttachClassicLinkVpcCommand}.
+ */
+export interface AttachClassicLinkVpcCommandInput extends AttachClassicLinkVpcRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AttachClassicLinkVpcCommand}.
+ */
+export interface AttachClassicLinkVpcCommandOutput extends AttachClassicLinkVpcResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <note>
+ *             <p>We are retiring EC2-Classic. We recommend that you migrate from EC2-Classic to a VPC. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html">Migrate from EC2-Classic to a VPC</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
+ *          </note>
+ *          <p>Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or more of the VPC's
+ * 			security groups. You cannot link an EC2-Classic instance to more than one VPC at a time. You
+ * 			can only link an instance that's in the <code>running</code> state. An instance is
+ * 			automatically unlinked from a VPC when it's stopped - you can link it to the VPC again when
+ * 			you restart it.</p>
+ *          <p>After you've linked an instance, you cannot change the VPC security groups that are associated with it. To change the security groups, you must first unlink the instance, and then link it again.</p>
+ *          <p>Linking your instance to a VPC is sometimes referred to as <i>attaching</i> your instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AttachClassicLinkVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AttachClassicLinkVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AttachClassicLinkVpcRequest
+ *   DryRun: true || false,
+ *   Groups: [ // GroupIdStringList // required
+ *     "STRING_VALUE",
+ *   ],
+ *   InstanceId: "STRING_VALUE", // required
+ *   VpcId: "STRING_VALUE", // required
+ * };
+ * const command = new AttachClassicLinkVpcCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AttachClassicLinkVpcCommandInput - {@link AttachClassicLinkVpcCommandInput}
+ * @returns {@link AttachClassicLinkVpcCommandOutput}
+ * @see {@link AttachClassicLinkVpcCommandInput} for command's `input` shape.
+ * @see {@link AttachClassicLinkVpcCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AttachClassicLinkVpcCommand extends $Command<AttachClassicLinkVpcCommandInput, AttachClassicLinkVpcCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AttachClassicLinkVpcCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AttachClassicLinkVpcCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachClassicLinkVpcCommandInput, AttachClassicLinkVpcCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AttachInternetGatewayCommand.d.ts

@@ -1,36 +1,78 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  EC2ClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../EC2Client";
-import { AttachInternetGatewayRequest } from "../models/models_0";
-export interface AttachInternetGatewayCommandInput
-  extends AttachInternetGatewayRequest {}
-export interface AttachInternetGatewayCommandOutput extends __MetadataBearer {}
-export declare class AttachInternetGatewayCommand extends $Command<
-  AttachInternetGatewayCommandInput,
-  AttachInternetGatewayCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AttachInternetGatewayCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AttachInternetGatewayCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AttachInternetGatewayCommandInput,
-    AttachInternetGatewayCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { AttachInternetGatewayRequest } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AttachInternetGatewayCommand}.
+ */
+export interface AttachInternetGatewayCommandInput extends AttachInternetGatewayRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AttachInternetGatewayCommand}.
+ */
+export interface AttachInternetGatewayCommandOutput extends __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Attaches an internet gateway or a virtual private gateway to a VPC, enabling connectivity between the internet and
+ * 			the VPC. For more information about your VPC and internet gateway, see the <a href="https://docs.aws.amazon.com/vpc/latest/userguide/">Amazon Virtual Private Cloud User Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AttachInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AttachInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AttachInternetGatewayRequest
+ *   DryRun: true || false,
+ *   InternetGatewayId: "STRING_VALUE", // required
+ *   VpcId: "STRING_VALUE", // required
+ * };
+ * const command = new AttachInternetGatewayCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AttachInternetGatewayCommandInput - {@link AttachInternetGatewayCommandInput}
+ * @returns {@link AttachInternetGatewayCommandOutput}
+ * @see {@link AttachInternetGatewayCommandInput} for command's `input` shape.
+ * @see {@link AttachInternetGatewayCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ * @example To attach an Internet gateway to a VPC
+ * ```javascript
+ * // This example attaches the specified Internet gateway to the specified VPC.
+ * const input = {
+ *   "InternetGatewayId": "igw-c0a643a9",
+ *   "VpcId": "vpc-a01106c2"
+ * };
+ * const command = new AttachInternetGatewayCommand(input);
+ * await client.send(command);
+ * // example id: ec2-attach-internet-gateway-1
+ * ```
+ *
+ */
+export declare class AttachInternetGatewayCommand extends $Command<AttachInternetGatewayCommandInput, AttachInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AttachInternetGatewayCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AttachInternetGatewayCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachInternetGatewayCommandInput, AttachInternetGatewayCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AttachNetworkInterfaceCommand.d.ts

@@ -1,41 +1,91 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  EC2ClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../EC2Client";
-import {
-  AttachNetworkInterfaceRequest,
-  AttachNetworkInterfaceResult,
-} from "../models/models_0";
-export interface AttachNetworkInterfaceCommandInput
-  extends AttachNetworkInterfaceRequest {}
-export interface AttachNetworkInterfaceCommandOutput
-  extends AttachNetworkInterfaceResult,
-    __MetadataBearer {}
-export declare class AttachNetworkInterfaceCommand extends $Command<
-  AttachNetworkInterfaceCommandInput,
-  AttachNetworkInterfaceCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AttachNetworkInterfaceCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AttachNetworkInterfaceCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AttachNetworkInterfaceCommandInput,
-    AttachNetworkInterfaceCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { AttachNetworkInterfaceRequest, AttachNetworkInterfaceResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AttachNetworkInterfaceCommand}.
+ */
+export interface AttachNetworkInterfaceCommandInput extends AttachNetworkInterfaceRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AttachNetworkInterfaceCommand}.
+ */
+export interface AttachNetworkInterfaceCommandOutput extends AttachNetworkInterfaceResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Attaches a network interface to an instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AttachNetworkInterfaceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AttachNetworkInterfaceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AttachNetworkInterfaceRequest
+ *   DeviceIndex: Number("int"), // required
+ *   DryRun: true || false,
+ *   InstanceId: "STRING_VALUE", // required
+ *   NetworkInterfaceId: "STRING_VALUE", // required
+ *   NetworkCardIndex: Number("int"),
+ *   EnaSrdSpecification: { // EnaSrdSpecification
+ *     EnaSrdEnabled: true || false,
+ *     EnaSrdUdpSpecification: { // EnaSrdUdpSpecification
+ *       EnaSrdUdpEnabled: true || false,
+ *     },
+ *   },
+ * };
+ * const command = new AttachNetworkInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AttachNetworkInterfaceCommandInput - {@link AttachNetworkInterfaceCommandInput}
+ * @returns {@link AttachNetworkInterfaceCommandOutput}
+ * @see {@link AttachNetworkInterfaceCommandInput} for command's `input` shape.
+ * @see {@link AttachNetworkInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ * @example To attach a network interface to an instance
+ * ```javascript
+ * // This example attaches the specified network interface to the specified instance.
+ * const input = {
+ *   "DeviceIndex": 1,
+ *   "InstanceId": "i-1234567890abcdef0",
+ *   "NetworkInterfaceId": "eni-e5aa89a3"
+ * };
+ * const command = new AttachNetworkInterfaceCommand(input);
+ * const response = await client.send(command);
+ * /* response ==
+ * {
+ *   "AttachmentId": "eni-attach-66c4350a"
+ * }
+ * *\/
+ * // example id: ec2-attach-network-interface-1
+ * ```
+ *
+ */
+export declare class AttachNetworkInterfaceCommand extends $Command<AttachNetworkInterfaceCommandInput, AttachNetworkInterfaceCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AttachNetworkInterfaceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AttachNetworkInterfaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachNetworkInterfaceCommandInput, AttachNetworkInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AttachVerifiedAccessTrustProviderCommand.d.ts

@@ -1,41 +1,68 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  EC2ClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../EC2Client";
-import {
-  AttachVerifiedAccessTrustProviderRequest,
-  AttachVerifiedAccessTrustProviderResult,
-} from "../models/models_0";
-export interface AttachVerifiedAccessTrustProviderCommandInput
-  extends AttachVerifiedAccessTrustProviderRequest {}
-export interface AttachVerifiedAccessTrustProviderCommandOutput
-  extends AttachVerifiedAccessTrustProviderResult,
-    __MetadataBearer {}
-export declare class AttachVerifiedAccessTrustProviderCommand extends $Command<
-  AttachVerifiedAccessTrustProviderCommandInput,
-  AttachVerifiedAccessTrustProviderCommandOutput,
-  EC2ClientResolvedConfig
-> {
-  readonly input: AttachVerifiedAccessTrustProviderCommandInput;
-  static getEndpointParameterInstructions(): EndpointParameterInstructions;
-  constructor(input: AttachVerifiedAccessTrustProviderCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EC2ClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    AttachVerifiedAccessTrustProviderCommandInput,
-    AttachVerifiedAccessTrustProviderCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
+import { AttachVerifiedAccessTrustProviderRequest, AttachVerifiedAccessTrustProviderResult } from "../models/models_0";
+/**
+ * @public
+ *
+ * The input for {@link AttachVerifiedAccessTrustProviderCommand}.
+ */
+export interface AttachVerifiedAccessTrustProviderCommandInput extends AttachVerifiedAccessTrustProviderRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link AttachVerifiedAccessTrustProviderCommand}.
+ */
+export interface AttachVerifiedAccessTrustProviderCommandOutput extends AttachVerifiedAccessTrustProviderResult, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>A trust provider is a third-party entity that creates, maintains, and manages identity
+ *          information for users and devices. One or more trust providers can be attached to an Amazon Web Services Verified Access
+ *          instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { EC2Client, AttachVerifiedAccessTrustProviderCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+ * // const { EC2Client, AttachVerifiedAccessTrustProviderCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
+ * const client = new EC2Client(config);
+ * const input = { // AttachVerifiedAccessTrustProviderRequest
+ *   VerifiedAccessInstanceId: "STRING_VALUE", // required
+ *   VerifiedAccessTrustProviderId: "STRING_VALUE", // required
+ *   ClientToken: "STRING_VALUE",
+ *   DryRun: true || false,
+ * };
+ * const command = new AttachVerifiedAccessTrustProviderCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param AttachVerifiedAccessTrustProviderCommandInput - {@link AttachVerifiedAccessTrustProviderCommandInput}
+ * @returns {@link AttachVerifiedAccessTrustProviderCommandOutput}
+ * @see {@link AttachVerifiedAccessTrustProviderCommandInput} for command's `input` shape.
+ * @see {@link AttachVerifiedAccessTrustProviderCommandOutput} for command's `response` shape.
+ * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
+ *
+ *
+ */
+export declare class AttachVerifiedAccessTrustProviderCommand extends $Command<AttachVerifiedAccessTrustProviderCommandInput, AttachVerifiedAccessTrustProviderCommandOutput, EC2ClientResolvedConfig> {
+    readonly input: AttachVerifiedAccessTrustProviderCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: AttachVerifiedAccessTrustProviderCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachVerifiedAccessTrustProviderCommandInput, AttachVerifiedAccessTrustProviderCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}