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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
+import { GetSdkTypeRequest, SdkType } from "../models/models_0";
+export interface GetSdkTypeCommandInput extends GetSdkTypeRequest {
+}
+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/commands/GetSdkTypesCommand.d.ts

@@ -0,0 +1,18 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { APIGatewayClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../APIGatewayClient";
+import { GetSdkTypesRequest, SdkTypes } from "../models/models_0";
+export interface GetSdkTypesCommandInput extends GetSdkTypesRequest {
+}
+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/commands/GetStageCommand.d.ts

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

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

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

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

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

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

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

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

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