agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-lambda/lib/capacity-provider.d.ts

@@ -0,0 +1,315 @@
+import type { Construct } from 'constructs';
+import type { Architecture } from './architecture';
+import type { IFunction } from './function-base';
+import type * as ec2 from '../../aws-ec2';
+import * as iam from '../../aws-iam';
+import type * as kms from '../../aws-kms';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+import type { CapacityProviderReference, ICapacityProviderRef } from '../../interfaces/generated/aws-lambda-interfaces.generated';
+/**
+ * Represents a Lambda capacity provider.
+ */
+export interface ICapacityProvider extends IResource, ICapacityProviderRef {
+    /**
+     * The ARN of the capacity provider.
+     *
+     * @attribute
+     */
+    readonly capacityProviderArn: string;
+    /**
+     * The name of the capacity provider.
+     *
+     * @attribute
+     */
+    readonly capacityProviderName: string;
+}
+/**
+ * Properties for creating a Lambda capacity provider.
+ */
+export interface CapacityProviderProps {
+    /**
+     * The name of the capacity provider. The name must be unique within the AWS account and region.
+     *
+     * @default - AWS CloudFormation generates a unique physical ID and uses that
+     * ID for the capacity provider's name.
+     */
+    readonly capacityProviderName?: string;
+    /**
+     * A list of security group IDs to associate with EC2 instances launched by the capacity provider.
+     * Up to 5 security groups can be specified.
+     */
+    readonly securityGroups: ec2.ISecurityGroup[];
+    /**
+     * A list of subnets where the capacity provider can launch EC2 instances.
+     * At least one subnet must be specified, and up to 16 subnets are supported.
+     */
+    readonly subnets: ec2.ISubnet[];
+    /**
+     * The IAM role that the Lambda service assumes to manage the capacity provider.
+     *
+     * @default - A role will be generated containing the AWSLambdaManagedEC2ResourceOperator managed policy
+     */
+    readonly operatorRole?: iam.IRole;
+    /**
+     * The instruction set architecture required for compute instances.
+     * Only one architecture can be specified per capacity provider.
+     *
+     * @default - No architecture constraints specified
+     */
+    readonly architectures?: Architecture[];
+    /**
+     * Configuration for filtering instance types that the capacity provider can use.
+     *
+     * @default - No instance type filtering applied
+     */
+    readonly instanceTypeFilter?: InstanceTypeFilter;
+    /**
+     * The maximum number of vCPUs that the capacity provider can scale up to.
+     *
+     * @default - No maximum limit specified, service default is 400
+     */
+    readonly maxVCpuCount?: number;
+    /**
+     * The options for scaling a capacity provider, including scaling policies.
+     *
+     * @default - The `Auto` option is applied by default
+     */
+    readonly scalingOptions?: ScalingOptions;
+    /**
+     * The AWS Key Management Service (KMS) key used to encrypt data associated with the capacity provider.
+     *
+     * @default - No KMS key specified, uses an AWS-managed key instead
+     */
+    readonly kmsKey?: kms.IKey;
+}
+/**
+ * Configuration for filtering instance types that a capacity provider can use. Instances types can either be allowed or excluded, not both.
+ */
+export declare class InstanceTypeFilter {
+    /**
+     * Creates an instance type filter that allows only the specified instance types.
+     *
+     * @param instanceTypes A list of instance types that the capacity provider is allowed to use.
+     */
+    static allow(instanceTypes: ec2.InstanceType[]): InstanceTypeFilter;
+    /**
+     * Creates an instance type filter that excludes the specified instance types.
+     *
+     * @param instanceTypes A list of instance types that the capacity provider should not use.
+     */
+    static exclude(instanceTypes: ec2.InstanceType[]): InstanceTypeFilter;
+    /**
+     * A list of instance types that the capacity provider is allowed to use.
+     */
+    readonly allowedInstanceTypes?: ec2.InstanceType[];
+    /**
+     * A list of instance types that the capacity provider should not use.
+     */
+    readonly excludedInstanceTypes?: ec2.InstanceType[];
+    /**
+     * Creates a new InstanceTypeFilter.
+     *
+     * @param instanceTypes The instance type configuration
+     */
+    private constructor();
+}
+/**
+ * Configuration options for scaling a capacity provider, including scaling mode and policies.
+ */
+export declare class ScalingOptions {
+    /**
+     * Creates scaling options where the capacity provider manages scaling automatically.
+     */
+    static auto(): ScalingOptions;
+    /**
+     * Creates manual scaling options with custom target tracking scaling policies. At least one policy is required.
+     *
+     * @param scalingPolicies The target tracking scaling policies to use for manual scaling.
+     */
+    static manual(scalingPolicies: TargetTrackingScalingPolicy[]): ScalingOptions;
+    /**
+     * The scaling mode for the capacity provider.
+     */
+    readonly scalingMode: string;
+    /**
+     * The target tracking scaling policies used when scaling mode is 'Manual'.
+     */
+    readonly scalingPolicies?: TargetTrackingScalingPolicy[];
+    /**
+     * Creates a new ScalingOptions.
+     *
+     * @param scalingMode The scaling mode for the capacity provider
+     * @param scalingPolicies The target tracking scaling policies for manual scaling
+     */
+    private constructor();
+}
+/**
+ * A target tracking scaling policy that automatically adjusts the capacity provider's compute resources
+ * to maintain a specified target value by tracking the required CloudWatch metric.
+ */
+export declare class TargetTrackingScalingPolicy {
+    readonly metricType: string;
+    readonly value: number;
+    /**
+     * Creates a target tracking scaling policy for CPU utilization.
+     *
+     * @param targetCpuUtilization The target value for CPU utilization. The capacity provider will scale resources to maintain this target value.
+     */
+    static cpuUtilization(targetCpuUtilization: number): TargetTrackingScalingPolicy;
+    /**
+     * The predefined metric type for this scaling policy.
+     */
+    readonly predefinedMetricType: string;
+    /**
+     * The target value for the specified metric as a percentage. The capacity provider will scale resources to maintain this target value.
+     */
+    readonly targetValue: number;
+    /**
+     * Creates a new TargetTrackingScalingPolicy.
+     *
+     * @param metricType The predefined metric type
+     * @param value The target value for the metric
+     */
+    private constructor();
+}
+/**
+ * Base class for a Lambda capacity provider.
+ */
+declare abstract class CapacityProviderBase extends Resource implements ICapacityProvider {
+    /**
+     * The name of the capacity provider.
+     */
+    abstract readonly capacityProviderName: string;
+    /**
+     * The Amazon Resource Name (ARN) of the capacity provider.
+     */
+    abstract readonly capacityProviderArn: string;
+    get capacityProviderRef(): CapacityProviderReference;
+}
+/**
+ * Attributes for importing an existing Lambda capacity provider.
+ */
+export interface CapacityProviderAttributes {
+    /**
+     * The Amazon Resource Name (ARN) of the capacity provider.
+     *
+     * Format: arn:<partition>:lambda:<region>:<account-id>:capacity-provider:<capacity-provider-name>
+     */
+    readonly capacityProviderArn: string;
+}
+/**
+ * Options for creating a function associated with a capacity provider.
+ */
+export interface CapacityProviderFunctionOptions {
+    /**
+     * Specifies the maximum number of concurrent invokes a single execution environment can handle.
+     *
+     * @default Maximum is set to 10
+     */
+    readonly perExecutionEnvironmentMaxConcurrency?: number;
+    /**
+     * Specifies the execution environment memory per VCPU, in GiB.
+     *
+     * @default 2.0
+     */
+    readonly executionEnvironmentMemoryGiBPerVCpu?: number;
+    /**
+     * A boolean determining whether or not to automatically publish to the $LATEST.PUBLISHED version.
+     *
+     * @default - True
+     */
+    readonly publishToLatestPublished?: boolean;
+    /**
+     * The scaling options that are applied to the $LATEST.PUBLISHED version.
+     *
+     * @default - No scaling limitations are applied to the $LATEST.PUBLISHED version.
+     */
+    readonly latestPublishedScalingConfig?: LatestPublishedScalingConfig;
+}
+/**
+ * The scaling configuration that will be applied to the $LATEST.PUBLISHED version.
+ */
+export interface LatestPublishedScalingConfig {
+    /**
+     * The minimum number of execution environments to maintain for the $LATEST.PUBLISHED version
+     * when published into a capacity provider.
+     *
+     * This setting ensures that at least this many execution environments are always
+     * available to handle function invocations for this specific version, reducing cold start latency.
+     *
+     * @default - 3 execution environments are set to be the minimum
+     */
+    readonly minExecutionEnvironments?: number;
+    /**
+     * The maximum number of execution environments allowed for the $LATEST.PUBLISHED version
+     * when published into a capacity provider.
+     *
+     * This setting limits the total number of execution environments that can be created
+     * to handle concurrent invocations of this specific version.
+     *
+     * @default - No maximum specified
+     */
+    readonly maxExecutionEnvironments?: number;
+}
+/**
+ * A Lambda capacity provider that manages compute resources for Lambda functions.
+ */
+export declare class CapacityProvider extends CapacityProviderBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing capacity provider by name.
+     *
+     * @param scope The parent construct
+     * @param id The construct ID
+     * @param capacityProviderName The name of the capacity provider to import
+     */
+    static fromCapacityProviderName(scope: Construct, id: string, capacityProviderName: string): ICapacityProvider;
+    /**
+     * Import an existing capacity provider by ARN.
+     *
+     * @param scope The parent construct
+     * @param id The construct ID
+     * @param capacityProviderArn The ARN of the capacity provider to import
+     */
+    static fromCapacityProviderArn(scope: Construct, id: string, capacityProviderArn: string): ICapacityProvider;
+    /**
+     * Import an existing capacity provider using its attributes.
+     *
+     * @param scope The parent construct
+     * @param id The construct ID
+     * @param attrs The capacity provider attributes
+     */
+    static fromCapacityProviderAttributes(scope: Construct, id: string, attrs: CapacityProviderAttributes): ICapacityProvider;
+    private readonly capacityProvider;
+    /**
+     * The name of the capacity provider.
+     */
+    get capacityProviderName(): string;
+    /**
+     * The Amazon Resource Name (ARN) of the capacity provider.
+     */
+    get capacityProviderArn(): string;
+    /**
+     * Creates a new Lambda capacity provider.
+     *
+     * @param scope The parent construct
+     * @param id The construct ID
+     * @param props The capacity provider properties
+     */
+    constructor(scope: Construct, id: string, props: CapacityProviderProps);
+    private validateCapacityProviderProps;
+    private validateCapacityProviderName;
+    private validateScalingPolicies;
+    private validateInstanceTypeFilter;
+    /**
+     * Configures a Lambda function to use this capacity provider.
+     *
+     * @param func The Lambda function to configure
+     * @param options Optional configuration for the function's capacity provider settings
+     */
+    addFunction(func: IFunction, options?: CapacityProviderFunctionOptions): void;
+    private validateFunctionScalingConfig;
+}
+export {};