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

package/dist-types/commands/GetUsagePlansCommand.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 { GetUsagePlansRequest, UsagePlans } from "../models/models_0";
+export interface GetUsagePlansCommandInput extends GetUsagePlansRequest {
+}
+export interface GetUsagePlansCommandOutput extends UsagePlans, __MetadataBearer {
+}
+/**
+ * <p>Gets all the usage plans of the caller's account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, GetUsagePlansCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, GetUsagePlansCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new GetUsagePlansCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUsagePlansCommandInput} for command's `input` shape.
+ * @see {@link GetUsagePlansCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUsagePlansCommand extends $Command<GetUsagePlansCommandInput, GetUsagePlansCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: GetUsagePlansCommandInput;
+    constructor(input: GetUsagePlansCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsagePlansCommandInput, GetUsagePlansCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVpcLinkCommand.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 { GetVpcLinkRequest, VpcLink } from "../models/models_0";
+export interface GetVpcLinkCommandInput extends GetVpcLinkRequest {
+}
+export interface GetVpcLinkCommandOutput extends VpcLink, __MetadataBearer {
+}
+/**
+ * <p>Gets a specified VPC link under the caller's account in a region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, GetVpcLinkCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, GetVpcLinkCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new GetVpcLinkCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVpcLinkCommandInput} for command's `input` shape.
+ * @see {@link GetVpcLinkCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetVpcLinkCommand extends $Command<GetVpcLinkCommandInput, GetVpcLinkCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: GetVpcLinkCommandInput;
+    constructor(input: GetVpcLinkCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcLinkCommandInput, GetVpcLinkCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVpcLinksCommand.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 { GetVpcLinksRequest, VpcLinks } from "../models/models_0";
+export interface GetVpcLinksCommandInput extends GetVpcLinksRequest {
+}
+export interface GetVpcLinksCommandOutput extends VpcLinks, __MetadataBearer {
+}
+/**
+ * <p>Gets the <a>VpcLinks</a> collection under the caller's account in a selected region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, GetVpcLinksCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, GetVpcLinksCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new GetVpcLinksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVpcLinksCommandInput} for command's `input` shape.
+ * @see {@link GetVpcLinksCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetVpcLinksCommand extends $Command<GetVpcLinksCommandInput, GetVpcLinksCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: GetVpcLinksCommandInput;
+    constructor(input: GetVpcLinksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcLinksCommandInput, GetVpcLinksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportApiKeysCommand.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 { ApiKeyIds, ImportApiKeysRequest } from "../models/models_0";
+export interface ImportApiKeysCommandInput extends ImportApiKeysRequest {
+}
+export interface ImportApiKeysCommandOutput extends ApiKeyIds, __MetadataBearer {
+}
+/**
+ * <p>Import API keys from an external source, such as a CSV-formatted file.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, ImportApiKeysCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, ImportApiKeysCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new ImportApiKeysCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportApiKeysCommandInput} for command's `input` shape.
+ * @see {@link ImportApiKeysCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ImportApiKeysCommand extends $Command<ImportApiKeysCommandInput, ImportApiKeysCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: ImportApiKeysCommandInput;
+    constructor(input: ImportApiKeysCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportApiKeysCommandInput, ImportApiKeysCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportDocumentationPartsCommand.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 { DocumentationPartIds, ImportDocumentationPartsRequest } from "../models/models_0";
+export interface ImportDocumentationPartsCommandInput extends ImportDocumentationPartsRequest {
+}
+export interface ImportDocumentationPartsCommandOutput extends DocumentationPartIds, __MetadataBearer {
+}
+export declare class ImportDocumentationPartsCommand extends $Command<ImportDocumentationPartsCommandInput, ImportDocumentationPartsCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: ImportDocumentationPartsCommandInput;
+    constructor(input: ImportDocumentationPartsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportDocumentationPartsCommandInput, ImportDocumentationPartsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportRestApiCommand.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 { ImportRestApiRequest, RestApi } from "../models/models_0";
+export interface ImportRestApiCommandInput extends ImportRestApiRequest {
+}
+export interface ImportRestApiCommandOutput extends RestApi, __MetadataBearer {
+}
+/**
+ * <p>A feature of the API Gateway control service for creating a new API from an external API definition file.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, ImportRestApiCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, ImportRestApiCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new ImportRestApiCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportRestApiCommandInput} for command's `input` shape.
+ * @see {@link ImportRestApiCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ImportRestApiCommand extends $Command<ImportRestApiCommandInput, ImportRestApiCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: ImportRestApiCommandInput;
+    constructor(input: ImportRestApiCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportRestApiCommandInput, ImportRestApiCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutGatewayResponseCommand.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 { GatewayResponse, PutGatewayResponseRequest } from "../models/models_0";
+export interface PutGatewayResponseCommandInput extends PutGatewayResponseRequest {
+}
+export interface PutGatewayResponseCommandOutput extends GatewayResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a customization of a <a>GatewayResponse</a> of a specified response type and status code on the given <a>RestApi</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, PutGatewayResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutGatewayResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutGatewayResponseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutGatewayResponseCommandInput} for command's `input` shape.
+ * @see {@link PutGatewayResponseCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutGatewayResponseCommand extends $Command<PutGatewayResponseCommandInput, PutGatewayResponseCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutGatewayResponseCommandInput;
+    constructor(input: PutGatewayResponseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutGatewayResponseCommandInput, PutGatewayResponseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutIntegrationCommand.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 { Integration, PutIntegrationRequest } from "../models/models_0";
+export interface PutIntegrationCommandInput extends PutIntegrationRequest {
+}
+export interface PutIntegrationCommandOutput extends Integration, __MetadataBearer {
+}
+/**
+ * <p>Sets up a method's integration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutIntegrationCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutIntegrationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutIntegrationCommandInput} for command's `input` shape.
+ * @see {@link PutIntegrationCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutIntegrationCommand extends $Command<PutIntegrationCommandInput, PutIntegrationCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutIntegrationCommandInput;
+    constructor(input: PutIntegrationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIntegrationCommandInput, PutIntegrationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutIntegrationResponseCommand.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 { IntegrationResponse, PutIntegrationResponseRequest } from "../models/models_0";
+export interface PutIntegrationResponseCommandInput extends PutIntegrationResponseRequest {
+}
+export interface PutIntegrationResponseCommandOutput extends IntegrationResponse, __MetadataBearer {
+}
+/**
+ * <p>Represents a put integration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutIntegrationResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutIntegrationResponseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutIntegrationResponseCommandInput} for command's `input` shape.
+ * @see {@link PutIntegrationResponseCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutIntegrationResponseCommand extends $Command<PutIntegrationResponseCommandInput, PutIntegrationResponseCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutIntegrationResponseCommandInput;
+    constructor(input: PutIntegrationResponseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIntegrationResponseCommandInput, PutIntegrationResponseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutMethodCommand.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 { Method, PutMethodRequest } from "../models/models_0";
+export interface PutMethodCommandInput extends PutMethodRequest {
+}
+export interface PutMethodCommandOutput extends Method, __MetadataBearer {
+}
+/**
+ * <p>Add a method to an existing <a>Resource</a> resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutMethodCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutMethodCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutMethodCommandInput} for command's `input` shape.
+ * @see {@link PutMethodCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutMethodCommand extends $Command<PutMethodCommandInput, PutMethodCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutMethodCommandInput;
+    constructor(input: PutMethodCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMethodCommandInput, PutMethodCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutMethodResponseCommand.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 { MethodResponse, PutMethodResponseRequest } from "../models/models_0";
+export interface PutMethodResponseCommandInput extends PutMethodResponseRequest {
+}
+export interface PutMethodResponseCommandOutput extends MethodResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds a <a>MethodResponse</a> to 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, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutMethodResponseCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutMethodResponseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutMethodResponseCommandInput} for command's `input` shape.
+ * @see {@link PutMethodResponseCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutMethodResponseCommand extends $Command<PutMethodResponseCommandInput, PutMethodResponseCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutMethodResponseCommandInput;
+    constructor(input: PutMethodResponseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMethodResponseCommandInput, PutMethodResponseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+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 { PutRestApiRequest, RestApi } from "../models/models_0";
+export interface PutRestApiCommandInput extends PutRestApiRequest {
+}
+export interface PutRestApiCommandOutput extends RestApi, __MetadataBearer {
+}
+/**
+ * <p>A feature of the API Gateway control service for updating an existing API with an input of external API definitions.
+ *             The update can take the form of merging the supplied definition into the existing API or overwriting the existing API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, PutRestApiCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, PutRestApiCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new PutRestApiCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutRestApiCommandInput} for command's `input` shape.
+ * @see {@link PutRestApiCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutRestApiCommand extends $Command<PutRestApiCommandInput, PutRestApiCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: PutRestApiCommandInput;
+    constructor(input: PutRestApiCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRestApiCommandInput, PutRestApiCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.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 { TagResourceRequest } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Adds or updates a tag on a given resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, TagResourceCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, TagResourceCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+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 { TestInvokeAuthorizerRequest, TestInvokeAuthorizerResponse } from "../models/models_0";
+export interface TestInvokeAuthorizerCommandInput extends TestInvokeAuthorizerRequest {
+}
+export interface TestInvokeAuthorizerCommandOutput extends TestInvokeAuthorizerResponse, __MetadataBearer {
+}
+/**
+ * <p>Simulate the execution of an <a>Authorizer</a> in your <a>RestApi</a> with headers, parameters, and an incoming request body.</p>
+ *       <div class="seeAlso">
+ *         <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html">Use Lambda Function as Authorizer</a>
+ *         <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html">Use Cognito User Pool as Authorizer</a>
+ *       </div>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, TestInvokeAuthorizerCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, TestInvokeAuthorizerCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new TestInvokeAuthorizerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TestInvokeAuthorizerCommandInput} for command's `input` shape.
+ * @see {@link TestInvokeAuthorizerCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TestInvokeAuthorizerCommand extends $Command<TestInvokeAuthorizerCommandInput, TestInvokeAuthorizerCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: TestInvokeAuthorizerCommandInput;
+    constructor(input: TestInvokeAuthorizerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestInvokeAuthorizerCommandInput, TestInvokeAuthorizerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TestInvokeMethodCommand.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 { TestInvokeMethodRequest, TestInvokeMethodResponse } from "../models/models_0";
+export interface TestInvokeMethodCommandInput extends TestInvokeMethodRequest {
+}
+export interface TestInvokeMethodCommandOutput extends TestInvokeMethodResponse, __MetadataBearer {
+}
+/**
+ * <p>Simulate the execution of a <a>Method</a> in your <a>RestApi</a> with headers, parameters, and an incoming request body.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, TestInvokeMethodCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new TestInvokeMethodCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TestInvokeMethodCommandInput} for command's `input` shape.
+ * @see {@link TestInvokeMethodCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TestInvokeMethodCommand extends $Command<TestInvokeMethodCommandInput, TestInvokeMethodCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: TestInvokeMethodCommandInput;
+    constructor(input: TestInvokeMethodCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestInvokeMethodCommandInput, TestInvokeMethodCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.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 { UntagResourceRequest } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Removes a tag from a given resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, UntagResourceCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, UntagResourceCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/UpdateApiKeyCommand.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 { ApiKey, UpdateApiKeyRequest } from "../models/models_0";
+export interface UpdateApiKeyCommandInput extends UpdateApiKeyRequest {
+}
+export interface UpdateApiKeyCommandOutput extends ApiKey, __MetadataBearer {
+}
+/**
+ * <p>Changes information about an <a>ApiKey</a> resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { APIGatewayClient, UpdateApiKeyCommand } from "@aws-sdk/client-api-gateway"; // ES Modules import
+ * // const { APIGatewayClient, UpdateApiKeyCommand } = require("@aws-sdk/client-api-gateway"); // CommonJS import
+ * const client = new APIGatewayClient(config);
+ * const command = new UpdateApiKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateApiKeyCommandInput} for command's `input` shape.
+ * @see {@link UpdateApiKeyCommandOutput} for command's `response` shape.
+ * @see {@link APIGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateApiKeyCommand extends $Command<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput, APIGatewayClientResolvedConfig> {
+    readonly input: UpdateApiKeyCommandInput;
+    constructor(input: UpdateApiKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: APIGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}