terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/activity.js

@@ -8,6 +8,7 @@ const cdktf_1 = require("cdktf");
 // import { CustomerManagedEncryptionConfiguration } from "./customer-managed-key-encryption-configuration";
 // import { EncryptionConfiguration } from "./encryption-configuration";
 // import { buildEncryptionConfiguration } from "./private/util";
+// import { StatesMetrics } from "./stepfunctions-canned-metrics.generated";
 const arn_1 = require("../arn");
 const aws_construct_1 = require("../aws-construct");
 const aws_stack_1 = require("../aws-stack");
@@ -128,5 +129,5 @@ class Activity extends aws_construct_1.AwsConstructBase {
 }
 exports.Activity = Activity;
 _a = JSII_RTTI_SYMBOL_1;
-Activity[_a] = { fqn: "terraconstructs.aws.compute.Activity", version: "0.0.10" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../../src/aws/compute/activity.ts"],"names":[],"mappings":"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","sourcesContent":["import { sfnActivity } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\n// import { CustomerManagedEncryptionConfiguration } from \"./customer-managed-key-encryption-configuration\";\n// import { EncryptionConfiguration } from \"./encryption-configuration\";\n// import { buildEncryptionConfiguration } from \"./private/util\";\nimport {\n  // Arn,\n  ArnFormat,\n} from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as iam from \"../iam\";\n\n/**\n * Properties for defining a new Step Functions Activity\n */\nexport interface ActivityProps extends AwsConstructProps {\n  /**\n   * The name for this activity.\n   *\n   * This name must be unique for your AWS account and region for 90 days.\n   * For more information, see [Limits Related to State Machine Executions][1] in the AWS Step Functions Developer Guide.\n   *\n   * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n   * Length Constraints: Minimum length of 1. Maximum length of 80.\n   *\n   * [1]: https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-state-machine-executions\n   *\n   * @default - If not supplied, a name is generated\n   */\n  readonly activityName?: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs.\n  //  *\n  //  * @default - data is transparently encrypted using an AWS owned key\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\nexport interface ActivityOutputs {\n  /**\n   * The Amazon Resource Name (ARN) that identifies the created activity.\n   */\n  readonly arn: string;\n}\n\n/**\n * Represents a Step Functions Activity\n * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html\n */\nexport interface IActivity extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly activityOutputs: ActivityOutputs;\n\n  /**\n   * The ARN of the activity\n   *\n   * @attribute\n   */\n  readonly activityArn: string;\n\n  /**\n   * The name of the activity\n   *\n   * @attribute\n   */\n  readonly activityName: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs\n  //  *\n  //  * @attribute\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\n/**\n * Define a new Step Functions Activity\n */\nexport class Activity extends AwsConstructBase implements IActivity {\n  /**\n   * Construct an Activity from an existing Activity ARN\n   */\n  public static fromActivityArn(\n    scope: Construct,\n    id: string,\n    activityArn: string,\n  ): IActivity {\n    class Imported extends AwsConstructBase implements IActivity {\n      public get activityOutputs(): ActivityOutputs {\n        return {\n          arn: this.activityArn,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.activityOutputs;\n      }\n      public get activityArn() {\n        return activityArn;\n      }\n      public get activityName() {\n        return (\n          this.stack.splitArn(activityArn, ArnFormat.COLON_RESOURCE_NAME)\n            .resourceName || \"\"\n        );\n      }\n    }\n\n    return new Imported(scope, id);\n  }\n\n  /**\n   * Construct an Activity from an existing Activity Name\n   */\n  public static fromActivityName(\n    scope: Construct,\n    id: string,\n    activityName: string,\n  ): IActivity {\n    return Activity.fromActivityArn(\n      scope,\n      id,\n      AwsStack.ofAwsConstruct(scope).formatArn({\n        service: \"states\",\n        resource: \"activity\",\n        resourceName: activityName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n    );\n  }\n\n  public get activityOutputs(): ActivityOutputs {\n    return {\n      arn: this.activityArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.activityOutputs;\n  }\n  public readonly resource: sfnActivity.SfnActivity;\n\n  /**\n   * @attribute\n   */\n  public readonly activityArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly activityName: string;\n\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly encryptionConfiguration?: EncryptionConfiguration;\n\n  constructor(scope: Construct, id: string, props: ActivityProps = {}) {\n    super(scope, id, props);\n\n    /**\n     * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n     * Length Constraints: Minimum length of 1. Maximum length of 80.\n     */\n    const resourceName =\n      props.activityName ||\n      Lazy.stringValue({\n        produce: () =>\n          this.stack.uniqueResourceName(this, {\n            prefix: this.gridUUID + \"-\",\n            maxLength: 80,\n            allowedSpecialCharacters: \"-_\",\n          }),\n      });\n\n    // this.encryptionConfiguration = props.encryptionConfiguration;\n    // if (\n    //   props.encryptionConfiguration instanceof\n    //   CustomerManagedEncryptionConfiguration\n    // ) {\n    //   props.encryptionConfiguration.kmsKey.addToResourcePolicy(\n    //     new iam.PolicyStatement({\n    //       resources: [\"*\"],\n    //       actions: [\"kms:Decrypt\", \"kms:GenerateDataKey\"],\n    //       principals: [new iam.ServicePrincipal(\"states.amazonaws.com\")],\n    //       condition: [\n    //         {\n    //           test: \"StringEquals\",\n    //           variable: \"kms:EncryptionContext:aws:states:activityArn\",\n    //           values: [\n    //             this.stack.formatArn({\n    //               service: \"states\",\n    //               resource: \"activity\",\n    //               sep: \":\",\n    //               resourceName,\n    //             }),\n    //           ],\n    //         },\n    //       ],\n    //     }),\n    //   );\n    // }\n\n    this.resource = new sfnActivity.SfnActivity(this, \"Resource\", {\n      name: resourceName,\n      // encryptionConfiguration: buildEncryptionConfiguration(\n      //   props.encryptionConfiguration,\n      // ),\n    });\n\n    this.activityArn = this.resource.id;\n    this.activityName = this.resource.name;\n  }\n\n  /**\n   * Grant the given identity permissions on this Activity\n   *\n   * @param identity The principal\n   * @param actions The list of desired actions\n   */\n  public grant(identity: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions,\n      resourceArns: [this.activityArn],\n    });\n  }\n}\n"]}
+Activity[_a] = { fqn: "terraconstructs.aws.compute.Activity", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../../src/aws/compute/activity.ts"],"names":[],"mappings":"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","sourcesContent":["import { sfnActivity } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\n// import { CustomerManagedEncryptionConfiguration } from \"./customer-managed-key-encryption-configuration\";\n// import { EncryptionConfiguration } from \"./encryption-configuration\";\n// import { buildEncryptionConfiguration } from \"./private/util\";\n// import { StatesMetrics } from \"./stepfunctions-canned-metrics.generated\";\nimport {\n  // Arn,\n  ArnFormat,\n} from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as iam from \"../iam\";\n\n/**\n * Properties for defining a new Step Functions Activity\n */\nexport interface ActivityProps extends AwsConstructProps {\n  /**\n   * The name for this activity.\n   *\n   * This name must be unique for your AWS account and region for 90 days.\n   * For more information, see [Limits Related to State Machine Executions][1] in the AWS Step Functions Developer Guide.\n   *\n   * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n   * Length Constraints: Minimum length of 1. Maximum length of 80.\n   *\n   * [1]: https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-state-machine-executions\n   *\n   * @default - If not supplied, a name is generated\n   */\n  readonly activityName?: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs.\n  //  *\n  //  * @default - data is transparently encrypted using an AWS owned key\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\nexport interface ActivityOutputs {\n  /**\n   * The Amazon Resource Name (ARN) that identifies the created activity.\n   */\n  readonly arn: string;\n}\n\n/**\n * Represents a Step Functions Activity\n * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html\n */\nexport interface IActivity extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly activityOutputs: ActivityOutputs;\n\n  /**\n   * The ARN of the activity\n   *\n   * @attribute\n   */\n  readonly activityArn: string;\n\n  /**\n   * The name of the activity\n   *\n   * @attribute\n   */\n  readonly activityName: string;\n\n  // /**\n  //  * The encryptionConfiguration object used for server-side encryption of the activity inputs\n  //  *\n  //  * @attribute\n  //  */\n  // readonly encryptionConfiguration?: EncryptionConfiguration;\n}\n\n/**\n * Define a new Step Functions Activity\n */\nexport class Activity extends AwsConstructBase implements IActivity {\n  /**\n   * Construct an Activity from an existing Activity ARN\n   */\n  public static fromActivityArn(\n    scope: Construct,\n    id: string,\n    activityArn: string,\n  ): IActivity {\n    class Imported extends AwsConstructBase implements IActivity {\n      public get activityOutputs(): ActivityOutputs {\n        return {\n          arn: this.activityArn,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.activityOutputs;\n      }\n      public get activityArn() {\n        return activityArn;\n      }\n      public get activityName() {\n        return (\n          this.stack.splitArn(activityArn, ArnFormat.COLON_RESOURCE_NAME)\n            .resourceName || \"\"\n        );\n      }\n    }\n\n    return new Imported(scope, id);\n  }\n\n  /**\n   * Construct an Activity from an existing Activity Name\n   */\n  public static fromActivityName(\n    scope: Construct,\n    id: string,\n    activityName: string,\n  ): IActivity {\n    return Activity.fromActivityArn(\n      scope,\n      id,\n      AwsStack.ofAwsConstruct(scope).formatArn({\n        service: \"states\",\n        resource: \"activity\",\n        resourceName: activityName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n    );\n  }\n\n  public get activityOutputs(): ActivityOutputs {\n    return {\n      arn: this.activityArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.activityOutputs;\n  }\n  public readonly resource: sfnActivity.SfnActivity;\n\n  /**\n   * @attribute\n   */\n  public readonly activityArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly activityName: string;\n\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly encryptionConfiguration?: EncryptionConfiguration;\n\n  constructor(scope: Construct, id: string, props: ActivityProps = {}) {\n    super(scope, id, props);\n\n    /**\n     * To enable logging with CloudWatch Logs, the name should only contain 0-9, A-Z, a-z, - and _.\n     * Length Constraints: Minimum length of 1. Maximum length of 80.\n     */\n    const resourceName =\n      props.activityName ||\n      Lazy.stringValue({\n        produce: () =>\n          this.stack.uniqueResourceName(this, {\n            prefix: this.gridUUID + \"-\",\n            maxLength: 80,\n            allowedSpecialCharacters: \"-_\",\n          }),\n      });\n\n    // this.encryptionConfiguration = props.encryptionConfiguration;\n    // if (\n    //   props.encryptionConfiguration instanceof\n    //   CustomerManagedEncryptionConfiguration\n    // ) {\n    //   props.encryptionConfiguration.kmsKey.addToResourcePolicy(\n    //     new iam.PolicyStatement({\n    //       resources: [\"*\"],\n    //       actions: [\"kms:Decrypt\", \"kms:GenerateDataKey\"],\n    //       principals: [new iam.ServicePrincipal(\"states.amazonaws.com\")],\n    //       condition: [\n    //         {\n    //           test: \"StringEquals\",\n    //           variable: \"kms:EncryptionContext:aws:states:activityArn\",\n    //           values: [\n    //             this.stack.formatArn({\n    //               service: \"states\",\n    //               resource: \"activity\",\n    //               sep: \":\",\n    //               resourceName,\n    //             }),\n    //           ],\n    //         },\n    //       ],\n    //     }),\n    //   );\n    // }\n\n    this.resource = new sfnActivity.SfnActivity(this, \"Resource\", {\n      name: resourceName,\n      // encryptionConfiguration: buildEncryptionConfiguration(\n      //   props.encryptionConfiguration,\n      // ),\n    });\n\n    this.activityArn = this.resource.id;\n    this.activityName = this.resource.name;\n  }\n\n  /**\n   * Grant the given identity permissions on this Activity\n   *\n   * @param identity The principal\n   * @param actions The list of desired actions\n   */\n  public grant(identity: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipal({\n      grantee: identity,\n      actions,\n      resourceArns: [this.activityArn],\n    });\n  }\n}\n"]}

package/lib/aws/compute/alb/application-listener-action.d.ts

@@ -0,0 +1,334 @@
+import { lbListener as tfListener, lbListenerRule as tfListenerRule } from "@cdktf/provider-aws";
+import { Construct, IConstruct } from "constructs";
+import { IApplicationListener } from "./application-listener";
+import { IApplicationTargetGroup } from "./application-target-group";
+import { Duration } from "../../../duration";
+import { IListenerAction } from "../lb-shared/listener-action";
+/**
+ * What to do when a client makes a request to a listener
+ *
+ * Some actions can be combined with other ones (specifically,
+ * you can perform authentication before serving the request).
+ *
+ * Multiple actions form a linked chain; the chain must always terminate in a
+ * *(weighted)forward*, *fixedResponse* or *redirect* action.
+ *
+ * If an action supports chaining, the next action can be indicated
+ * by passing it in the `next` property.
+ *
+ * (Called `ListenerAction` instead of the more strictly correct
+ * `ListenerAction` because this is the class most users interact
+ * with, and we want to make it not too visually overwhelming).
+ */
+export declare class ListenerAction implements IListenerAction {
+    private readonly defaultActionJson;
+    protected readonly next?: ListenerAction | undefined;
+    /**
+     * Authenticate using an identity provider (IdP) that is compliant with OpenID Connect (OIDC)
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/listener-authenticate-users.html#oidc-requirements
+     */
+    static authenticateOidc(options: AuthenticateOidcOptions): ListenerAction;
+    /**
+     * Forward to one or more Target Groups
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions
+     */
+    static forward(targetGroups: IApplicationTargetGroup[], options?: ForwardOptions): ListenerAction;
+    /**
+     * Forward to one or more Target Groups which are weighted differently
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions
+     */
+    static weightedForward(targetGroups: WeightedTargetGroup[], options?: ForwardOptions): ListenerAction;
+    /**
+     * Return a fixed response
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#fixed-response-actions
+     */
+    static fixedResponse(statusCode: number, options?: FixedResponseOptions): ListenerAction;
+    /**
+     * Redirect to a different URI
+     *
+     * A URI consists of the following components:
+     * protocol://hostname:port/path?query. You must modify at least one of the
+     * following components to avoid a redirect loop: protocol, hostname, port, or
+     * path. Any components that you do not modify retain their original values.
+     *
+     * You can reuse URI components using the following reserved keywords:
+     *
+     * - `#{protocol}`
+     * - `#{host}`
+     * - `#{port}`
+     * - `#{path}` (the leading "/" is removed)
+     * - `#{query}`
+     *
+     * For example, you can change the path to "/new/#{path}", the hostname to
+     * "example.#{host}", or the query to "#{query}&value=xyz".
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#redirect-actions
+     */
+    static redirect(options: RedirectOptions): ListenerAction;
+    /**
+     * If set, it is preferred as Action for the `ListenerRule`.
+     * This is necessary if `CfnListener.ActionProperty` and `CfnListenerRule.ActionProperty`
+     * have different structures.
+     */
+    private _actionJson?;
+    /**
+     * Create an instance of ListenerAction
+     *
+     * The default class should be good enough for most cases and
+     * should be created by using one of the static factory functions,
+     * but allow overriding to make sure we allow flexibility for the future.
+     */
+    protected constructor(defaultActionJson: tfListener.LbListenerDefaultAction, next?: ListenerAction | undefined);
+    /**
+     * Render the listener rule actions in this chain
+     */
+    renderRuleActions(): tfListenerRule.LbListenerRuleAction[];
+    /**
+     * Render the listener default actions in this chain
+     */
+    renderActions(): tfListener.LbListenerDefaultAction[];
+    /**
+     * Called when the action is being used in a listener
+     */
+    bind(scope: Construct, listener: IApplicationListener, associatingConstruct?: IConstruct): void;
+    private _renumber;
+    /**
+     * Renumber the "order" fields in the actions array.
+     *
+     * We don't number for 0 or 1 elements, but otherwise number them 1...#actions
+     * so ELB knows about the right order.
+     *
+     * Do this in `ListenerAction` instead of in `Listener` so that we give
+     * users the opportunity to override by subclassing and overriding `renderActions`.
+     */
+    protected renumber(actions: tfListener.LbListenerDefaultAction[]): tfListener.LbListenerDefaultAction[];
+    /**
+     * Sets the Action for the `ListenerRule`.
+     * This method is required to set a dedicated Action to a `ListenerRule`
+     * when the Action for the `CfnListener` and the Action for the `CfnListenerRule`
+     * have different structures. (e.g. `AuthenticateOidcConfig`)
+     * @param actionJson Action for `ListenerRule`
+     */
+    protected addRuleAction(actionJson: tfListenerRule.LbListenerRuleAction): void;
+}
+/**
+ * Options for `ListenerAction.forward()`
+ */
+export interface ForwardOptions {
+    /**
+     * For how long clients should be directed to the same target group
+     *
+     * Range between 1 second and 7 days.
+     *
+     * @default - No stickiness
+     */
+    readonly stickinessDuration?: Duration;
+}
+/**
+ * A Target Group and weight combination
+ */
+export interface WeightedTargetGroup {
+    /**
+     * The target group
+     */
+    readonly targetGroup: IApplicationTargetGroup;
+    /**
+     * The target group's weight
+     *
+     * Range is [0..1000).
+     *
+     * @default 1
+     */
+    readonly weight?: number;
+}
+/**
+ * Options for `ListenerAction.fixedResponse()`
+ */
+export interface FixedResponseOptions {
+    /**
+     * Content Type of the response
+     *
+     * Valid Values: text/plain | text/css | text/html | application/javascript | application/json
+     */
+    readonly contentType?: string;
+    /**
+     * The response body
+     *
+     * @default - No body
+     */
+    readonly messageBody?: string;
+}
+/**
+ * Options for `ListenerAction.redirect()`
+ *
+ * A URI consists of the following components:
+ * protocol://hostname:port/path?query. You must modify at least one of the
+ * following components to avoid a redirect loop: protocol, hostname, port, or
+ * path. Any components that you do not modify retain their original values.
+ *
+ * You can reuse URI components using the following reserved keywords:
+ *
+ * - `#{protocol}`
+ * - `#{host}`
+ * - `#{port}`
+ * - `#{path}` (the leading "/" is removed)
+ * - `#{query}`
+ *
+ * For example, you can change the path to "/new/#{path}", the hostname to
+ * "example.#{host}", or the query to "#{query}&value=xyz".
+ */
+export interface RedirectOptions {
+    /**
+     * The hostname.
+     *
+     * This component is not percent-encoded. The hostname can contain #{host}.
+     *
+     * @default - No change
+     */
+    readonly host?: string;
+    /**
+     * The absolute path, starting with the leading "/".
+     *
+     * This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.
+     *
+     * @default - No change
+     */
+    readonly path?: string;
+    /**
+     * The port.
+     *
+     * You can specify a value from 1 to 65535 or #{port}.
+     *
+     * @default - No change
+     */
+    readonly port?: string;
+    /**
+     * The protocol.
+     *
+     * You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP, HTTP to HTTPS, and HTTPS to HTTPS. You cannot redirect HTTPS to HTTP.
+     *
+     * @default - No change
+     */
+    readonly protocol?: string;
+    /**
+     * The query parameters, URL-encoded when necessary, but not percent-encoded.
+     *
+     * Do not include the leading "?", as it is automatically added. You can specify any of the reserved keywords.
+     *
+     * @default - No change
+     */
+    readonly query?: string;
+    /**
+     * The HTTP redirect code.
+     *
+     * The redirect is either permanent (HTTP 301) or temporary (HTTP 302).
+     *
+     * @default false
+     */
+    readonly permanent?: boolean;
+}
+/**
+ * Options for `ListenerAction.authenciateOidc()`
+ */
+export interface AuthenticateOidcOptions {
+    /**
+     * What action to execute next
+     */
+    readonly next: ListenerAction;
+    /**
+     * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.
+     *
+     * @default - No extra parameters
+     */
+    readonly authenticationRequestExtraParams?: Record<string, string>;
+    /**
+     * The authorization endpoint of the IdP.
+     *
+     * This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    readonly authorizationEndpoint: string;
+    /**
+     * The OAuth 2.0 client identifier.
+     */
+    readonly clientId: string;
+    /**
+     * The OAuth 2.0 client secret.
+     */
+    readonly clientSecret: string;
+    /**
+     * The OIDC issuer identifier of the IdP.
+     *
+     * This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    readonly issuer: string;
+    /**
+     * The behavior if the user is not authenticated.
+     *
+     * @default UnauthenticatedAction.AUTHENTICATE
+     */
+    readonly onUnauthenticatedRequest?: UnauthenticatedAction;
+    /**
+     * The set of user claims to be requested from the IdP.
+     *
+     * To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.
+     *
+     * @default "openid"
+     */
+    readonly scope?: string;
+    /**
+     * The name of the cookie used to maintain session information.
+     *
+     * @default "AWSELBAuthSessionCookie"
+     */
+    readonly sessionCookieName?: string;
+    /**
+     * The maximum duration of the authentication session.
+     *
+     * @default Duration.days(7)
+     */
+    readonly sessionTimeout?: Duration;
+    /**
+     * The token endpoint of the IdP.
+     *
+     * This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    readonly tokenEndpoint: string;
+    /**
+     * The user info endpoint of the IdP.
+     *
+     * This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    readonly userInfoEndpoint: string;
+    /**
+     * Allow HTTPS outbound traffic to communicate with the IdP.
+     *
+     * Set this property to false if the IP address used for the IdP endpoint is identifiable
+     * and you want to control outbound traffic.
+     * Then allow HTTPS outbound traffic to the IdP's IP address using the listener's `connections` property.
+     *
+     * @default true
+     * @see https://repost.aws/knowledge-center/elb-configure-authentication-alb
+     */
+    readonly allowHttpsOutbound?: boolean;
+}
+/**
+ * What to do with unauthenticated requests
+ */
+export declare enum UnauthenticatedAction {
+    /**
+     * Return an HTTP 401 Unauthorized error.
+     */
+    DENY = "deny",
+    /**
+     * Allow the request to be forwarded to the target.
+     */
+    ALLOW = "allow",
+    /**
+     * Redirect the request to the IdP authorization endpoint.
+     */
+    AUTHENTICATE = "authenticate"
+}