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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetModelTemplateCommandInput extends GetModelTemplateRequest {
 }
 export interface GetModelTemplateCommandOutput extends Template, __MetadataBearer {
 }
-/**
- * <p>Generates a sample mapping template that can be used to transform a payload into the structure of a model.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, GetModelTemplateCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, GetModelTemplateCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new GetModelTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetModelTemplateCommandInput} for command's `input` shape.
- * @see {@link GetModelTemplateCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetModelTemplateCommand extends $Command<GetModelTemplateCommandInput, GetModelTemplateCommandOutput, APIGatewayClientResolvedConfig> {
     readonly input: GetModelTemplateCommandInput;
     constructor(input: GetModelTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetModelTemplateCommandInput, GetModelTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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