@aws-sdk/client-api-gateway 3.36.0 → 3.36.1

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

@@ -6,29 +6,11 @@ export interface GetUsagePlanKeyCommandInput extends GetUsagePlanKeyRequest {
 }
 export interface GetUsagePlanKeyCommandOutput extends UsagePlanKey, __MetadataBearer {
 }
-/**
- * <p>Gets a usage plan key of a given key identifier.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetUsagePlanKeyCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetUsagePlanKeyCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetUsagePlanKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUsagePlanKeyCommandInput} for command's `input` shape.
- * @see {@link GetUsagePlanKeyCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUsagePlanKeyCommand extends $Command<GetUsagePlanKeyCommandInput, GetUsagePlanKeyCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetUsagePlanKeyCommandInput;
     constructor(input: GetUsagePlanKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsagePlanKeyCommandInput, GetUsagePlanKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetUsagePlanKeysCommandInput extends GetUsagePlanKeysRequest {
 }
 export interface GetUsagePlanKeysCommandOutput extends UsagePlanKeys, __MetadataBearer {
 }
-/**
- * <p>Gets all the usage plan keys representing the API keys added to a specified usage plan.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetUsagePlanKeysCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetUsagePlanKeysCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetUsagePlanKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUsagePlanKeysCommandInput} for command's `input` shape.
- * @see {@link GetUsagePlanKeysCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUsagePlanKeysCommand extends $Command<GetUsagePlanKeysCommandInput, GetUsagePlanKeysCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetUsagePlanKeysCommandInput;
     constructor(input: GetUsagePlanKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsagePlanKeysCommandInput, GetUsagePlanKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetUsagePlansCommandInput extends GetUsagePlansRequest {
 }
 export interface GetUsagePlansCommandOutput extends UsagePlans, __MetadataBearer {
 }
-/**
- * <p>Gets all the usage plans of the caller's account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetUsagePlansCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetUsagePlansCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetUsagePlansCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUsagePlansCommandInput} for command's `input` shape.
- * @see {@link GetUsagePlansCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUsagePlansCommand extends $Command<GetUsagePlansCommandInput, GetUsagePlansCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetUsagePlansCommandInput;
     constructor(input: GetUsagePlansCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsagePlansCommandInput, GetUsagePlansCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetVpcLinkCommandInput extends GetVpcLinkRequest {
 }
 export interface GetVpcLinkCommandOutput extends VpcLink, __MetadataBearer {
 }
-/**
- * <p>Gets a specified VPC link under the caller's account in a region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetVpcLinkCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetVpcLinkCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetVpcLinkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetVpcLinkCommandInput} for command's `input` shape.
- * @see {@link GetVpcLinkCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetVpcLinkCommand extends $Command<GetVpcLinkCommandInput, GetVpcLinkCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetVpcLinkCommandInput;
     constructor(input: GetVpcLinkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcLinkCommandInput, GetVpcLinkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetVpcLinksCommandInput extends GetVpcLinksRequest {
 }
 export interface GetVpcLinksCommandOutput extends VpcLinks, __MetadataBearer {
 }
-/**
- * <p>Gets the <a>VpcLinks</a> collection under the caller's account in a selected region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetVpcLinksCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetVpcLinksCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetVpcLinksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetVpcLinksCommandInput} for command's `input` shape.
- * @see {@link GetVpcLinksCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetVpcLinksCommand extends $Command<GetVpcLinksCommandInput, GetVpcLinksCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetVpcLinksCommandInput;
     constructor(input: GetVpcLinksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcLinksCommandInput, GetVpcLinksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ImportApiKeysCommandInput extends ImportApiKeysRequest {
 }
 export interface ImportApiKeysCommandOutput extends ApiKeyIds, __MetadataBearer {
 }
-/**
- * <p>Import API keys from an external source, such as a CSV-formatted file.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, ImportApiKeysCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, ImportApiKeysCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new ImportApiKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportApiKeysCommandInput} for command's `input` shape.
- * @see {@link ImportApiKeysCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportApiKeysCommand extends $Command<ImportApiKeysCommandInput, ImportApiKeysCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: ImportApiKeysCommandInput;
     constructor(input: ImportApiKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportApiKeysCommandInput, ImportApiKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -9,9 +9,7 @@ export interface ImportDocumentationPartsCommandOutput extends DocumentationPart
 export declare class ImportDocumentationPartsCommand extends $Command<ImportDocumentationPartsCommandInput, ImportDocumentationPartsCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: ImportDocumentationPartsCommandInput;
     constructor(input: ImportDocumentationPartsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportDocumentationPartsCommandInput, ImportDocumentationPartsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ImportRestApiCommandInput extends ImportRestApiRequest {
 }
 export interface ImportRestApiCommandOutput extends RestApi, __MetadataBearer {
 }
-/**
- * <p>A feature of the API Gateway control service for creating a new API from an external API definition file.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, ImportRestApiCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, ImportRestApiCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new ImportRestApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportRestApiCommandInput} for command's `input` shape.
- * @see {@link ImportRestApiCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportRestApiCommand extends $Command<ImportRestApiCommandInput, ImportRestApiCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: ImportRestApiCommandInput;
     constructor(input: ImportRestApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportRestApiCommandInput, ImportRestApiCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutGatewayResponseCommandInput extends PutGatewayResponseReques
 }
 export interface PutGatewayResponseCommandOutput extends GatewayResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a customization of a <a>GatewayResponse</a> of a specified response type and status code on the given <a>RestApi</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutGatewayResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutGatewayResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutGatewayResponseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutGatewayResponseCommandInput} for command's `input` shape.
- * @see {@link PutGatewayResponseCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutGatewayResponseCommand extends $Command<PutGatewayResponseCommandInput, PutGatewayResponseCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutGatewayResponseCommandInput;
     constructor(input: PutGatewayResponseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutGatewayResponseCommandInput, PutGatewayResponseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutIntegrationCommandInput extends PutIntegrationRequest {
 }
 export interface PutIntegrationCommandOutput extends Integration, __MetadataBearer {
 }
-/**
- * <p>Sets up a method's integration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutIntegrationCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutIntegrationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutIntegrationCommandInput} for command's `input` shape.
- * @see {@link PutIntegrationCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutIntegrationCommand extends $Command<PutIntegrationCommandInput, PutIntegrationCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutIntegrationCommandInput;
     constructor(input: PutIntegrationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIntegrationCommandInput, PutIntegrationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutIntegrationResponseCommandInput extends PutIntegrationRespon
 }
 export interface PutIntegrationResponseCommandOutput extends IntegrationResponse, __MetadataBearer {
 }
-/**
- * <p>Represents a put integration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutIntegrationResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutIntegrationResponseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutIntegrationResponseCommandInput} for command's `input` shape.
- * @see {@link PutIntegrationResponseCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutIntegrationResponseCommand extends $Command<PutIntegrationResponseCommandInput, PutIntegrationResponseCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutIntegrationResponseCommandInput;
     constructor(input: PutIntegrationResponseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIntegrationResponseCommandInput, PutIntegrationResponseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutMethodCommandInput extends PutMethodRequest {
 }
 export interface PutMethodCommandOutput extends Method, __MetadataBearer {
 }
-/**
- * <p>Add a method to an existing <a>Resource</a> resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutMethodCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutMethodCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMethodCommandInput} for command's `input` shape.
- * @see {@link PutMethodCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMethodCommand extends $Command<PutMethodCommandInput, PutMethodCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutMethodCommandInput;
     constructor(input: PutMethodCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMethodCommandInput, PutMethodCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutMethodResponseCommandInput extends PutMethodResponseRequest
 }
 export interface PutMethodResponseCommandOutput extends MethodResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a <a>MethodResponse</a> to an existing <a>Method</a> resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutMethodResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutMethodResponseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMethodResponseCommandInput} for command's `input` shape.
- * @see {@link PutMethodResponseCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMethodResponseCommand extends $Command<PutMethodResponseCommandInput, PutMethodResponseCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutMethodResponseCommandInput;
     constructor(input: PutMethodResponseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMethodResponseCommandInput, PutMethodResponseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutRestApiCommandInput extends PutRestApiRequest {
 }
 export interface PutRestApiCommandOutput extends RestApi, __MetadataBearer {
 }
-/**
- * <p>A feature of the API Gateway control service for updating an existing API with an input of external API definitions.
- *             The update can take the form of merging the supplied definition into the existing API or overwriting the existing API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, PutRestApiCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, PutRestApiCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new PutRestApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRestApiCommandInput} for command's `input` shape.
- * @see {@link PutRestApiCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRestApiCommand extends $Command<PutRestApiCommandInput, PutRestApiCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: PutRestApiCommandInput;
     constructor(input: PutRestApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRestApiCommandInput, PutRestApiCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds or updates a tag on a given resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, TagResourceCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, TagResourceCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface TestInvokeAuthorizerCommandInput extends TestInvokeAuthorizerRe
 }
 export interface TestInvokeAuthorizerCommandOutput extends TestInvokeAuthorizerResponse, __MetadataBearer {
 }
-/**
- * <p>Simulate the execution of an <a>Authorizer</a> in your <a>RestApi</a> with headers, parameters, and an incoming request body.</p>
- *       <div class="seeAlso">
- *         <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html">Use Lambda Function as Authorizer</a>
- *         <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html">Use Cognito User Pool as Authorizer</a>
- *       </div>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, TestInvokeAuthorizerCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, TestInvokeAuthorizerCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new TestInvokeAuthorizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestInvokeAuthorizerCommandInput} for command's `input` shape.
- * @see {@link TestInvokeAuthorizerCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestInvokeAuthorizerCommand extends $Command<TestInvokeAuthorizerCommandInput, TestInvokeAuthorizerCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: TestInvokeAuthorizerCommandInput;
     constructor(input: TestInvokeAuthorizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestInvokeAuthorizerCommandInput, TestInvokeAuthorizerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TestInvokeMethodCommandInput extends TestInvokeMethodRequest {
 }
 export interface TestInvokeMethodCommandOutput extends TestInvokeMethodResponse, __MetadataBearer {
 }
-/**
- * <p>Simulate the execution of a <a>Method</a> in your <a>RestApi</a> with headers, parameters, and an incoming request body.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, TestInvokeMethodCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new TestInvokeMethodCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestInvokeMethodCommandInput} for command's `input` shape.
- * @see {@link TestInvokeMethodCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestInvokeMethodCommand extends $Command<TestInvokeMethodCommandInput, TestInvokeMethodCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: TestInvokeMethodCommandInput;
     constructor(input: TestInvokeMethodCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestInvokeMethodCommandInput, TestInvokeMethodCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes a tag from a given resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, UntagResourceCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UntagResourceCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateAccountCommandInput extends UpdateAccountRequest {
 }
 export interface UpdateAccountCommandOutput extends Account, __MetadataBearer {
 }
-/**
- * <p>Changes information about the current <a>Account</a> resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, UpdateAccountCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UpdateAccountCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UpdateAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccountCommandInput} for command's `input` shape.
- * @see {@link UpdateAccountCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAccountCommand extends $Command<UpdateAccountCommandInput, UpdateAccountCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UpdateAccountCommandInput;
     constructor(input: UpdateAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccountCommandInput, UpdateAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApiKeyCommandInput extends UpdateApiKeyRequest {
 }
 export interface UpdateApiKeyCommandOutput extends ApiKey, __MetadataBearer {
 }
-/**
- * <p>Changes information about an <a>ApiKey</a> resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, UpdateApiKeyCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UpdateApiKeyCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UpdateApiKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApiKeyCommandInput} for command's `input` shape.
- * @see {@link UpdateApiKeyCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApiKeyCommand extends $Command<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UpdateApiKeyCommandInput;
     constructor(input: UpdateApiKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput>;
     private serialize;
     private deserialize;