agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/api-key.d.ts

@@ -0,0 +1,156 @@
+import type { Construct } from 'constructs';
+import type { IResource as IResourceBase } from '../../../core';
+import { Resource } from '../../../core';
+import type { ThrottleSettings } from '../common';
+import type { QuotaSettings, UsagePlanPerApiStage } from './usage-plan';
+import type { ApiKeyReference, IApiKeyRef } from '../../../aws-apigateway/lib';
+import * as iam from '../../../aws-iam';
+/**
+ * API keys are alphanumeric string values that you distribute to
+ * app developer customers to grant access to your API
+ *
+ * API Keys are an API Gateway V1 concept.
+ */
+export interface IApiKey extends IResourceBase, IApiKeyRef {
+    /**
+     * The API key ID.
+     * @attribute
+     */
+    readonly keyId: string;
+    /**
+     * The API key ARN.
+     * @attribute
+     */
+    readonly keyArn: string;
+}
+/**
+ * The options for creating an API Key.
+ */
+export interface ApiKeyOptions {
+    /**
+     * A name for the API key. If you don't specify a name, AWS CloudFormation generates a unique physical ID and uses that ID for the API key name.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-name
+     * @default automatically generated name
+     */
+    readonly apiKeyName?: string;
+    /**
+     * The value of the API key. Must be at least 20 characters long.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-value
+     * @default none
+     */
+    readonly value?: string;
+    /**
+     * A description of the purpose of the API key.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-description
+     * @default none
+     */
+    readonly description?: string;
+}
+/**
+ * ApiKey Properties.
+ */
+export interface ApiKeyProps extends ApiKeyOptions {
+    /**
+     * An AWS Marketplace customer identifier to use when integrating with the AWS SaaS Marketplace.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-customerid
+     * @default none
+     */
+    readonly customerId?: string;
+    /**
+     * Indicates whether the API key can be used by clients.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-enabled
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Specifies whether the key identifier is distinct from the created API key value.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-generatedistinctid
+     * @default false
+     */
+    readonly generateDistinctId?: boolean;
+}
+/**
+ * Base implementation that is common to the various implementations of IApiKey
+ */
+declare abstract class ApiKeyBase extends Resource implements IApiKey {
+    abstract readonly keyId: string;
+    abstract readonly keyArn: string;
+    /**
+     * Permits the IAM principal all read operations through this key
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Permits the IAM principal all write operations through this key
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Permits the IAM principal all read and write operations through this key
+     * [disable-awslint:no-grants]
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantReadWrite(grantee: iam.IGrantable): iam.Grant;
+    get apiKeyRef(): ApiKeyReference;
+}
+/**
+ * An API Gateway ApiKey.
+ *
+ * An ApiKey can be distributed to API clients that are connecting to
+ * WebSocket APIs that require API key authentication. The key is used
+ * to authenticate WebSocket connections and associate them with usage plans
+ * for throttling and quota management.
+ * @resource AWS::ApiGateway::ApiKey
+ */
+export declare class ApiKey extends ApiKeyBase {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an ApiKey by its Id
+     */
+    static fromApiKeyId(scope: Construct, id: string, apiKeyId: string): IApiKey;
+    readonly keyId: string;
+    readonly keyArn: string;
+    constructor(scope: Construct, id: string, props?: ApiKeyProps);
+}
+/**
+ * RateLimitedApiKey properties.
+ */
+export interface RateLimitedApiKeyProps extends ApiKeyProps {
+    /**
+     * API Stages to be associated with the RateLimitedApiKey.
+     *
+     * @default none
+     */
+    readonly apiStages?: UsagePlanPerApiStage[];
+    /**
+     * Number of requests clients can make in a given time period.
+     * @default none
+     */
+    readonly quota?: QuotaSettings;
+    /**
+     * Overall throttle settings for the API.
+     * @default none
+     */
+    readonly throttle?: ThrottleSettings;
+}
+/**
+ * An API Gateway ApiKey, for which a rate limiting configuration can be specified.
+ *
+ * @resource AWS::ApiGateway::ApiKey
+ */
+export declare class RateLimitedApiKey extends ApiKeyBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly keyId: string;
+    readonly keyArn: string;
+    constructor(scope: Construct, id: string, props?: RateLimitedApiKeyProps);
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/api.d.ts

@@ -0,0 +1,164 @@
+import type { Construct } from 'constructs';
+import type { WebSocketRouteOptions } from './route';
+import { WebSocketRoute } from './route';
+import type { IGrantable } from '../../../aws-iam';
+import { Grant } from '../../../aws-iam';
+import type { ApiReference, IApiRef } from '../apigatewayv2.generated';
+import type { IApi, IpAddressType } from '../common/api';
+import { ApiBase } from '../common/base';
+/**
+ * Represents a reference to an HTTP API
+ */
+export interface IWebSocketApiRef extends IApiRef {
+    /**
+     * Indicates that this is a WebSocket API
+     *
+     * Will always return true, but is necessary to prevent accidental structural
+     * equality in TypeScript.
+     */
+    readonly isWebsocketApi: boolean;
+}
+/**
+ * Represents a WebSocket API
+ */
+export interface IWebSocketApi extends IApi, IWebSocketApiRef {
+}
+/**
+ * Represents the currently available API Key Selection Expressions
+ */
+export declare class WebSocketApiKeySelectionExpression {
+    readonly customApiKeySelector: string;
+    /**
+     * The API will extract the key value from the `x-api-key` header in the user request.
+     */
+    static readonly HEADER_X_API_KEY: WebSocketApiKeySelectionExpression;
+    /**
+     * The API will extract the key value from the `usageIdentifierKey` attribute in the `context` map,
+     * returned by the Lambda Authorizer.
+     * See https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html
+     */
+    static readonly AUTHORIZER_USAGE_IDENTIFIER_KEY: WebSocketApiKeySelectionExpression;
+    /**
+     * @param customApiKeySelector The expression used by API Gateway
+     */
+    constructor(customApiKeySelector: string);
+}
+/**
+ * Props for WebSocket API
+ */
+export interface WebSocketApiProps {
+    /**
+     * Name for the WebSocket API resource
+     * @default - id of the WebSocketApi construct.
+     */
+    readonly apiName?: string;
+    /**
+     * An API key selection expression. Providing this option will require an API Key be provided to access the API.
+     * @default - Key is not required to access these APIs
+     */
+    readonly apiKeySelectionExpression?: WebSocketApiKeySelectionExpression;
+    /**
+     * The description of the API.
+     * @default - none
+     */
+    readonly description?: string;
+    /**
+     * The route selection expression for the API
+     * @default '$request.body.action'
+     */
+    readonly routeSelectionExpression?: string;
+    /**
+     * Options to configure a '$connect' route
+     *
+     * @default - no '$connect' route configured
+     */
+    readonly connectRouteOptions?: WebSocketRouteOptions;
+    /**
+     * Options to configure a '$disconnect' route
+     *
+     * @default - no '$disconnect' route configured
+     */
+    readonly disconnectRouteOptions?: WebSocketRouteOptions;
+    /**
+     * Options to configure a '$default' route
+     *
+     * @default - no '$default' route configured
+     */
+    readonly defaultRouteOptions?: WebSocketRouteOptions;
+    /**
+     * The IP address types that can invoke the API.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-ip-address-type.html
+     *
+     * @default undefined - AWS default is IPV4
+     */
+    readonly ipAddressType?: IpAddressType;
+    /**
+     * Avoid validating models when creating a deployment.
+     *
+     * @default false
+     */
+    readonly disableSchemaValidation?: boolean;
+}
+/**
+ * Attributes for importing a WebSocketApi into the CDK
+ */
+export interface WebSocketApiAttributes {
+    /**
+     * The identifier of the WebSocketApi
+     */
+    readonly webSocketId: string;
+    /**
+     * The endpoint URL of the WebSocketApi
+     * @default - throw san error if apiEndpoint is accessed.
+     */
+    readonly apiEndpoint?: string;
+}
+/**
+ * Create a new API Gateway WebSocket API endpoint.
+ * @resource AWS::ApiGatewayV2::Api
+ */
+export declare class WebSocketApi extends ApiBase implements IWebSocketApi {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing WebSocket API into this CDK app.
+     */
+    static fromWebSocketApiAttributes(scope: Construct, id: string, attrs: WebSocketApiAttributes): IWebSocketApi;
+    readonly isWebsocketApi = true;
+    readonly apiId: string;
+    readonly apiEndpoint: string;
+    /**
+     * A human friendly name for this WebSocket API. Note that this is different from `webSocketApiId`.
+     */
+    readonly webSocketApiName?: string;
+    constructor(scope: Construct, id: string, props?: WebSocketApiProps);
+    /**
+     * Add a new route
+     */
+    addRoute(routeKey: string, options: WebSocketRouteOptions): WebSocketRoute;
+    /**
+     * Grant access to the API Gateway management API for this WebSocket API to an IAM
+     * principal (Role/Group/User).
+     * [disable-awslint:no-grants]
+     *
+     * @param identity The principal
+     */
+    grantManageConnections(identity: IGrantable): Grant;
+    /**
+     * Get the "execute-api" ARN.
+     *
+     * @deprecated Use `arnForExecuteApiV2()` instead.
+     */
+    arnForExecuteApi(method?: string, path?: string, stage?: string): string;
+    /**
+     * Get the "execute-api" ARN.
+     *
+     * @default - The default behavior applies when no specific route, or stage is provided.
+     * In this case, the ARN will cover all routes, and all stages of this API.
+     * Specifically, if 'route' is not specified, it defaults to '*', representing all routes.
+     * If 'stage' is not specified, it also defaults to '*', representing all stages.
+     */
+    arnForExecuteApiV2(route?: string, stage?: string): string;
+    get apiRef(): ApiReference;
+}

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/authorizer.d.ts

@@ -0,0 +1,133 @@
+import type { Construct } from 'constructs';
+import type { IWebSocketApi } from './api';
+import type { IWebSocketRoute } from './route';
+import { Resource } from '../../../core';
+import type { IAuthorizer } from '../common';
+import type { AuthorizerReference } from '../index';
+/**
+ * Supported Authorizer types
+ */
+export declare enum WebSocketAuthorizerType {
+    /** Lambda Authorizer */
+    LAMBDA = "REQUEST",
+    /** IAM Authorizer */
+    IAM = "AWS_IAM"
+}
+/**
+ * Properties to initialize an instance of `WebSocketAuthorizer`.
+ */
+export interface WebSocketAuthorizerProps {
+    /**
+     * Name of the authorizer
+     * @default - id of the WebSocketAuthorizer construct.
+     */
+    readonly authorizerName?: string;
+    /**
+     * WebSocket Api to attach the authorizer to
+     */
+    readonly webSocketApi: IWebSocketApi;
+    /**
+     * The type of authorizer
+     */
+    readonly type: WebSocketAuthorizerType;
+    /**
+     * The identity source for which authorization is requested.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigatewayv2-authorizer.html#cfn-apigatewayv2-authorizer-identitysource
+     */
+    readonly identitySource: string[];
+    /**
+     * The authorizer's Uniform Resource Identifier (URI).
+     *
+     * For REQUEST authorizers, this must be a well-formed Lambda function URI.
+     *
+     * @default - required for Request authorizer types
+     */
+    readonly authorizerUri?: string;
+}
+/**
+ * An authorizer for WebSocket APIs
+ */
+export interface IWebSocketAuthorizer extends IAuthorizer {
+}
+/**
+ * Reference to an WebSocket authorizer
+ */
+export interface WebSocketAuthorizerAttributes {
+    /**
+     * Id of the Authorizer
+     */
+    readonly authorizerId: string;
+    /**
+     * Type of authorizer
+     *
+     * Possible values are:
+     * - CUSTOM - Lambda Authorizer
+     * - NONE - No Authorization
+     */
+    readonly authorizerType: string;
+}
+/**
+ * An authorizer for WebSocket Apis
+ * @resource AWS::ApiGatewayV2::Authorizer
+ */
+export declare class WebSocketAuthorizer extends Resource implements IWebSocketAuthorizer {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing WebSocket Authorizer into this CDK app.
+     */
+    static fromWebSocketAuthorizerAttributes(scope: Construct, id: string, attrs: WebSocketAuthorizerAttributes): IWebSocketRouteAuthorizer;
+    readonly authorizerId: string;
+    private readonly apiId;
+    constructor(scope: Construct, id: string, props: WebSocketAuthorizerProps);
+    get authorizerRef(): AuthorizerReference;
+}
+/**
+ * Input to the bind() operation, that binds an authorizer to a route.
+ */
+export interface WebSocketRouteAuthorizerBindOptions {
+    /**
+     * The route to which the authorizer is being bound.
+     */
+    readonly route: IWebSocketRoute;
+    /**
+     * The scope for any constructs created as part of the bind.
+     */
+    readonly scope: Construct;
+}
+/**
+ * Results of binding an authorizer to an WebSocket route.
+ */
+export interface WebSocketRouteAuthorizerConfig {
+    /**
+     * The authorizer id
+     *
+     * @default - No authorizer id (useful for AWS_IAM route authorizer)
+     */
+    readonly authorizerId?: string;
+    /**
+     * The type of authorization
+     *
+     * Possible values are:
+     * - CUSTOM - Lambda Authorizer
+     * - NONE - No Authorization
+     */
+    readonly authorizationType: string;
+}
+/**
+ * An authorizer that can attach to an WebSocket Route.
+ */
+export interface IWebSocketRouteAuthorizer {
+    /**
+     * Bind this authorizer to a specified WebSocket route.
+     */
+    bind(options: WebSocketRouteAuthorizerBindOptions): WebSocketRouteAuthorizerConfig;
+}
+/**
+ * Explicitly configure no authorizers on specific WebSocket API routes.
+ */
+export declare class WebSocketNoneAuthorizer implements IWebSocketRouteAuthorizer {
+    bind(_options: WebSocketRouteAuthorizerBindOptions): WebSocketRouteAuthorizerConfig;
+}

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/index.d.ts

@@ -0,0 +1,7 @@
+export * from './api';
+export * from './route';
+export * from './stage';
+export * from './integration';
+export * from './authorizer';
+export * from './usage-plan';
+export * from './api-key';

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/integration.d.ts

@@ -0,0 +1,266 @@
+import type { Construct } from 'constructs';
+import type { IWebSocketApi, IWebSocketApiRef } from './api';
+import type { IWebSocketRoute } from './route';
+import type { IntegrationReference } from '.././index';
+import type { IRole } from '../../../aws-iam';
+import type { Duration } from '../../../core';
+import { Resource } from '../../../core';
+import type { IIntegration } from '../common';
+/**
+ * Represents an Integration for an WebSocket API.
+ */
+export interface IWebSocketIntegration extends IIntegration {
+    /** The WebSocket API associated with this integration */
+    readonly webSocketApi: IWebSocketApi;
+}
+/**
+ * WebSocket Integration Types
+ */
+export declare enum WebSocketIntegrationType {
+    /**
+     * AWS Proxy Integration Type
+     */
+    AWS_PROXY = "AWS_PROXY",
+    /**
+     * Mock Integration Type
+     */
+    MOCK = "MOCK",
+    /**
+     * AWS Integration Type
+     */
+    AWS = "AWS"
+}
+/**
+ * Integration content handling
+ */
+export declare enum ContentHandling {
+    /**
+     * Converts a request payload from a base64-encoded string to a binary blob.
+     */
+    CONVERT_TO_BINARY = "CONVERT_TO_BINARY",
+    /**
+     * Converts a request payload from a binary blob to a base64-encoded string.
+     */
+    CONVERT_TO_TEXT = "CONVERT_TO_TEXT"
+}
+/**
+ * Integration Passthrough Behavior
+ */
+export declare enum PassthroughBehavior {
+    /**
+     * Passes the request body for unmapped content types through to the
+     * integration back end without transformation.
+     */
+    WHEN_NO_MATCH = "WHEN_NO_MATCH",
+    /**
+     * Rejects unmapped content types with an HTTP 415 'Unsupported Media Type'
+     * response
+     */
+    NEVER = "NEVER",
+    /**
+     * Allows pass-through when the integration has NO content types mapped to
+     * templates. However if there is at least one content type defined,
+     * unmapped content types will be rejected with the same 415 response.
+     */
+    WHEN_NO_TEMPLATES = "WHEN_NO_TEMPLATES"
+}
+/**
+ * The integration properties
+ */
+export interface WebSocketIntegrationProps {
+    /**
+     * The WebSocket API to which this integration should be bound.
+     */
+    readonly webSocketApi: IWebSocketApiRef;
+    /**
+     * Integration type
+     */
+    readonly integrationType: WebSocketIntegrationType;
+    /**
+     * Integration URI.
+     */
+    readonly integrationUri: string;
+    /**
+     * Specifies the integration's HTTP method type.
+     *
+     * @default - No HTTP method required.
+     */
+    readonly integrationMethod?: string;
+    /**
+     * Specifies how to handle response payload content type conversions.
+     *
+     * @default - The response payload will be passed through from the integration response to
+     * the route response or method response without modification.
+     */
+    readonly contentHandling?: ContentHandling;
+    /**
+     * Specifies the IAM role required for the integration.
+     *
+     * @default - No IAM role required.
+     */
+    readonly credentialsRole?: IRole;
+    /**
+     * The request parameters that API Gateway sends with the backend request.
+     * Specify request parameters as key-value pairs (string-to-string
+     * mappings), with a destination as the key and a source as the value.
+     *
+     * @default - No request parameters required.
+     */
+    readonly requestParameters?: {
+        [dest: string]: string;
+    };
+    /**
+     * A map of Apache Velocity templates that are applied on the request
+     * payload.
+     *
+     * ```
+     *   { "application/json": "{ \"statusCode\": 200 }" }
+     * ```
+     *
+     * @default - No request templates required.
+     */
+    readonly requestTemplates?: {
+        [contentType: string]: string;
+    };
+    /**
+     * The template selection expression for the integration.
+     *
+     * @default - No template selection expression required.
+     */
+    readonly templateSelectionExpression?: string;
+    /**
+     * The maximum amount of time an integration will run before it returns without a response.
+     * Must be between 50 milliseconds and 29 seconds.
+     *
+     * @default Duration.seconds(29)
+     */
+    readonly timeout?: Duration;
+    /**
+     * Specifies the pass-through behavior for incoming requests based on the
+     * Content-Type header in the request, and the available mapping templates
+     * specified as the requestTemplates property on the Integration resource.
+     * There are three valid values: WHEN_NO_MATCH, WHEN_NO_TEMPLATES, and
+     * NEVER.
+     *
+     * @default - No passthrough behavior required.
+     */
+    readonly passthroughBehavior?: PassthroughBehavior;
+}
+/**
+ * The integration for an API route.
+ * @resource AWS::ApiGatewayV2::Integration
+ */
+export declare class WebSocketIntegration extends Resource implements IWebSocketIntegration {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly integrationId: string;
+    private readonly _webSocketApi;
+    constructor(scope: Construct, id: string, props: WebSocketIntegrationProps);
+    get webSocketApi(): IWebSocketApi;
+    get integrationRef(): IntegrationReference;
+}
+/**
+ * Options to the WebSocketRouteIntegration during its bind operation.
+ */
+export interface WebSocketRouteIntegrationBindOptions {
+    /**
+     * The route to which this is being bound.
+     */
+    readonly route: IWebSocketRoute;
+    /**
+     * The current scope in which the bind is occurring.
+     * If the `WebSocketRouteIntegration` being bound creates additional constructs,
+     * this will be used as their parent scope.
+     */
+    readonly scope: Construct;
+}
+/**
+ * The interface that various route integration classes will inherit.
+ */
+export declare abstract class WebSocketRouteIntegration {
+    private readonly id;
+    private integration?;
+    /**
+     * Initialize an integration for a route on websocket api.
+     * @param id id of the underlying `WebSocketIntegration` construct.
+     */
+    constructor(id: string);
+    /**
+     * Internal method called when binding this integration to the route.
+     * @internal
+     */
+    _bindToRoute(options: WebSocketRouteIntegrationBindOptions): {
+        readonly integrationId: string;
+    };
+    /**
+     * Bind this integration to the route.
+     */
+    abstract bind(options: WebSocketRouteIntegrationBindOptions): WebSocketRouteIntegrationConfig;
+}
+/**
+ * Config returned back as a result of the bind.
+ */
+export interface WebSocketRouteIntegrationConfig {
+    /**
+     * Integration type.
+     */
+    readonly type: WebSocketIntegrationType;
+    /**
+     * Integration URI
+     */
+    readonly uri: string;
+    /**
+     * Integration method
+     *
+     * @default - No integration method.
+     */
+    readonly method?: string;
+    /**
+     * Specifies how to handle response payload content type conversions.
+     *
+     * @default - The response payload will be passed through from the integration response to
+     * the route response or method response without modification.
+     */
+    readonly contentHandling?: ContentHandling;
+    /**
+     * Credentials role
+     *
+     * @default - No role provided.
+     */
+    readonly credentialsRole?: IRole;
+    /**
+     * Request template
+     *
+     * @default - No request template provided.
+     */
+    readonly requestTemplates?: {
+        [contentType: string]: string;
+    };
+    /**
+     * Request parameters
+     *
+     * @default - No request parameters provided.
+     */
+    readonly requestParameters?: {
+        [dest: string]: string;
+    };
+    /**
+     * Template selection expression
+     *
+     * @default - No template selection expression.
+     */
+    readonly templateSelectionExpression?: string;
+    /**
+     * The maximum amount of time an integration will run before it returns without a response.
+     * Must be between 50 milliseconds and 29 seconds.
+     *
+     * @default Duration.seconds(29)
+     */
+    readonly timeout?: Duration;
+    /**
+     * Integration passthrough behaviors.
+     *
+     * @default - No pass through bahavior.
+     */
+    readonly passthroughBehavior?: PassthroughBehavior;
+}

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/route.d.ts

@@ -0,0 +1,78 @@
+import { Construct } from 'constructs';
+import type { IWebSocketApi } from './api';
+import type { IWebSocketRouteAuthorizer } from './authorizer';
+import type { WebSocketRouteIntegration } from './integration';
+import type { RouteReference } from '.././index';
+import { Resource } from '../../../core';
+import type { IRoute } from '../common';
+/**
+ * Represents a Route for an WebSocket API.
+ */
+export interface IWebSocketRoute extends IRoute {
+    /**
+     * The WebSocket API associated with this route.
+     */
+    readonly webSocketApi: IWebSocketApi;
+    /**
+     * The key to this route.
+     * @attribute
+     */
+    readonly routeKey: string;
+}
+/**
+ * Options used to add route to the API
+ */
+export interface WebSocketRouteOptions {
+    /**
+     * The integration to be configured on this route.
+     */
+    readonly integration: WebSocketRouteIntegration;
+    /**
+     * The authorize to this route. You can only set authorizer to a $connect route.
+     *
+     * @default - No Authorizer
+     */
+    readonly authorizer?: IWebSocketRouteAuthorizer;
+    /**
+     * Should the route send a response to the client
+     * @default false
+     */
+    readonly returnResponse?: boolean;
+}
+/**
+ * Properties to initialize a new Route
+ */
+export interface WebSocketRouteProps extends WebSocketRouteOptions {
+    /**
+     * The API the route is associated with.
+     */
+    readonly webSocketApi: IWebSocketApi;
+    /**
+     * The key to this route.
+     */
+    readonly routeKey: string;
+    /**
+     * Whether the route requires an API Key to be provided
+     * @default false
+     */
+    readonly apiKeyRequired?: boolean;
+}
+/**
+ * Route class that creates the Route for API Gateway WebSocket API
+ * @resource AWS::ApiGatewayV2::Route
+ */
+export declare class WebSocketRoute extends Resource implements IWebSocketRoute {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    readonly routeId: string;
+    readonly webSocketApi: IWebSocketApi;
+    readonly routeKey: string;
+    /**
+     * Integration response ID
+     */
+    readonly integrationResponseId?: string;
+    constructor(scope: Construct, id: string, props: WebSocketRouteProps);
+    get routeRef(): RouteReference;
+}

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/stage.d.ts

@@ -0,0 +1,83 @@
+import type { Construct } from 'constructs';
+import type { IWebSocketApi } from './api';
+import { AccessLogFormat } from '../../../aws-apigateway';
+import type { IGrantable } from '../../../aws-iam';
+import { Grant } from '../../../aws-iam';
+import type { StageOptions, IApi, IStage, StageAttributes } from '../common';
+import { StageBase } from '../common/base';
+/**
+ * Represents the WebSocketStage
+ */
+export interface IWebSocketStage extends IStage {
+    /**
+     * The API this stage is associated to.
+     */
+    readonly api: IWebSocketApi;
+    /**
+     * The callback URL to this stage.
+     * You can use the callback URL to send messages to the client from the backend system.
+     * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html
+     * https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-how-to-call-websocket-api-connections.html
+     */
+    readonly callbackUrl: string;
+}
+/**
+ * Properties to initialize an instance of `WebSocketStage`.
+ */
+export interface WebSocketStageProps extends StageOptions {
+    /**
+     * The WebSocket API to which this stage is associated.
+     */
+    readonly webSocketApi: IWebSocketApi;
+    /**
+     * The name of the stage.
+     */
+    readonly stageName: string;
+}
+/**
+ * The attributes used to import existing WebSocketStage
+ */
+export interface WebSocketStageAttributes extends StageAttributes {
+    /**
+     * The API to which this stage is associated
+     */
+    readonly api: IWebSocketApi;
+}
+/**
+ * Represents a stage where an instance of the API is deployed.
+ * @resource AWS::ApiGatewayV2::Stage
+ */
+export declare class WebSocketStage extends StageBase implements IWebSocketStage {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing stage into this CDK app.
+     */
+    static fromWebSocketStageAttributes(scope: Construct, id: string, attrs: WebSocketStageAttributes): IWebSocketStage;
+    protected readonly baseApi: IApi;
+    readonly stageName: string;
+    readonly api: IWebSocketApi;
+    constructor(scope: Construct, id: string, props: WebSocketStageProps);
+    /**
+     * The websocket URL to this stage.
+     */
+    get url(): string;
+    /**
+     * The callback URL to this stage.
+     */
+    get callbackUrl(): string;
+    /**
+     * Grant access to the API Gateway management API for this WebSocket API Stage to an IAM
+     * principal (Role/Group/User).
+     * [disable-awslint:no-grants]
+     *
+     * @param identity The principal
+     */
+    grantManagementApiAccess(identity: IGrantable): Grant;
+    /**
+     * CLF Log format for WebSocket API Stage.
+     *
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-api-logging.html
+     */
+    defaultAccessLogFormat(): AccessLogFormat;
+}

cdk/node_modules/aws-cdk-lib/aws-apigatewayv2/lib/websocket/usage-plan.d.ts

@@ -0,0 +1,164 @@
+import type { Construct } from 'constructs';
+import type { IWebSocketApi } from './api';
+import type { IWebSocketStage } from './stage';
+import type { IApiKeyRef, IUsagePlanRef, UsagePlanReference } from '../../../aws-apigateway/lib';
+import type { IResource } from '../../../core';
+import { Resource } from '../../../core';
+import type { ThrottleSettings } from '../common';
+/**
+ * Time period for which quota settings apply.
+ */
+export declare enum Period {
+    /**
+     * The quota resets every day.
+     */
+    DAY = "DAY",
+    /**
+     * The quota resets every week.
+     */
+    WEEK = "WEEK",
+    /**
+     * The quota resets every month.
+     */
+    MONTH = "MONTH"
+}
+/**
+ * Specifies the maximum number of requests that clients can make to API Gateway APIs.
+ */
+export interface QuotaSettings {
+    /**
+     * The maximum number of requests that users can make within the specified time period.
+     * @default none
+     */
+    readonly limit?: number;
+    /**
+     * For the initial time period, the number of requests to subtract from the specified limit.
+     * @default none
+     */
+    readonly offset?: number;
+    /**
+     * The time period for which the maximum limit of requests applies.
+     * @default none
+     */
+    readonly period?: Period;
+}
+/**
+ * Represents the API stages that a usage plan applies to.
+ */
+export interface UsagePlanPerApiStage {
+    /**
+     * The WebSocket API to associate with the usage plan.
+     * @default none
+     */
+    readonly api?: IWebSocketApi;
+    /**
+     *
+     * [disable-awslint:ref-via-interface]
+     * @default none
+     */
+    readonly stage?: IWebSocketStage;
+}
+/**
+ * Properties for defining an API Gateway Usage Plan for WebSocket APIs.
+ */
+export interface UsagePlanProps {
+    /**
+     * API Stages to be associated with the usage plan.
+     * @default none
+     */
+    readonly apiStages?: UsagePlanPerApiStage[];
+    /**
+     * Represents usage plan purpose.
+     * @default none
+     */
+    readonly description?: string;
+    /**
+     * Number of requests clients can make in a given time period.
+     * @default none
+     */
+    readonly quota?: QuotaSettings;
+    /**
+     * Overall throttle settings for the API.
+     * @default none
+     */
+    readonly throttle?: ThrottleSettings;
+    /**
+     * Name for this usage plan.
+     * @default none
+     */
+    readonly usagePlanName?: string;
+}
+/**
+ * Options to the UsagePlan.addApiKey() method
+ */
+export interface AddApiKeyOptions {
+    /**
+     * Override the CloudFormation logical id of the AWS::ApiGateway::UsagePlanKey resource
+     * @default - autogenerated by the CDK
+     */
+    readonly overrideLogicalId?: string;
+}
+/**
+ * A UsagePlan, either managed by this CDK app, or imported.
+ */
+export interface IUsagePlan extends IResource, IUsagePlanRef {
+    /**
+     * Id of the usage plan
+     * @attribute
+     */
+    readonly usagePlanId: string;
+    /**
+     * Adds an ApiKey.
+     *
+     * @param apiKey the api key to associate with this usage plan
+     * @param options options that control the behaviour of this method
+     */
+    addApiKey(apiKey: IApiKeyRef, options?: AddApiKeyOptions): void;
+}
+declare abstract class UsagePlanBase extends Resource implements IUsagePlan {
+    /**
+     * Id of the usage plan
+     * @attribute
+     */
+    abstract readonly usagePlanId: string;
+    /**
+     * Adds an ApiKey.
+     *
+     * @param apiKey the api key to associate with this usage plan
+     * @param options options that control the behaviour of this method
+     */
+    addApiKey(apiKey: IApiKeyRef, options?: AddApiKeyOptions): void;
+    get usagePlanRef(): UsagePlanReference;
+}
+/**
+ * A UsagePlan.
+ *
+ * @resource AWS::ApiGateway::UsagePlan
+ */
+export declare class UsagePlan extends UsagePlanBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an externally defined usage plan using its ARN.
+     *
+     * @param scope  the construct that will "own" the imported usage plan.
+     * @param id     the id of the imported usage plan in the construct tree.
+     * @param usagePlanId the id of an existing usage plan.
+     */
+    static fromUsagePlanId(scope: Construct, id: string, usagePlanId: string): IUsagePlan;
+    /**
+     * @attribute
+     */
+    readonly usagePlanId: string;
+    private readonly apiStages;
+    constructor(scope: Construct, id: string, props?: UsagePlanProps);
+    /**
+     * Adds an apiStage.
+     */
+    addApiStage(apiStage: UsagePlanPerApiStage): void;
+    private renderApiStages;
+    private createStage;
+    private renderQuota;
+    private renderThrottle;
+}
+export {};