agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/elasticloadbalancing-canned-metrics.generated.d.ts

@@ -0,0 +1,176 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class ELBMetrics {
+    static backendConnectionErrorsSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static backendConnectionErrorsSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static desyncMitigationModeNonCompliantRequestCountSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static desyncMitigationModeNonCompliantRequestCountSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend2XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend2XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend3XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend3XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend4XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend4XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend5XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend5XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb4XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb4XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb5XxSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb5XxSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static healthyHostCountAverage(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static healthyHostCountAverage(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static latencyAverage(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static latencyAverage(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static requestCountSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static requestCountSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static spilloverCountSum(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static spilloverCountSum(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static surgeQueueLengthAverage(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static surgeQueueLengthAverage(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static unHealthyHostCountAverage(this: void, dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static unHealthyHostCountAverage(this: void, dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+}

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/elasticloadbalancing-canned-metrics.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ELBMetrics=void 0;class ELBMetrics{static backendConnectionErrorsSum(dimensions){return{namespace:"AWS/ELB",metricName:"BackendConnectionErrors",dimensionsMap:dimensions,statistic:"Sum"}}static desyncMitigationModeNonCompliantRequestCountSum(dimensions){return{namespace:"AWS/ELB",metricName:"DesyncMitigationMode_NonCompliant_Request_Count",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeBackend2XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_Backend_2XX",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeBackend3XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_Backend_3XX",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeBackend4XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_Backend_4XX",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeBackend5XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_Backend_5XX",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeElb4XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_ELB_4XX",dimensionsMap:dimensions,statistic:"Sum"}}static httpCodeElb5XxSum(dimensions){return{namespace:"AWS/ELB",metricName:"HTTPCode_ELB_5XX",dimensionsMap:dimensions,statistic:"Sum"}}static healthyHostCountAverage(dimensions){return{namespace:"AWS/ELB",metricName:"HealthyHostCount",dimensionsMap:dimensions,statistic:"Average"}}static latencyAverage(dimensions){return{namespace:"AWS/ELB",metricName:"Latency",dimensionsMap:dimensions,statistic:"Average"}}static requestCountSum(dimensions){return{namespace:"AWS/ELB",metricName:"RequestCount",dimensionsMap:dimensions,statistic:"Sum"}}static spilloverCountSum(dimensions){return{namespace:"AWS/ELB",metricName:"SpilloverCount",dimensionsMap:dimensions,statistic:"Sum"}}static surgeQueueLengthAverage(dimensions){return{namespace:"AWS/ELB",metricName:"SurgeQueueLength",dimensionsMap:dimensions,statistic:"Average"}}static unHealthyHostCountAverage(dimensions){return{namespace:"AWS/ELB",metricName:"UnHealthyHostCount",dimensionsMap:dimensions,statistic:"Average"}}}exports.ELBMetrics=ELBMetrics;

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/elasticloadbalancing.generated.d.ts

@@ -0,0 +1,699 @@
+import * as cdk from "../../core/lib";
+import * as constructs from "constructs";
+import * as cfn_parse from "../../core/lib/helpers-internal";
+import { aws_ec2 as ec2Refs } from "../../interfaces";
+import { ILoadBalancerRef, LoadBalancerReference } from "../../interfaces/generated/aws-elasticloadbalancing-interfaces.generated";
+/**
+ * Specifies a Classic Load Balancer.
+ *
+ * If this resource has a public IP address and is also in a VPC that is defined in the same template, you must use the [DependsOn attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html) to declare a dependency on the VPC-gateway attachment.
+ *
+ * @cloudformationResource AWS::ElasticLoadBalancing::LoadBalancer
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html
+ */
+export declare class CfnLoadBalancer extends cdk.CfnResource implements cdk.IInspectable, ILoadBalancerRef, cdk.ITaggable {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly CFN_RESOURCE_TYPE_NAME: string;
+    /**
+     * Build a CfnLoadBalancer from CloudFormation properties
+     *
+     * A factory method that creates a new instance of this class from an object
+     * containing the CloudFormation properties of this resource.
+     * Used in the @aws-cdk/cloudformation-include module.
+     *
+     * @internal
+     */
+    static _fromCloudFormation(scope: constructs.Construct, id: string, resourceAttributes: any, options: cfn_parse.FromCloudFormationOptions): CfnLoadBalancer;
+    /**
+     * Checks whether the given object is a CfnLoadBalancer
+     */
+    static isCfnLoadBalancer(x: any): x is CfnLoadBalancer;
+    /**
+     * Creates a new ILoadBalancerRef from a loadBalancerName
+     */
+    static fromLoadBalancerName(scope: constructs.Construct, id: string, loadBalancerName: string): ILoadBalancerRef;
+    static arnForLoadBalancer(resource: ILoadBalancerRef): string;
+    /**
+     * Information about where and how access logs are stored for the load balancer.
+     */
+    private _accessLoggingPolicy?;
+    /**
+     * Information about a policy for application-controlled session stickiness.
+     */
+    private _appCookieStickinessPolicy?;
+    /**
+     * The Availability Zones for a load balancer in a default VPC.
+     */
+    private _availabilityZones?;
+    /**
+     * If enabled, the load balancer allows existing requests to complete before the load balancer shifts traffic away from a deregistered or unhealthy instance.
+     */
+    private _connectionDrainingPolicy?;
+    /**
+     * If enabled, the load balancer allows the connections to remain idle (no data is sent over the connection) for the specified duration.
+     */
+    private _connectionSettings?;
+    /**
+     * If enabled, the load balancer routes the request traffic evenly across all instances regardless of the Availability Zones.
+     */
+    private _crossZone?;
+    /**
+     * The health check settings to use when evaluating the health of your EC2 instances.
+     */
+    private _healthCheck?;
+    /**
+     * The IDs of the instances for the load balancer.
+     */
+    private _instances?;
+    /**
+     * Information about a policy for duration-based session stickiness.
+     */
+    private _lbCookieStickinessPolicy?;
+    /**
+     * The listeners for the load balancer. You can specify at most one listener per port.
+     */
+    private _listeners;
+    /**
+     * The name of the load balancer.
+     */
+    private _loadBalancerName?;
+    /**
+     * The policies defined for your Classic Load Balancer.
+     */
+    private _policies?;
+    /**
+     * The type of load balancer. Valid only for load balancers in a VPC.
+     */
+    private _scheme?;
+    /**
+     * The security groups for the load balancer.
+     */
+    private _securityGroups?;
+    /**
+     * The IDs of the subnets for the load balancer. You can specify at most one subnet per Availability Zone.
+     */
+    private _subnets?;
+    /**
+     * Tag Manager which manages the tags for this resource
+     */
+    readonly tags: cdk.TagManager;
+    /**
+     * The tags associated with a load balancer.
+     */
+    private _tagsRaw?;
+    protected readonly cfnPropertyNames: Record<string, string>;
+    /**
+     * Create a new `AWS::ElasticLoadBalancing::LoadBalancer`.
+     *
+     * @param scope Scope in which this resource is defined
+     * @param id Construct identifier for this resource (unique in its scope)
+     * @param props Resource properties
+     */
+    constructor(scope: constructs.Construct, id: string, props: CfnLoadBalancerProps);
+    get loadBalancerRef(): LoadBalancerReference;
+    /**
+     * Information about where and how access logs are stored for the load balancer.
+     */
+    get accessLoggingPolicy(): CfnLoadBalancer.AccessLoggingPolicyProperty | cdk.IResolvable | undefined;
+    /**
+     * Information about where and how access logs are stored for the load balancer.
+     */
+    set accessLoggingPolicy(value: CfnLoadBalancer.AccessLoggingPolicyProperty | cdk.IResolvable | undefined);
+    /**
+     * Information about a policy for application-controlled session stickiness.
+     */
+    get appCookieStickinessPolicy(): Array<CfnLoadBalancer.AppCookieStickinessPolicyProperty | cdk.IResolvable> | cdk.IResolvable | undefined;
+    /**
+     * Information about a policy for application-controlled session stickiness.
+     */
+    set appCookieStickinessPolicy(value: Array<CfnLoadBalancer.AppCookieStickinessPolicyProperty | cdk.IResolvable> | cdk.IResolvable | undefined);
+    /**
+     * The Availability Zones for a load balancer in a default VPC.
+     */
+    get availabilityZones(): Array<string> | undefined;
+    /**
+     * The Availability Zones for a load balancer in a default VPC.
+     */
+    set availabilityZones(value: Array<string> | undefined);
+    /**
+     * If enabled, the load balancer allows existing requests to complete before the load balancer shifts traffic away from a deregistered or unhealthy instance.
+     */
+    get connectionDrainingPolicy(): CfnLoadBalancer.ConnectionDrainingPolicyProperty | cdk.IResolvable | undefined;
+    /**
+     * If enabled, the load balancer allows existing requests to complete before the load balancer shifts traffic away from a deregistered or unhealthy instance.
+     */
+    set connectionDrainingPolicy(value: CfnLoadBalancer.ConnectionDrainingPolicyProperty | cdk.IResolvable | undefined);
+    /**
+     * If enabled, the load balancer allows the connections to remain idle (no data is sent over the connection) for the specified duration.
+     */
+    get connectionSettings(): CfnLoadBalancer.ConnectionSettingsProperty | cdk.IResolvable | undefined;
+    /**
+     * If enabled, the load balancer allows the connections to remain idle (no data is sent over the connection) for the specified duration.
+     */
+    set connectionSettings(value: CfnLoadBalancer.ConnectionSettingsProperty | cdk.IResolvable | undefined);
+    /**
+     * If enabled, the load balancer routes the request traffic evenly across all instances regardless of the Availability Zones.
+     */
+    get crossZone(): boolean | cdk.IResolvable | undefined;
+    /**
+     * If enabled, the load balancer routes the request traffic evenly across all instances regardless of the Availability Zones.
+     */
+    set crossZone(value: boolean | cdk.IResolvable | undefined);
+    /**
+     * The health check settings to use when evaluating the health of your EC2 instances.
+     */
+    get healthCheck(): CfnLoadBalancer.HealthCheckProperty | cdk.IResolvable | undefined;
+    /**
+     * The health check settings to use when evaluating the health of your EC2 instances.
+     */
+    set healthCheck(value: CfnLoadBalancer.HealthCheckProperty | cdk.IResolvable | undefined);
+    /**
+     * The IDs of the instances for the load balancer.
+     */
+    get instances(): Array<string> | undefined;
+    /**
+     * The IDs of the instances for the load balancer.
+     */
+    set instances(value: Array<string> | undefined);
+    /**
+     * Information about a policy for duration-based session stickiness.
+     */
+    get lbCookieStickinessPolicy(): Array<cdk.IResolvable | CfnLoadBalancer.LBCookieStickinessPolicyProperty> | cdk.IResolvable | undefined;
+    /**
+     * Information about a policy for duration-based session stickiness.
+     */
+    set lbCookieStickinessPolicy(value: Array<cdk.IResolvable | CfnLoadBalancer.LBCookieStickinessPolicyProperty> | cdk.IResolvable | undefined);
+    /**
+     * The listeners for the load balancer. You can specify at most one listener per port.
+     */
+    get listeners(): Array<cdk.IResolvable | CfnLoadBalancer.ListenersProperty> | cdk.IResolvable;
+    /**
+     * The listeners for the load balancer. You can specify at most one listener per port.
+     */
+    set listeners(value: Array<cdk.IResolvable | CfnLoadBalancer.ListenersProperty> | cdk.IResolvable);
+    /**
+     * The name of the load balancer.
+     */
+    get loadBalancerName(): string | undefined;
+    /**
+     * The name of the load balancer.
+     */
+    set loadBalancerName(value: string | undefined);
+    /**
+     * The policies defined for your Classic Load Balancer.
+     */
+    get policies(): Array<cdk.IResolvable | CfnLoadBalancer.PoliciesProperty> | cdk.IResolvable | undefined;
+    /**
+     * The policies defined for your Classic Load Balancer.
+     */
+    set policies(value: Array<cdk.IResolvable | CfnLoadBalancer.PoliciesProperty> | cdk.IResolvable | undefined);
+    /**
+     * The type of load balancer. Valid only for load balancers in a VPC.
+     */
+    get scheme(): string | undefined;
+    /**
+     * The type of load balancer. Valid only for load balancers in a VPC.
+     */
+    set scheme(value: string | undefined);
+    /**
+     * The security groups for the load balancer.
+     */
+    get securityGroups(): Array<string> | undefined;
+    /**
+     * The security groups for the load balancer.
+     */
+    set securityGroups(value: Array<string> | undefined);
+    /**
+     * The IDs of the subnets for the load balancer. You can specify at most one subnet per Availability Zone.
+     */
+    get subnets(): Array<string> | undefined;
+    /**
+     * The IDs of the subnets for the load balancer. You can specify at most one subnet per Availability Zone.
+     */
+    set subnets(value: Array<string> | undefined);
+    /**
+     * The tags associated with a load balancer.
+     */
+    get tagsRaw(): Array<cdk.CfnTag> | undefined;
+    /**
+     * The tags associated with a load balancer.
+     */
+    set tagsRaw(value: Array<cdk.CfnTag> | undefined);
+    /**
+     * The name of the Route 53 hosted zone that is associated with the load balancer. Internal-facing load balancers don't use this value, use `DNSName` instead.
+     *
+     * @cloudformationAttribute CanonicalHostedZoneName
+     */
+    get attrCanonicalHostedZoneName(): string;
+    /**
+     * The ID of the Route 53 hosted zone name that is associated with the load balancer.
+     *
+     * @cloudformationAttribute CanonicalHostedZoneNameID
+     */
+    get attrCanonicalHostedZoneNameId(): string;
+    /**
+     * The DNS name for the load balancer.
+     *
+     * @cloudformationAttribute DNSName
+     */
+    get attrDnsName(): string;
+    /**
+     * @cloudformationAttribute Id
+     */
+    get attrId(): string;
+    /**
+     * The name of the security group that you can use as part of your inbound rules for your load balancer's back-end instances.
+     *
+     * @cloudformationAttribute SourceSecurityGroup.GroupName
+     */
+    get attrSourceSecurityGroupGroupName(): string;
+    /**
+     * The owner of the source security group.
+     *
+     * @cloudformationAttribute SourceSecurityGroup.OwnerAlias
+     */
+    get attrSourceSecurityGroupOwnerAlias(): string;
+    protected get cfnProperties(): Record<string, any>;
+    /**
+     * Examines the CloudFormation resource and discloses attributes
+     *
+     * @param inspector tree inspector to collect and process attributes
+     */
+    inspect(inspector: cdk.TreeInspector): void;
+    protected renderProperties(props: Record<string, any>): Record<string, any>;
+}
+export declare namespace CfnLoadBalancer {
+    /**
+     * Specifies where and how access logs are stored for your Classic Load Balancer.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-accessloggingpolicy.html
+     */
+    interface AccessLoggingPolicyProperty {
+        /**
+         * The interval for publishing the access logs. You can specify an interval of either 5 minutes or 60 minutes.
+         *
+         * Default: 60 minutes
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-accessloggingpolicy.html#cfn-elasticloadbalancing-loadbalancer-accessloggingpolicy-emitinterval
+         */
+        readonly emitInterval?: number;
+        /**
+         * Specifies whether access logs are enabled for the load balancer.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-accessloggingpolicy.html#cfn-elasticloadbalancing-loadbalancer-accessloggingpolicy-enabled
+         */
+        readonly enabled: boolean | cdk.IResolvable;
+        /**
+         * The name of the Amazon S3 bucket where the access logs are stored.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-accessloggingpolicy.html#cfn-elasticloadbalancing-loadbalancer-accessloggingpolicy-s3bucketname
+         */
+        readonly s3BucketName: string;
+        /**
+         * The logical hierarchy you created for your Amazon S3 bucket, for example `my-bucket-prefix/prod` .
+         *
+         * If the prefix is not provided, the log is placed at the root level of the bucket.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-accessloggingpolicy.html#cfn-elasticloadbalancing-loadbalancer-accessloggingpolicy-s3bucketprefix
+         */
+        readonly s3BucketPrefix?: string;
+    }
+    /**
+     * Specifies a policy for application-controlled session stickiness for your Classic Load Balancer.
+     *
+     * To associate a policy with a listener, use the [PolicyNames](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-elb-listener.html#cfn-ec2-elb-listener-policynames) property for the listener.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy.html
+     */
+    interface AppCookieStickinessPolicyProperty {
+        /**
+         * The name of the application cookie used for stickiness.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy.html#cfn-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy-cookiename
+         */
+        readonly cookieName: string;
+        /**
+         * The mnemonic name for the policy being created.
+         *
+         * The name must be unique within a set of policies for this load balancer.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy.html#cfn-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy-policyname
+         */
+        readonly policyName: string;
+    }
+    /**
+     * Specifies the connection draining settings for your Classic Load Balancer.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-connectiondrainingpolicy.html
+     */
+    interface ConnectionDrainingPolicyProperty {
+        /**
+         * Specifies whether connection draining is enabled for the load balancer.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-connectiondrainingpolicy.html#cfn-elasticloadbalancing-loadbalancer-connectiondrainingpolicy-enabled
+         */
+        readonly enabled: boolean | cdk.IResolvable;
+        /**
+         * The maximum time, in seconds, to keep the existing connections open before deregistering the instances.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-connectiondrainingpolicy.html#cfn-elasticloadbalancing-loadbalancer-connectiondrainingpolicy-timeout
+         */
+        readonly timeout?: number;
+    }
+    /**
+     * Specifies the idle timeout value for your Classic Load Balancer.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-connectionsettings.html
+     */
+    interface ConnectionSettingsProperty {
+        /**
+         * The time, in seconds, that the connection is allowed to be idle (no data has been sent over the connection) before it is closed by the load balancer.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-connectionsettings.html#cfn-elasticloadbalancing-loadbalancer-connectionsettings-idletimeout
+         */
+        readonly idleTimeout: number;
+    }
+    /**
+     * Specifies health check settings for your Classic Load Balancer.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html
+     */
+    interface HealthCheckProperty {
+        /**
+         * The number of consecutive health checks successes required before moving the instance to the `Healthy` state.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html#cfn-elasticloadbalancing-loadbalancer-healthcheck-healthythreshold
+         */
+        readonly healthyThreshold: string;
+        /**
+         * The approximate interval, in seconds, between health checks of an individual instance.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html#cfn-elasticloadbalancing-loadbalancer-healthcheck-interval
+         */
+        readonly interval: string;
+        /**
+         * The instance being checked.
+         *
+         * The protocol is either TCP, HTTP, HTTPS, or SSL. The range of valid ports is one (1) through 65535.
+         *
+         * TCP is the default, specified as a TCP: port pair, for example "TCP:5000". In this case, a health check simply attempts to open a TCP connection to the instance on the specified port. Failure to connect within the configured timeout is considered unhealthy.
+         *
+         * SSL is also specified as SSL: port pair, for example, SSL:5000.
+         *
+         * For HTTP/HTTPS, you must include a ping path in the string. HTTP is specified as a HTTP:port;/;PathToPing; grouping, for example "HTTP:80/weather/us/wa/seattle". In this case, a HTTP GET request is issued to the instance on the given port and path. Any answer other than "200 OK" within the timeout period is considered unhealthy.
+         *
+         * The total length of the HTTP ping target must be 1024 16-bit Unicode characters or less.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html#cfn-elasticloadbalancing-loadbalancer-healthcheck-target
+         */
+        readonly target: string;
+        /**
+         * The amount of time, in seconds, during which no response means a failed health check.
+         *
+         * This value must be less than the `Interval` value.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html#cfn-elasticloadbalancing-loadbalancer-healthcheck-timeout
+         */
+        readonly timeout: string;
+        /**
+         * The number of consecutive health check failures required before moving the instance to the `Unhealthy` state.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-healthcheck.html#cfn-elasticloadbalancing-loadbalancer-healthcheck-unhealthythreshold
+         */
+        readonly unhealthyThreshold: string;
+    }
+    /**
+     * Specifies a policy for duration-based session stickiness for your Classic Load Balancer.
+     *
+     * To associate a policy with a listener, use the [PolicyNames](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-elb-listener.html#cfn-ec2-elb-listener-policynames) property for the listener.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy.html
+     */
+    interface LBCookieStickinessPolicyProperty {
+        /**
+         * The time period, in seconds, after which the cookie should be considered stale.
+         *
+         * If this parameter is not specified, the stickiness session lasts for the duration of the browser session.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy.html#cfn-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy-cookieexpirationperiod
+         */
+        readonly cookieExpirationPeriod?: string;
+        /**
+         * The name of the policy.
+         *
+         * This name must be unique within the set of policies for this load balancer.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy.html#cfn-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy-policyname
+         */
+        readonly policyName?: string;
+    }
+    /**
+     * Specifies a listener for your Classic Load Balancer.
+     *
+     * Modifying any property replaces the listener.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html
+     */
+    interface ListenersProperty {
+        /**
+         * The port on which the instance is listening.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-instanceport
+         */
+        readonly instancePort: string;
+        /**
+         * The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or SSL.
+         *
+         * If the front-end protocol is TCP or SSL, the back-end protocol must be TCP or SSL. If the front-end protocol is HTTP or HTTPS, the back-end protocol must be HTTP or HTTPS.
+         *
+         * If there is another listener with the same `InstancePort` whose `InstanceProtocol` is secure, (HTTPS or SSL), the listener's `InstanceProtocol` must also be secure.
+         *
+         * If there is another listener with the same `InstancePort` whose `InstanceProtocol` is HTTP or TCP, the listener's `InstanceProtocol` must be HTTP or TCP.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-instanceprotocol
+         */
+        readonly instanceProtocol?: string;
+        /**
+         * The port on which the load balancer is listening.
+         *
+         * On EC2-VPC, you can specify any port from the range 1-65535. On EC2-Classic, you can specify any port from the following list: 25, 80, 443, 465, 587, 1024-65535.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-loadbalancerport
+         */
+        readonly loadBalancerPort: string;
+        /**
+         * The names of the policies to associate with the listener.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-policynames
+         */
+        readonly policyNames?: Array<string>;
+        /**
+         * The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, or SSL.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-protocol
+         */
+        readonly protocol: string;
+        /**
+         * The Amazon Resource Name (ARN) of the server certificate.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-listeners.html#cfn-elasticloadbalancing-loadbalancer-listeners-sslcertificateid
+         */
+        readonly sslCertificateId?: string;
+    }
+    /**
+     * Specifies policies for your Classic Load Balancer.
+     *
+     * To associate policies with a listener, use the [PolicyNames](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-elb-listener.html#cfn-ec2-elb-listener-policynames) property for the listener.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html
+     */
+    interface PoliciesProperty {
+        /**
+         * The policy attributes.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html#cfn-elasticloadbalancing-loadbalancer-policies-attributes
+         */
+        readonly attributes: Array<any | cdk.IResolvable> | cdk.IResolvable;
+        /**
+         * The instance ports for the policy.
+         *
+         * Required only for some policy types.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html#cfn-elasticloadbalancing-loadbalancer-policies-instanceports
+         */
+        readonly instancePorts?: Array<string>;
+        /**
+         * The load balancer ports for the policy.
+         *
+         * Required only for some policy types.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html#cfn-elasticloadbalancing-loadbalancer-policies-loadbalancerports
+         */
+        readonly loadBalancerPorts?: Array<string>;
+        /**
+         * The name of the policy.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html#cfn-elasticloadbalancing-loadbalancer-policies-policyname
+         */
+        readonly policyName: string;
+        /**
+         * The name of the policy type.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancing-loadbalancer-policies.html#cfn-elasticloadbalancing-loadbalancer-policies-policytype
+         */
+        readonly policyType: string;
+    }
+}
+/**
+ * Properties for defining a `CfnLoadBalancer`
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html
+ */
+export interface CfnLoadBalancerProps {
+    /**
+     * Information about where and how access logs are stored for the load balancer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-accessloggingpolicy
+     */
+    readonly accessLoggingPolicy?: CfnLoadBalancer.AccessLoggingPolicyProperty | cdk.IResolvable;
+    /**
+     * Information about a policy for application-controlled session stickiness.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-appcookiestickinesspolicy
+     */
+    readonly appCookieStickinessPolicy?: Array<CfnLoadBalancer.AppCookieStickinessPolicyProperty | cdk.IResolvable> | cdk.IResolvable;
+    /**
+     * The Availability Zones for a load balancer in a default VPC.
+     *
+     * For a load balancer in a nondefault VPC, specify `Subnets` instead.
+     *
+     * Update requires replacement if you did not previously specify an Availability Zone or if you are removing all Availability Zones. Otherwise, update requires no interruption.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-availabilityzones
+     */
+    readonly availabilityZones?: Array<string>;
+    /**
+     * If enabled, the load balancer allows existing requests to complete before the load balancer shifts traffic away from a deregistered or unhealthy instance.
+     *
+     * For more information, see [Configure connection draining](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html) in the *User Guide for Classic Load Balancers* .
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-connectiondrainingpolicy
+     */
+    readonly connectionDrainingPolicy?: CfnLoadBalancer.ConnectionDrainingPolicyProperty | cdk.IResolvable;
+    /**
+     * If enabled, the load balancer allows the connections to remain idle (no data is sent over the connection) for the specified duration.
+     *
+     * By default, Elastic Load Balancing maintains a 60-second idle connection timeout for both front-end and back-end connections of your load balancer. For more information, see [Configure idle connection timeout](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html) in the *User Guide for Classic Load Balancers* .
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-connectionsettings
+     */
+    readonly connectionSettings?: CfnLoadBalancer.ConnectionSettingsProperty | cdk.IResolvable;
+    /**
+     * If enabled, the load balancer routes the request traffic evenly across all instances regardless of the Availability Zones.
+     *
+     * For more information, see [Configure cross-zone load balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html) in the *User Guide for Classic Load Balancers* .
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-crosszone
+     */
+    readonly crossZone?: boolean | cdk.IResolvable;
+    /**
+     * The health check settings to use when evaluating the health of your EC2 instances.
+     *
+     * Update requires replacement if you did not previously specify health check settings or if you are removing the health check settings. Otherwise, update requires no interruption.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-healthcheck
+     */
+    readonly healthCheck?: CfnLoadBalancer.HealthCheckProperty | cdk.IResolvable;
+    /**
+     * The IDs of the instances for the load balancer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-instances
+     */
+    readonly instances?: Array<ec2Refs.IInstanceRef | string>;
+    /**
+     * Information about a policy for duration-based session stickiness.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-lbcookiestickinesspolicy
+     */
+    readonly lbCookieStickinessPolicy?: Array<cdk.IResolvable | CfnLoadBalancer.LBCookieStickinessPolicyProperty> | cdk.IResolvable;
+    /**
+     * The listeners for the load balancer. You can specify at most one listener per port.
+     *
+     * If you update the properties for a listener, AWS CloudFormation deletes the existing listener and creates a new one with the specified properties. While the new listener is being created, clients cannot connect to the load balancer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-listeners
+     */
+    readonly listeners: Array<cdk.IResolvable | CfnLoadBalancer.ListenersProperty> | cdk.IResolvable;
+    /**
+     * The name of the load balancer.
+     *
+     * This name must be unique within your set of load balancers for the region.
+     *
+     * If you don't specify a name, AWS CloudFormation generates a unique physical ID for the load balancer. For more information, see [Name Type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) . If you specify a name, you cannot perform updates that require replacement of this resource, but you can perform other updates. To replace the resource, specify a new name.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-loadbalancername
+     */
+    readonly loadBalancerName?: string;
+    /**
+     * The policies defined for your Classic Load Balancer.
+     *
+     * Specify only back-end server policies.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-policies
+     */
+    readonly policies?: Array<cdk.IResolvable | CfnLoadBalancer.PoliciesProperty> | cdk.IResolvable;
+    /**
+     * The type of load balancer. Valid only for load balancers in a VPC.
+     *
+     * If `Scheme` is `internet-facing` , the load balancer has a public DNS name that resolves to a public IP address.
+     *
+     * If `Scheme` is `internal` , the load balancer has a public DNS name that resolves to a private IP address.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-scheme
+     */
+    readonly scheme?: string;
+    /**
+     * The security groups for the load balancer.
+     *
+     * Valid only for load balancers in a VPC.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-securitygroups
+     */
+    readonly securityGroups?: Array<ec2Refs.ISecurityGroupRef | string>;
+    /**
+     * The IDs of the subnets for the load balancer. You can specify at most one subnet per Availability Zone.
+     *
+     * Update requires replacement if you did not previously specify a subnet or if you are removing all subnets. Otherwise, update requires no interruption. To update to a different subnet in the current Availability Zone, you must first update to a subnet in a different Availability Zone, then update to the new subnet in the original Availability Zone.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-subnets
+     */
+    readonly subnets?: Array<ec2Refs.ISubnetRef | string>;
+    /**
+     * The tags associated with a load balancer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancing-loadbalancer.html#cfn-elasticloadbalancing-loadbalancer-tags
+     */
+    readonly tags?: Array<cdk.CfnTag>;
+}
+export type { ILoadBalancerRef, LoadBalancerReference };

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './elasticloadbalancing.generated';
+export * from './load-balancer';

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/index.js

@@ -0,0 +1 @@
+"use strict";var __createBinding=exports&&exports.__createBinding||(Object.create?(function(o,m,k,k2){k2===void 0&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);(!desc||("get"in desc?!m.__esModule:desc.writable||desc.configurable))&&(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}):(function(o,m,k,k2){k2===void 0&&(k2=k),o[k2]=m[k]})),__exportStar=exports&&exports.__exportStar||function(m,exports2){for(var p in m)p!=="default"&&!Object.prototype.hasOwnProperty.call(exports2,p)&&__createBinding(exports2,m,p)};Object.defineProperty(exports,"__esModule",{value:!0});var _noFold;exports.CfnLoadBalancer=void 0,Object.defineProperty(exports,_noFold="CfnLoadBalancer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./elasticloadbalancing.generated").CfnLoadBalancer;return Object.defineProperty(exports,_noFold="CfnLoadBalancer",{enumerable:!0,configurable:!0,value}),value}}),exports.LoadBalancingProtocol=void 0,Object.defineProperty(exports,_noFold="LoadBalancingProtocol",{enumerable:!0,configurable:!0,get:()=>{var value=require("./load-balancer").LoadBalancingProtocol;return Object.defineProperty(exports,_noFold="LoadBalancingProtocol",{enumerable:!0,configurable:!0,value}),value}}),exports.LoadBalancer=void 0,Object.defineProperty(exports,_noFold="LoadBalancer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./load-balancer").LoadBalancer;return Object.defineProperty(exports,_noFold="LoadBalancer",{enumerable:!0,configurable:!0,value}),value}}),exports.InstanceTarget=void 0,Object.defineProperty(exports,_noFold="InstanceTarget",{enumerable:!0,configurable:!0,get:()=>{var value=require("./load-balancer").InstanceTarget;return Object.defineProperty(exports,_noFold="InstanceTarget",{enumerable:!0,configurable:!0,value}),value}}),exports.ListenerPort=void 0,Object.defineProperty(exports,_noFold="ListenerPort",{enumerable:!0,configurable:!0,get:()=>{var value=require("./load-balancer").ListenerPort;return Object.defineProperty(exports,_noFold="ListenerPort",{enumerable:!0,configurable:!0,value}),value}});

cdk/node_modules/aws-cdk-lib/aws-elasticloadbalancing/lib/load-balancer.d.ts

@@ -0,0 +1,313 @@
+import type { Construct } from 'constructs';
+import { CfnLoadBalancer } from './elasticloadbalancing.generated';
+import type { IConnectable, Instance, ISecurityGroup, IVpc, SubnetSelection } from '../../aws-ec2';
+import { Connections, Port } from '../../aws-ec2';
+import type { IResource } from '../../core';
+import { Duration, Resource } from '../../core';
+import type { aws_elasticloadbalancing } from '../../interfaces';
+/**
+ * Represents a load balancer
+ */
+export interface ILoadBalancer extends IResource, aws_elasticloadbalancing.ILoadBalancerRef {
+}
+/**
+ * Construction properties for a LoadBalancer
+ */
+export interface LoadBalancerProps {
+    /**
+     * VPC network of the fleet instances
+     */
+    readonly vpc: IVpc;
+    /**
+     * Whether this is an internet-facing Load Balancer
+     *
+     * This controls whether the LB has a public IP address assigned. It does
+     * not open up the Load Balancer's security groups to public internet access.
+     *
+     * @default false
+     */
+    readonly internetFacing?: boolean;
+    /**
+     * What listeners to set up for the load balancer.
+     *
+     * Can also be added by .addListener()
+     *
+     * @default -
+     */
+    readonly listeners?: LoadBalancerListener[];
+    /**
+     * What targets to load balance to.
+     *
+     * Can also be added by .addTarget()
+     *
+     * @default - None.
+     */
+    readonly targets?: ILoadBalancerTarget[];
+    /**
+     * Health check settings for the load balancing targets.
+     *
+     * Not required but recommended.
+     *
+     * @default - None.
+     */
+    readonly healthCheck?: HealthCheck;
+    /**
+     * Whether cross zone load balancing is enabled
+     *
+     * This controls whether the load balancer evenly distributes requests
+     * across each availability zone
+     *
+     * @default true
+     */
+    readonly crossZone?: boolean;
+    /**
+     * Which subnets to deploy the load balancer
+     *
+     * Can be used to define a specific set of subnets to deploy the load balancer to.
+     * Useful multiple public or private subnets are covering the same availability zone.
+     *
+     * @default - Public subnets if internetFacing, Private subnets otherwise
+     */
+    readonly subnetSelection?: SubnetSelection;
+    /**
+     * Enable Loadbalancer access logs
+     * Can be used to avoid manual work as aws console
+     * Required S3 bucket name , enabled flag
+     * Can add interval for pushing log
+     * Can set bucket prefix in order to provide folder name inside bucket
+     * @default - disabled
+     */
+    readonly accessLoggingPolicy?: CfnLoadBalancer.AccessLoggingPolicyProperty;
+}
+/**
+ * Describe the health check to a load balancer
+ */
+export interface HealthCheck {
+    /**
+     * What port number to health check on
+     */
+    readonly port: number;
+    /**
+     * What protocol to use for health checking
+     *
+     * The protocol is automatically determined from the port if it's not supplied.
+     *
+     * @default Automatic
+     */
+    readonly protocol?: LoadBalancingProtocol;
+    /**
+     * What path to use for HTTP or HTTPS health check (must return 200)
+     *
+     * For SSL and TCP health checks, accepting connections is enough to be considered
+     * healthy.
+     *
+     * @default "/"
+     */
+    readonly path?: string;
+    /**
+     * After how many successful checks is an instance considered healthy
+     *
+     * @default 2
+     */
+    readonly healthyThreshold?: number;
+    /**
+     * After how many unsuccessful checks is an instance considered unhealthy
+     *
+     * @default 5
+     */
+    readonly unhealthyThreshold?: number;
+    /**
+     * Number of seconds between health checks
+     *
+     * @default Duration.seconds(30)
+     */
+    readonly interval?: Duration;
+    /**
+     * Health check timeout
+     *
+     * @default Duration.seconds(5)
+     */
+    readonly timeout?: Duration;
+}
+/**
+ * Interface that is going to be implemented by constructs that you can load balance to
+ */
+export interface ILoadBalancerTarget extends IConnectable {
+    /**
+     * Attach load-balanced target to a classic ELB
+     * @param loadBalancer [disable-awslint:ref-via-interface] The load balancer to attach the target to
+     */
+    attachToClassicLB(loadBalancer: LoadBalancer): void;
+}
+/**
+ * Add a backend to the load balancer
+ */
+export interface LoadBalancerListener {
+    /**
+     * External listening port
+     */
+    readonly externalPort: number;
+    /**
+     * What public protocol to use for load balancing
+     *
+     * Either 'tcp', 'ssl', 'http' or 'https'.
+     *
+     * May be omitted if the external port is either 80 or 443.
+     */
+    readonly externalProtocol?: LoadBalancingProtocol;
+    /**
+     * Instance listening port
+     *
+     * Same as the externalPort if not specified.
+     *
+     * @default externalPort
+     */
+    readonly internalPort?: number;
+    /**
+     * What public protocol to use for load balancing
+     *
+     * Either 'tcp', 'ssl', 'http' or 'https'.
+     *
+     * May be omitted if the internal port is either 80 or 443.
+     *
+     * The instance protocol is 'tcp' if the front-end protocol
+     * is 'tcp' or 'ssl', the instance protocol is 'http' if the
+     * front-end protocol is 'https'.
+     */
+    readonly internalProtocol?: LoadBalancingProtocol;
+    /**
+     * SSL policy names
+     */
+    readonly policyNames?: string[];
+    /**
+     * the ARN of the SSL certificate
+     *
+     * @default - none
+     */
+    readonly sslCertificateArn?: string;
+    /**
+     * Allow connections to the load balancer from the given set of connection peers
+     *
+     * By default, connections will be allowed from anywhere. Set this to an empty list
+     * to deny connections, or supply a custom list of peers to allow connections from
+     * (IP ranges or security groups).
+     *
+     * @default Anywhere
+     */
+    readonly allowConnectionsFrom?: IConnectable[];
+}
+export declare enum LoadBalancingProtocol {
+    TCP = "tcp",
+    SSL = "ssl",
+    HTTP = "http",
+    HTTPS = "https"
+}
+/**
+ * A load balancer with a single listener
+ *
+ * Routes to a fleet of instances in a VPC.
+ */
+export declare class LoadBalancer extends Resource implements ILoadBalancer, IConnectable {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Control all connections from and to this load balancer
+     */
+    readonly connections: Connections;
+    /**
+     * An object controlling specifically the connections for each listener added to this load balancer
+     */
+    readonly listenerPorts: ListenerPort[];
+    private readonly elb;
+    private readonly securityGroup;
+    private readonly _listeners;
+    private readonly instancePorts;
+    private readonly targets;
+    private readonly _instanceIds;
+    constructor(scope: Construct, id: string, props: LoadBalancerProps);
+    /**
+     * Add a backend to the load balancer
+     *
+     * @returns A ListenerPort object that controls connections to the listener port
+     */
+    addListener(listener: LoadBalancerListener): ListenerPort;
+    addTarget(target: ILoadBalancerTarget): void;
+    /**
+     * @attribute
+     */
+    get loadBalancerName(): string;
+    /**
+     * @attribute
+     */
+    get loadBalancerCanonicalHostedZoneNameId(): string;
+    /**
+     * @attribute
+     */
+    get loadBalancerCanonicalHostedZoneName(): string;
+    /**
+     * @attribute
+     */
+    get loadBalancerDnsName(): string;
+    /**
+     * @attribute
+     */
+    get loadBalancerSourceSecurityGroupGroupName(): string;
+    /**
+     * @attribute
+     */
+    get loadBalancerSourceSecurityGroupOwnerAlias(): string;
+    /**
+     * A reference to this LoadBalancer resource
+     */
+    get loadBalancerRef(): aws_elasticloadbalancing.LoadBalancerReference;
+    /**
+     * Allow connections to all existing targets on new instance port
+     */
+    private newInstancePort;
+    /**
+     * Allow connections to target on all existing instance ports
+     */
+    private newTarget;
+    /**
+     * Allow connections for a single (port, target) pair
+     */
+    private allowTargetConnection;
+    /**
+     * Add instance to the load balancer.
+     * @internal
+     */
+    _addInstanceId(instanceId: string): void;
+}
+/**
+ * An EC2 instance that is the target for load balancing
+ */
+export declare class InstanceTarget implements ILoadBalancerTarget {
+    readonly instance: Instance;
+    readonly connections: Connections;
+    /**
+     * Create a new Instance target.
+     *
+     * @param instance Instance to register to.
+     */
+    constructor(instance: Instance);
+    attachToClassicLB(loadBalancer: LoadBalancer): void;
+}
+/**
+ * Reference to a listener's port just created.
+ *
+ * This implements IConnectable with a default port (the port that an ELB
+ * listener was just created on) for a given security group so that it can be
+ * conveniently used just like any Connectable. E.g:
+ *
+ *    const listener = elb.addListener(...);
+ *
+ *    listener.connections.allowDefaultPortFromAnyIPv4();
+ *    // or
+ *    instance.connections.allowToDefaultPort(listener);
+ */
+export declare class ListenerPort implements IConnectable {
+    readonly connections: Connections;
+    constructor(securityGroup: ISecurityGroup, defaultPort: Port);
+}