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

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

@@ -6,30 +6,11 @@ export interface UpdateAuthorizerCommandInput extends UpdateAuthorizerRequest {
 }
 export interface UpdateAuthorizerCommandOutput extends Authorizer, __MetadataBearer {
 }
-/**
- * <p>Updates an existing <a>Authorizer</a> resource.</p>
- *         <div class="seeAlso"><a href="https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-authorizer.html">AWS CLI</a></div>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, UpdateAuthorizerCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UpdateAuthorizerCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UpdateAuthorizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAuthorizerCommandInput} for command's `input` shape.
- * @see {@link UpdateAuthorizerCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAuthorizerCommand extends $Command<UpdateAuthorizerCommandInput, UpdateAuthorizerCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UpdateAuthorizerCommandInput;
     constructor(input: UpdateAuthorizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAuthorizerCommandInput, UpdateAuthorizerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateGatewayResponseCommandInput extends UpdateGatewayResponse
 }
 export interface UpdateGatewayResponseCommandOutput extends GatewayResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <a>GatewayResponse</a> of a specified response type 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, UpdateGatewayResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UpdateGatewayResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UpdateGatewayResponseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateGatewayResponseCommandInput} for command's `input` shape.
- * @see {@link UpdateGatewayResponseCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateGatewayResponseCommand extends $Command<UpdateGatewayResponseCommandInput, UpdateGatewayResponseCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UpdateGatewayResponseCommandInput;
     constructor(input: UpdateGatewayResponseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateGatewayResponseCommandInput, UpdateGatewayResponseCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateMethodCommandInput extends UpdateMethodRequest {
 }
 export interface UpdateMethodCommandOutput extends Method, __MetadataBearer {
 }
-/**
- * <p>Updates 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, UpdateMethodCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, UpdateMethodCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new UpdateMethodCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMethodCommandInput} for command's `input` shape.
- * @see {@link UpdateMethodCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateMethodCommand extends $Command<UpdateMethodCommandInput, UpdateMethodCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: UpdateMethodCommandInput;
     constructor(input: UpdateMethodCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMethodCommandInput, UpdateMethodCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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