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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetAuthorizerCommandInput extends GetAuthorizerRequest {
 }
 export interface GetAuthorizerCommandOutput extends Authorizer, __MetadataBearer {
 }
-/**
- * <p>Describe an existing <a>Authorizer</a> resource.</p>
- *         <div class="seeAlso"><a href="https://docs.aws.amazon.com/cli/latest/reference/apigateway/get-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, GetAuthorizerCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetAuthorizerCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetAuthorizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAuthorizerCommandInput} for command's `input` shape.
- * @see {@link GetAuthorizerCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAuthorizerCommand extends $Command<GetAuthorizerCommandInput, GetAuthorizerCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetAuthorizerCommandInput;
     constructor(input: GetAuthorizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAuthorizerCommandInput, GetAuthorizerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetDomainNameCommandInput extends GetDomainNameRequest {
 }
 export interface GetDomainNameCommandOutput extends DomainName, __MetadataBearer {
 }
-/**
- * <p>Represents a domain name that is contained in a simpler, more intuitive URL that can be called.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetDomainNameCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetDomainNameCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetDomainNameCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDomainNameCommandInput} for command's `input` shape.
- * @see {@link GetDomainNameCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainNameCommand extends $Command<GetDomainNameCommandInput, GetDomainNameCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetDomainNameCommandInput;
     constructor(input: GetDomainNameCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainNameCommandInput, GetDomainNameCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetGatewayResponsesCommandInput extends GetGatewayResponsesRequ
 }
 export interface GetGatewayResponsesCommandOutput extends GatewayResponses, __MetadataBearer {
 }
-/**
- * <p>Gets the <a>GatewayResponses</a> collection on the given <a>RestApi</a>. If an API developer has not added any definitions for gateway responses, the result will be the API Gateway-generated default <a>GatewayResponses</a> collection for the supported response types.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetGatewayResponsesCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetGatewayResponsesCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetGatewayResponsesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGatewayResponsesCommandInput} for command's `input` shape.
- * @see {@link GetGatewayResponsesCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetGatewayResponsesCommand extends $Command<GetGatewayResponsesCommandInput, GetGatewayResponsesCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetGatewayResponsesCommandInput;
     constructor(input: GetGatewayResponsesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGatewayResponsesCommandInput, GetGatewayResponsesCommandOutput>;
     private serialize;
     private deserialize;