@aws-sdk/client-api-gateway 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/DeleteModelCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteModelRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteModelCommandInput extends DeleteModelRequest {
-}
-export interface DeleteModelCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes a model.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, DeleteModelCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteModelCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteModelCommandInput} for command's `input` shape.
- * @see {@link DeleteModelCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteModelCommand extends $Command<DeleteModelCommandInput, DeleteModelCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteModelCommandInput;
-    constructor(input: DeleteModelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteModelCommandInput, DeleteModelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteRequestValidatorCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteRequestValidatorRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteRequestValidatorCommandInput extends DeleteRequestValidatorRequest {
-}
-export interface DeleteRequestValidatorCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteRequestValidatorCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteRequestValidatorCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteRequestValidatorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRequestValidatorCommandInput} for command's `input` shape.
- * @see {@link DeleteRequestValidatorCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteRequestValidatorCommand extends $Command<DeleteRequestValidatorCommandInput, DeleteRequestValidatorCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteRequestValidatorCommandInput;
-    constructor(input: DeleteRequestValidatorCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRequestValidatorCommandInput, DeleteRequestValidatorCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteResourceRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteResourceCommandInput extends DeleteResourceRequest {
-}
-export interface DeleteResourceCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteResourceCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteResourceCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResourceCommandInput} for command's `input` shape.
- * @see {@link DeleteResourceCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteResourceCommand extends $Command<DeleteResourceCommandInput, DeleteResourceCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteResourceCommandInput;
-    constructor(input: DeleteResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourceCommandInput, DeleteResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteRestApiCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteRestApiRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteRestApiCommandInput extends DeleteRestApiRequest {
-}
-export interface DeleteRestApiCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, DeleteRestApiCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteRestApiCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteRestApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRestApiCommandInput} for command's `input` shape.
- * @see {@link DeleteRestApiCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteRestApiCommand extends $Command<DeleteRestApiCommandInput, DeleteRestApiCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteRestApiCommandInput;
-    constructor(input: DeleteRestApiCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRestApiCommandInput, DeleteRestApiCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteStageCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteStageRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteStageCommandInput extends DeleteStageRequest {
-}
-export interface DeleteStageCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteStageCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteStageCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteStageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteStageCommandInput} for command's `input` shape.
- * @see {@link DeleteStageCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteStageCommand extends $Command<DeleteStageCommandInput, DeleteStageCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteStageCommandInput;
-    constructor(input: DeleteStageCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStageCommandInput, DeleteStageCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteUsagePlanCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteUsagePlanRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteUsagePlanCommandInput extends DeleteUsagePlanRequest {
-}
-export interface DeleteUsagePlanCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteUsagePlanCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteUsagePlanCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteUsagePlanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteUsagePlanCommandInput} for command's `input` shape.
- * @see {@link DeleteUsagePlanCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteUsagePlanCommand extends $Command<DeleteUsagePlanCommandInput, DeleteUsagePlanCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteUsagePlanCommandInput;
-    constructor(input: DeleteUsagePlanCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUsagePlanCommandInput, DeleteUsagePlanCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteUsagePlanKeyCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteUsagePlanKeyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteUsagePlanKeyCommandInput extends DeleteUsagePlanKeyRequest {
-}
-export interface DeleteUsagePlanKeyCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes a usage plan key  and remove the underlying API key from the associated usage plan.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, DeleteUsagePlanKeyCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteUsagePlanKeyCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteUsagePlanKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteUsagePlanKeyCommandInput} for command's `input` shape.
- * @see {@link DeleteUsagePlanKeyCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteUsagePlanKeyCommand extends $Command<DeleteUsagePlanKeyCommandInput, DeleteUsagePlanKeyCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteUsagePlanKeyCommandInput;
-    constructor(input: DeleteUsagePlanKeyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUsagePlanKeyCommandInput, DeleteUsagePlanKeyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteVpcLinkCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { DeleteVpcLinkRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteVpcLinkCommandInput extends DeleteVpcLinkRequest {
-}
-export interface DeleteVpcLinkCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteVpcLinkCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, DeleteVpcLinkCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new DeleteVpcLinkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVpcLinkCommandInput} for command's `input` shape.
- * @see {@link DeleteVpcLinkCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteVpcLinkCommand extends $Command<DeleteVpcLinkCommandInput, DeleteVpcLinkCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: DeleteVpcLinkCommandInput;
-    constructor(input: DeleteVpcLinkCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVpcLinkCommandInput, DeleteVpcLinkCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/FlushStageAuthorizersCacheCommand.d.ts

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { FlushStageAuthorizersCacheRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface FlushStageAuthorizersCacheCommandInput extends FlushStageAuthorizersCacheRequest {
-}
-export interface FlushStageAuthorizersCacheCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Flushes all authorizer cache entries on a stage.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { APIGatewayClient, FlushStageAuthorizersCacheCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
- * // const { APIGatewayClient, FlushStageAuthorizersCacheCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
- * const client = new APIGatewayClient(config);
- * const command = new FlushStageAuthorizersCacheCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link FlushStageAuthorizersCacheCommandInput} for command's `input` shape.
- * @see {@link FlushStageAuthorizersCacheCommandOutput} for command's `response` shape.
- * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class FlushStageAuthorizersCacheCommand extends $Command<FlushStageAuthorizersCacheCommandInput, FlushStageAuthorizersCacheCommandOutput, APIGatewayClientResolvedConfig> {
-    readonly input: FlushStageAuthorizersCacheCommandInput;
-    constructor(input: FlushStageAuthorizersCacheCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<FlushStageAuthorizersCacheCommandInput, FlushStageAuthorizersCacheCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { FlushStageCacheRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { ClientCertificate, GenerateClientCertificateRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GenerateClientCertificateCommandInput extends GenerateClientCertificateRequest {
-}
-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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { Account, GetAccountRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { ApiKey, GetApiKeyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { ApiKeys, GetApiKeysRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { Authorizer, GetAuthorizerRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { Authorizers, GetAuthorizersRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,35 +0,0 @@
-import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
-import { BasePathMapping, GetBasePathMappingRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetBasePathMappingCommandInput extends GetBasePathMappingRequest {
-}
-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;
-}