@aws-sdk/client-apigatewayv2 3.34.0 → 3.35.0

package/dist-types/ts3.4/commands/GetRouteCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetRouteRequest, GetRouteResult } from "../models/models_0";
+export interface GetRouteCommandInput extends GetRouteRequest {
+}
+export interface GetRouteCommandOutput extends GetRouteResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a Route.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetRouteCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetRouteCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new GetRouteCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRouteCommandInput} for command's `input` shape.
+ * @see {@link GetRouteCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRouteCommand extends $Command<GetRouteCommandInput, GetRouteCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetRouteCommandInput;
+    constructor(input: GetRouteCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRouteCommandInput, GetRouteCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetRouteResponseCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetRouteResponseRequest, GetRouteResponseResponse } from "../models/models_0";
+export interface GetRouteResponseCommandInput extends GetRouteResponseRequest {
+}
+export interface GetRouteResponseCommandOutput extends GetRouteResponseResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a RouteResponse.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetRouteResponseCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetRouteResponseCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new GetRouteResponseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRouteResponseCommandInput} for command's `input` shape.
+ * @see {@link GetRouteResponseCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRouteResponseCommand extends $Command<GetRouteResponseCommandInput, GetRouteResponseCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetRouteResponseCommandInput;
+    constructor(input: GetRouteResponseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRouteResponseCommandInput, GetRouteResponseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetRouteResponsesCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetRouteResponsesRequest, GetRouteResponsesResponse } from "../models/models_0";
+export interface GetRouteResponsesCommandInput extends GetRouteResponsesRequest {
+}
+export interface GetRouteResponsesCommandOutput extends GetRouteResponsesResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the RouteResponses for a Route.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetRouteResponsesCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetRouteResponsesCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new GetRouteResponsesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRouteResponsesCommandInput} for command's `input` shape.
+ * @see {@link GetRouteResponsesCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRouteResponsesCommand extends $Command<GetRouteResponsesCommandInput, GetRouteResponsesCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetRouteResponsesCommandInput;
+    constructor(input: GetRouteResponsesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRouteResponsesCommandInput, GetRouteResponsesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetRoutesCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetRoutesRequest, GetRoutesResponse } from "../models/models_0";
+export interface GetRoutesCommandInput extends GetRoutesRequest {
+}
+export interface GetRoutesCommandOutput extends GetRoutesResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the Routes for an API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetRoutesCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetRoutesCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new GetRoutesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRoutesCommandInput} for command's `input` shape.
+ * @see {@link GetRoutesCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRoutesCommand extends $Command<GetRoutesCommandInput, GetRoutesCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetRoutesCommandInput;
+    constructor(input: GetRoutesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRoutesCommandInput, GetRoutesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetStageRequest, GetStageResponse } from "../models/models_0";
+export interface GetStageCommandInput extends GetStageRequest {
+}
+export interface GetStageCommandOutput extends GetStageResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a Stage.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetStageCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetStageCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(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 ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetStageCommand extends $Command<GetStageCommandInput, GetStageCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetStageCommandInput;
+    constructor(input: GetStageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStageCommandInput, GetStageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetStagesRequest, GetStagesResponse } from "../models/models_0";
+export interface GetStagesCommandInput extends GetStagesRequest {
+}
+export interface GetStagesCommandOutput extends GetStagesResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the Stages for an API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetStagesCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetStagesCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(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 ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetStagesCommand extends $Command<GetStagesCommandInput, GetStagesCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetStagesCommandInput;
+    constructor(input: GetStagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStagesCommandInput, GetStagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetTagsRequest, GetTagsResponse } from "../models/models_0";
+export interface GetTagsCommandInput extends GetTagsRequest {
+}
+export interface GetTagsCommandOutput extends GetTagsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a collection of Tag resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetTagsCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetTagsCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(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 ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTagsCommand extends $Command<GetTagsCommandInput, GetTagsCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetTagsCommandInput;
+    constructor(input: GetTagsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTagsCommandInput, GetTagsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/ts3.4/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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { GetVpcLinksRequest, GetVpcLinksResponse } from "../models/models_0";
+export interface GetVpcLinksCommandInput extends GetVpcLinksRequest {
+}
+export interface GetVpcLinksCommandOutput extends GetVpcLinksResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a collection of VPC links.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, GetVpcLinksCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, GetVpcLinksCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(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 ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetVpcLinksCommand extends $Command<GetVpcLinksCommandInput, GetVpcLinksCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: GetVpcLinksCommandInput;
+    constructor(input: GetVpcLinksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpcLinksCommandInput, GetVpcLinksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/ResetAuthorizersCacheCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { ResetAuthorizersCacheRequest } from "../models/models_0";
+export interface ResetAuthorizersCacheCommandInput extends ResetAuthorizersCacheRequest {
+}
+export interface ResetAuthorizersCacheCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Resets all authorizer cache entries on a stage. Supported only for HTTP APIs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, ResetAuthorizersCacheCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, ResetAuthorizersCacheCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new ResetAuthorizersCacheCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetAuthorizersCacheCommandInput} for command's `input` shape.
+ * @see {@link ResetAuthorizersCacheCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetAuthorizersCacheCommand extends $Command<ResetAuthorizersCacheCommandInput, ResetAuthorizersCacheCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: ResetAuthorizersCacheCommandInput;
+    constructor(input: ResetAuthorizersCacheCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetAuthorizersCacheCommandInput, ResetAuthorizersCacheCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a new Tag resource to represent a tag.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, TagResourceCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, TagResourceCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(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 ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/UpdateApiMappingCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { UpdateApiMappingRequest, UpdateApiMappingResponse } from "../models/models_0";
+export interface UpdateApiMappingCommandInput extends UpdateApiMappingRequest {
+}
+export interface UpdateApiMappingCommandOutput extends UpdateApiMappingResponse, __MetadataBearer {
+}
+/**
+ * <p>The API mapping.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, UpdateApiMappingCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, UpdateApiMappingCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new UpdateApiMappingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateApiMappingCommandInput} for command's `input` shape.
+ * @see {@link UpdateApiMappingCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateApiMappingCommand extends $Command<UpdateApiMappingCommandInput, UpdateApiMappingCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: UpdateApiMappingCommandInput;
+    constructor(input: UpdateApiMappingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiMappingCommandInput, UpdateApiMappingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateAuthorizerCommand.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 { ApiGatewayV2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ApiGatewayV2Client";
+import { UpdateAuthorizerRequest, UpdateAuthorizerResponse } from "../models/models_0";
+export interface UpdateAuthorizerCommandInput extends UpdateAuthorizerRequest {
+}
+export interface UpdateAuthorizerCommandOutput extends UpdateAuthorizerResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates an Authorizer.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ApiGatewayV2Client, UpdateAuthorizerCommand } from "@aws-sdk/client-apigatewayv2"; // ES Modules import
+ * // const { ApiGatewayV2Client, UpdateAuthorizerCommand } = require("@aws-sdk/client-apigatewayv2"); // CommonJS import
+ * const client = new ApiGatewayV2Client(config);
+ * const command = new UpdateAuthorizerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateAuthorizerCommandInput} for command's `input` shape.
+ * @see {@link UpdateAuthorizerCommandOutput} for command's `response` shape.
+ * @see {@link ApiGatewayV2ClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateAuthorizerCommand extends $Command<UpdateAuthorizerCommandInput, UpdateAuthorizerCommandOutput, ApiGatewayV2ClientResolvedConfig> {
+    readonly input: UpdateAuthorizerCommandInput;
+    constructor(input: UpdateAuthorizerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ApiGatewayV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAuthorizerCommandInput, UpdateAuthorizerCommandOutput>;
+    private serialize;
+    private deserialize;
+}