@aws-sdk/client-ec2 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTagsRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTagsCommand}.
  */
 export interface CreateTagsCommandInput extends CreateTagsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTagsCommand}.
  */
 export interface CreateTagsCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds or overwrites only the specified tags for the specified Amazon EC2 resource or
  *          resources. When you specify an existing tag key, the value is overwritten with
  *          the new value. Each resource can have a maximum of 50 tags. Each tag consists of a key and
@@ -33,6 +38,8 @@ export interface CreateTagsCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTagsCommandInput - {@link CreateTagsCommandInput}
+ * @returns {@link CreateTagsCommandOutput}
  * @see {@link CreateTagsCommandInput} for command's `input` shape.
  * @see {@link CreateTagsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -61,11 +68,20 @@ export interface CreateTagsCommandOutput extends __MetadataBearer {
 export declare class CreateTagsCommand extends $Command<CreateTagsCommandInput, CreateTagsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTagsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTagsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTagsCommandInput, CreateTagsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTrafficMirrorFilterRequest, CreateTrafficMirrorFilterResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTrafficMirrorFilterCommand}.
  */
 export interface CreateTrafficMirrorFilterCommandInput extends CreateTrafficMirrorFilterRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTrafficMirrorFilterCommand}.
  */
 export interface CreateTrafficMirrorFilterCommandOutput extends CreateTrafficMirrorFilterResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Traffic Mirror filter.</p>
  *          <p>A Traffic Mirror filter is a set of rules that defines the traffic to mirror.</p>
  *          <p>By default, no traffic is mirrored. To mirror traffic, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm">CreateTrafficMirrorFilterRule</a> to add Traffic Mirror rules to the filter. The rules you
@@ -28,6 +33,8 @@ export interface CreateTrafficMirrorFilterCommandOutput extends CreateTrafficMir
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTrafficMirrorFilterCommandInput - {@link CreateTrafficMirrorFilterCommandInput}
+ * @returns {@link CreateTrafficMirrorFilterCommandOutput}
  * @see {@link CreateTrafficMirrorFilterCommandInput} for command's `input` shape.
  * @see {@link CreateTrafficMirrorFilterCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateTrafficMirrorFilterCommandOutput extends CreateTrafficMir
 export declare class CreateTrafficMirrorFilterCommand extends $Command<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorFilterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTrafficMirrorFilterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTrafficMirrorFilterRuleRequest, CreateTrafficMirrorFilterRuleResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTrafficMirrorFilterRuleCommand}.
  */
 export interface CreateTrafficMirrorFilterRuleCommandInput extends CreateTrafficMirrorFilterRuleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTrafficMirrorFilterRuleCommand}.
  */
 export interface CreateTrafficMirrorFilterRuleCommandOutput extends CreateTrafficMirrorFilterRuleResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Traffic Mirror filter rule.</p>
  *          <p>A Traffic Mirror rule defines the Traffic Mirror source traffic to mirror.</p>
  *          <p>You need the Traffic Mirror filter ID when you create the rule.</p>
@@ -27,6 +32,8 @@ export interface CreateTrafficMirrorFilterRuleCommandOutput extends CreateTraffi
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTrafficMirrorFilterRuleCommandInput - {@link CreateTrafficMirrorFilterRuleCommandInput}
+ * @returns {@link CreateTrafficMirrorFilterRuleCommandOutput}
  * @see {@link CreateTrafficMirrorFilterRuleCommandInput} for command's `input` shape.
  * @see {@link CreateTrafficMirrorFilterRuleCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface CreateTrafficMirrorFilterRuleCommandOutput extends CreateTraffi
 export declare class CreateTrafficMirrorFilterRuleCommand extends $Command<CreateTrafficMirrorFilterRuleCommandInput, CreateTrafficMirrorFilterRuleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorFilterRuleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTrafficMirrorFilterRuleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorFilterRuleCommandInput, CreateTrafficMirrorFilterRuleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTrafficMirrorSessionRequest, CreateTrafficMirrorSessionResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTrafficMirrorSessionCommand}.
  */
 export interface CreateTrafficMirrorSessionCommandInput extends CreateTrafficMirrorSessionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTrafficMirrorSessionCommand}.
  */
 export interface CreateTrafficMirrorSessionCommandOutput extends CreateTrafficMirrorSessionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Traffic Mirror session.</p>
  *          <p>A Traffic Mirror session actively copies packets from a Traffic Mirror source to a Traffic Mirror target. Create a filter, and then assign it
  *          to the session to define a subset of the traffic to mirror, for example all TCP
@@ -31,6 +36,8 @@ export interface CreateTrafficMirrorSessionCommandOutput extends CreateTrafficMi
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTrafficMirrorSessionCommandInput - {@link CreateTrafficMirrorSessionCommandInput}
+ * @returns {@link CreateTrafficMirrorSessionCommandOutput}
  * @see {@link CreateTrafficMirrorSessionCommandInput} for command's `input` shape.
  * @see {@link CreateTrafficMirrorSessionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -40,11 +47,20 @@ export interface CreateTrafficMirrorSessionCommandOutput extends CreateTrafficMi
 export declare class CreateTrafficMirrorSessionCommand extends $Command<CreateTrafficMirrorSessionCommandInput, CreateTrafficMirrorSessionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorSessionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTrafficMirrorSessionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorSessionCommandInput, CreateTrafficMirrorSessionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTrafficMirrorTargetRequest, CreateTrafficMirrorTargetResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTrafficMirrorTargetCommand}.
  */
 export interface CreateTrafficMirrorTargetCommandInput extends CreateTrafficMirrorTargetRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTrafficMirrorTargetCommand}.
  */
 export interface CreateTrafficMirrorTargetCommandOutput extends CreateTrafficMirrorTargetResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a target for your Traffic Mirror session.</p>
  *          <p>A Traffic Mirror target is the destination for mirrored traffic. The Traffic Mirror source and
  *          the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in
@@ -30,6 +35,8 @@ export interface CreateTrafficMirrorTargetCommandOutput extends CreateTrafficMir
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTrafficMirrorTargetCommandInput - {@link CreateTrafficMirrorTargetCommandInput}
+ * @returns {@link CreateTrafficMirrorTargetCommandOutput}
  * @see {@link CreateTrafficMirrorTargetCommandInput} for command's `input` shape.
  * @see {@link CreateTrafficMirrorTargetCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -39,11 +46,20 @@ export interface CreateTrafficMirrorTargetCommandOutput extends CreateTrafficMir
 export declare class CreateTrafficMirrorTargetCommand extends $Command<CreateTrafficMirrorTargetCommandInput, CreateTrafficMirrorTargetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorTargetCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTrafficMirrorTargetCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorTargetCommandInput, CreateTrafficMirrorTargetCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayRequest, CreateTransitGatewayResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayCommand}.
  */
 export interface CreateTransitGatewayCommandInput extends CreateTransitGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayCommand}.
  */
 export interface CreateTransitGatewayCommandOutput extends CreateTransitGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a transit gateway.</p>
  *          <p>You can use a transit gateway to interconnect your virtual private clouds (VPC) and on-premises networks.
  *           After the transit gateway enters the <code>available</code> state, you can attach your VPCs and VPN
@@ -37,6 +42,8 @@ export interface CreateTransitGatewayCommandOutput extends CreateTransitGatewayR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayCommandInput - {@link CreateTransitGatewayCommandInput}
+ * @returns {@link CreateTransitGatewayCommandOutput}
  * @see {@link CreateTransitGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateTransitGatewayCommandOutput extends CreateTransitGatewayR
 export declare class CreateTransitGatewayCommand extends $Command<CreateTransitGatewayCommandInput, CreateTransitGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayCommandInput, CreateTransitGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayConnectRequest, CreateTransitGatewayConnectResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayConnectCommand}.
  */
 export interface CreateTransitGatewayConnectCommandInput extends CreateTransitGatewayConnectRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayConnectCommand}.
  */
 export interface CreateTransitGatewayConnectCommandOutput extends CreateTransitGatewayConnectResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Connect attachment from a specified transit gateway attachment. A Connect attachment is a GRE-based tunnel attachment that you can use to establish a connection between a transit gateway and an appliance.</p>
  *          <p>A Connect attachment uses an existing VPC or Amazon Web Services Direct Connect attachment as the underlying transport mechanism.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateTransitGatewayConnectCommandOutput extends CreateTransitG
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayConnectCommandInput - {@link CreateTransitGatewayConnectCommandInput}
+ * @returns {@link CreateTransitGatewayConnectCommandOutput}
  * @see {@link CreateTransitGatewayConnectCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayConnectCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface CreateTransitGatewayConnectCommandOutput extends CreateTransitG
 export declare class CreateTransitGatewayConnectCommand extends $Command<CreateTransitGatewayConnectCommandInput, CreateTransitGatewayConnectCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayConnectCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayConnectCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayConnectCommandInput, CreateTransitGatewayConnectCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayConnectPeerRequest, CreateTransitGatewayConnectPeerResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayConnectPeerCommand}.
  */
 export interface CreateTransitGatewayConnectPeerCommandInput extends CreateTransitGatewayConnectPeerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayConnectPeerCommand}.
  */
 export interface CreateTransitGatewayConnectPeerCommandOutput extends CreateTransitGatewayConnectPeerResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Connect peer for a specified transit gateway Connect attachment between a
  *             transit gateway and an appliance.</p>
  *          <p>The peer address and transit gateway address must be the same IP address family (IPv4 or IPv6).</p>
@@ -28,6 +33,8 @@ export interface CreateTransitGatewayConnectPeerCommandOutput extends CreateTran
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayConnectPeerCommandInput - {@link CreateTransitGatewayConnectPeerCommandInput}
+ * @returns {@link CreateTransitGatewayConnectPeerCommandOutput}
  * @see {@link CreateTransitGatewayConnectPeerCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayConnectPeerCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateTransitGatewayConnectPeerCommandOutput extends CreateTran
 export declare class CreateTransitGatewayConnectPeerCommand extends $Command<CreateTransitGatewayConnectPeerCommandInput, CreateTransitGatewayConnectPeerCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayConnectPeerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayConnectPeerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayConnectPeerCommandInput, CreateTransitGatewayConnectPeerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayMulticastDomainRequest, CreateTransitGatewayMulticastDomainResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayMulticastDomainCommand}.
  */
 export interface CreateTransitGatewayMulticastDomainCommandInput extends CreateTransitGatewayMulticastDomainRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayMulticastDomainCommand}.
  */
 export interface CreateTransitGatewayMulticastDomainCommandOutput extends CreateTransitGatewayMulticastDomainResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a multicast domain using the specified transit gateway.</p>
  *          <p>The transit gateway  must be in the available state before you create a domain. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGateways.html">DescribeTransitGateways</a> to see the state of transit gateway.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateTransitGatewayMulticastDomainCommandOutput extends Create
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayMulticastDomainCommandInput - {@link CreateTransitGatewayMulticastDomainCommandInput}
+ * @returns {@link CreateTransitGatewayMulticastDomainCommandOutput}
  * @see {@link CreateTransitGatewayMulticastDomainCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayMulticastDomainCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface CreateTransitGatewayMulticastDomainCommandOutput extends Create
 export declare class CreateTransitGatewayMulticastDomainCommand extends $Command<CreateTransitGatewayMulticastDomainCommandInput, CreateTransitGatewayMulticastDomainCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayMulticastDomainCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayMulticastDomainCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayMulticastDomainCommandInput, CreateTransitGatewayMulticastDomainCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayPeeringAttachmentRequest, CreateTransitGatewayPeeringAttachmentResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayPeeringAttachmentCommand}.
  */
 export interface CreateTransitGatewayPeeringAttachmentCommandInput extends CreateTransitGatewayPeeringAttachmentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayPeeringAttachmentCommand}.
  */
 export interface CreateTransitGatewayPeeringAttachmentCommandOutput extends CreateTransitGatewayPeeringAttachmentResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Requests a transit gateway peering attachment between the specified transit gateway
  *             (requester) and a peer transit gateway (accepter). The peer transit gateway can be in
  *             your account or a different Amazon Web Services account.</p>
@@ -29,6 +34,8 @@ export interface CreateTransitGatewayPeeringAttachmentCommandOutput extends Crea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayPeeringAttachmentCommandInput - {@link CreateTransitGatewayPeeringAttachmentCommandInput}
+ * @returns {@link CreateTransitGatewayPeeringAttachmentCommandOutput}
  * @see {@link CreateTransitGatewayPeeringAttachmentCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayPeeringAttachmentCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -38,11 +45,20 @@ export interface CreateTransitGatewayPeeringAttachmentCommandOutput extends Crea
 export declare class CreateTransitGatewayPeeringAttachmentCommand extends $Command<CreateTransitGatewayPeeringAttachmentCommandInput, CreateTransitGatewayPeeringAttachmentCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayPeeringAttachmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayPeeringAttachmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPeeringAttachmentCommandInput, CreateTransitGatewayPeeringAttachmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayPolicyTableRequest, CreateTransitGatewayPolicyTableResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayPolicyTableCommand}.
  */
 export interface CreateTransitGatewayPolicyTableCommandInput extends CreateTransitGatewayPolicyTableRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayPolicyTableCommand}.
  */
 export interface CreateTransitGatewayPolicyTableCommandOutput extends CreateTransitGatewayPolicyTableResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a transit gateway policy table.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateTransitGatewayPolicyTableCommandOutput extends CreateTran
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayPolicyTableCommandInput - {@link CreateTransitGatewayPolicyTableCommandInput}
+ * @returns {@link CreateTransitGatewayPolicyTableCommandOutput}
  * @see {@link CreateTransitGatewayPolicyTableCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayPolicyTableCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateTransitGatewayPolicyTableCommandOutput extends CreateTran
 export declare class CreateTransitGatewayPolicyTableCommand extends $Command<CreateTransitGatewayPolicyTableCommandInput, CreateTransitGatewayPolicyTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayPolicyTableCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayPolicyTableCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPolicyTableCommandInput, CreateTransitGatewayPolicyTableCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateTransitGatewayPrefixListReferenceRequest, CreateTransitGatewayPrefixListReferenceResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayPrefixListReferenceCommand}.
  */
 export interface CreateTransitGatewayPrefixListReferenceCommandInput extends CreateTransitGatewayPrefixListReferenceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayPrefixListReferenceCommand}.
  */
 export interface CreateTransitGatewayPrefixListReferenceCommandOutput extends CreateTransitGatewayPrefixListReferenceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a reference (route) to a prefix list in a specified transit gateway route table.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateTransitGatewayPrefixListReferenceCommandOutput extends Cr
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayPrefixListReferenceCommandInput - {@link CreateTransitGatewayPrefixListReferenceCommandInput}
+ * @returns {@link CreateTransitGatewayPrefixListReferenceCommandOutput}
  * @see {@link CreateTransitGatewayPrefixListReferenceCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayPrefixListReferenceCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateTransitGatewayPrefixListReferenceCommandOutput extends Cr
 export declare class CreateTransitGatewayPrefixListReferenceCommand extends $Command<CreateTransitGatewayPrefixListReferenceCommandInput, CreateTransitGatewayPrefixListReferenceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayPrefixListReferenceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayPrefixListReferenceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPrefixListReferenceCommandInput, CreateTransitGatewayPrefixListReferenceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }