@horietakehiro/aws-cdk-utul 0.1.1

package/src/types/cfn-resource-types/aws-elasticloadbalancing-loadbalancer.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Resource Type definition for AWS::ElasticLoadBalancing::LoadBalancer
+ */
+export interface _AWS_ELASTICLOADBALANCING_LOADBALANCER {
+    SecurityGroups?: string[];
+    ConnectionDrainingPolicy?: ConnectionDrainingPolicy;
+    Policies?: Policies[];
+    Scheme?: string;
+    AvailabilityZones?: string[];
+    SourceSecurityGroupOwnerAlias?: string;
+    HealthCheck?: HealthCheck;
+    CanonicalHostedZoneNameID?: string;
+    CanonicalHostedZoneName?: string;
+    DNSName?: string;
+    AccessLoggingPolicy?: AccessLoggingPolicy;
+    Instances?: string[];
+    LoadBalancerName?: string;
+    Listeners: Listeners[];
+    Subnets?: string[];
+    CrossZone?: boolean;
+    AppCookieStickinessPolicy?: AppCookieStickinessPolicy[];
+    LBCookieStickinessPolicy?: LBCookieStickinessPolicy[];
+    Id?: string;
+    SourceSecurityGroupGroupName?: string;
+    ConnectionSettings?: ConnectionSettings;
+    Tags?: Tag[];
+}
+export interface ConnectionDrainingPolicy {
+    Enabled: boolean;
+    Timeout?: number;
+}
+export interface Policies {
+    Attributes: {
+        [k: string]: unknown;
+    }[];
+    PolicyType: string;
+    LoadBalancerPorts?: string[];
+    PolicyName: string;
+    InstancePorts?: string[];
+}
+export interface HealthCheck {
+    Target: string;
+    UnhealthyThreshold: string;
+    Timeout: string;
+    HealthyThreshold: string;
+    Interval: string;
+}
+export interface AccessLoggingPolicy {
+    Enabled: boolean;
+    S3BucketName: string;
+    EmitInterval?: number;
+    S3BucketPrefix?: string;
+}
+export interface Listeners {
+    PolicyNames?: string[];
+    InstancePort: string;
+    LoadBalancerPort: string;
+    Protocol: string;
+    SSLCertificateId?: string;
+    InstanceProtocol?: string;
+}
+export interface AppCookieStickinessPolicy {
+    CookieName: string;
+    PolicyName: string;
+}
+export interface LBCookieStickinessPolicy {
+    CookieExpirationPeriod?: string;
+    PolicyName?: string;
+}
+export interface ConnectionSettings {
+    IdleTimeout: number;
+}
+export interface Tag {
+    Value: string;
+    Key: string;
+}

package/src/types/cfn-resource-types/aws-elasticloadbalancing-loadbalancer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/src/types/cfn-resource-types/aws-elasticloadbalancingv2-listener.d.ts

@@ -0,0 +1,289 @@
+/**
+ * Specifies a listener for an Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.
+ */
+export interface _AWS_ELASTICLOADBALANCINGV2_LISTENER {
+    ListenerArn?: string;
+    MutualAuthentication?: MutualAuthentication;
+    ListenerAttributes?: ListenerAttribute[];
+    /**
+     * [TLS listener] The name of the Application-Layer Protocol Negotiation (ALPN) policy.
+     */
+    AlpnPolicy?: string[];
+    /**
+     * [HTTPS and TLS listeners] The security policy that defines which protocols and ciphers are supported.
+     *  Updating the security policy can result in interruptions if the load balancer is handling a high volume of traffic.
+     *  For more information, see [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) in the *Application Load Balancers Guide* and [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies) in the *Network Load Balancers Guide*.
+     */
+    SslPolicy?: string;
+    /**
+     * The Amazon Resource Name (ARN) of the load balancer.
+     */
+    LoadBalancerArn: string;
+    /**
+     * The actions for the default rule. You cannot define a condition for a default rule.
+     *  To create additional rules for an Application Load Balancer, use [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listenerrule.html).
+     */
+    DefaultActions: Action[];
+    /**
+     * The port on which the load balancer is listening. You cannot specify a port for a Gateway Load Balancer.
+     */
+    Port?: number;
+    /**
+     * The default SSL server certificate for a secure listener. You must provide exactly one certificate if the listener protocol is HTTPS or TLS.
+     *  To create a certificate list for a secure listener, use [AWS::ElasticLoadBalancingV2::ListenerCertificate](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listenercertificate.html).
+     */
+    Certificates?: Certificate[];
+    /**
+     * The protocol for connections from clients to the load balancer. For Application Load Balancers, the supported protocols are HTTP and HTTPS. For Network Load Balancers, the supported protocols are TCP, TLS, UDP, and TCP_UDP. You can’t specify the UDP or TCP_UDP protocol if dual-stack mode is enabled. You cannot specify a protocol for a Gateway Load Balancer.
+     */
+    Protocol?: string;
+}
+/**
+ * The mutual authentication configuration information.
+ */
+export interface MutualAuthentication {
+    /**
+     * Indicates whether expired client certificates are ignored.
+     */
+    IgnoreClientCertificateExpiry?: boolean;
+    /**
+     * The client certificate handling method. Options are ``off``, ``passthrough`` or ``verify``. The default value is ``off``.
+     */
+    Mode?: string;
+    /**
+     * The Amazon Resource Name (ARN) of the trust store.
+     */
+    TrustStoreArn?: string;
+}
+export interface ListenerAttribute {
+    Value?: string;
+    Key?: string;
+}
+/**
+ * Specifies an action for a listener rule.
+ */
+export interface Action {
+    /**
+     * The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.
+     */
+    Order?: number;
+    /**
+     * The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.
+     */
+    TargetGroupArn?: string;
+    FixedResponseConfig?: FixedResponseConfig;
+    AuthenticateCognitoConfig?: AuthenticateCognitoConfig;
+    /**
+     * The type of action.
+     */
+    Type: string;
+    RedirectConfig?: RedirectConfig;
+    ForwardConfig?: ForwardConfig;
+    AuthenticateOidcConfig?: AuthenticateOidcConfig;
+}
+/**
+ * [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.
+ */
+export interface FixedResponseConfig {
+    /**
+     * The content type.
+     *  Valid Values: text/plain | text/css | text/html | application/javascript | application/json
+     */
+    ContentType?: string;
+    /**
+     * The HTTP response code (2XX, 4XX, or 5XX).
+     */
+    StatusCode: string;
+    /**
+     * The message.
+     */
+    MessageBody?: string;
+}
+/**
+ * [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.
+ */
+export interface AuthenticateCognitoConfig {
+    /**
+     * The behavior if the user is not authenticated. The following are possible values:
+     *   +  deny```` - Return an HTTP 401 Unauthorized error.
+     *   +  allow```` - Allow the request to be forwarded to the target.
+     *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.
+     */
+    OnUnauthenticatedRequest?: string;
+    /**
+     * The ID of the Amazon Cognito user pool client.
+     */
+    UserPoolClientId: ({
+        [k: string]: unknown;
+    } & string);
+    /**
+     * The domain prefix or fully-qualified domain name of the Amazon Cognito user pool.
+     */
+    UserPoolDomain: string;
+    /**
+     * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).
+     */
+    SessionTimeout?: string;
+    /**
+     * The set of user claims to be requested from the IdP. The default is ``openid``.
+     *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.
+     */
+    Scope?: string;
+    /**
+     * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.
+     */
+    SessionCookieName?: string;
+    /**
+     * The Amazon Resource Name (ARN) of the Amazon Cognito user pool.
+     */
+    UserPoolArn: string;
+    /**
+     * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.
+     */
+    AuthenticationRequestExtraParams?: {
+        /**
+         * This interface was referenced by `undefined`'s JSON-Schema definition
+         * via the `patternProperty` "[a-zA-Z0-9]+".
+         */
+        [k: string]: string;
+    };
+}
+/**
+ * [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.
+ */
+export interface RedirectConfig {
+    /**
+     * The absolute path, starting with the leading "/". This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.
+     */
+    Path?: 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.
+     */
+    Query?: string;
+    /**
+     * The port. You can specify a value from 1 to 65535 or #{port}.
+     */
+    Port?: string;
+    /**
+     * The hostname. This component is not percent-encoded. The hostname can contain #{host}.
+     */
+    Host?: 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.
+     */
+    Protocol?: string;
+    /**
+     * The HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary (HTTP 302).
+     */
+    StatusCode: string;
+}
+/**
+ * Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+ */
+export interface ForwardConfig {
+    TargetGroupStickinessConfig?: TargetGroupStickinessConfig;
+    /**
+     * Information about how traffic will be distributed between multiple target groups in a forward rule.
+     */
+    TargetGroups?: TargetGroupTuple[];
+}
+/**
+ * Information about the target group stickiness for a rule.
+ */
+export interface TargetGroupStickinessConfig {
+    /**
+     * Indicates whether target group stickiness is enabled.
+     */
+    Enabled?: boolean;
+    /**
+     * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days).
+     */
+    DurationSeconds?: number;
+}
+/**
+ * Information about how traffic will be distributed between multiple target groups in a forward rule.
+ */
+export interface TargetGroupTuple {
+    /**
+     * The Amazon Resource Name (ARN) of the target group.
+     */
+    TargetGroupArn?: string;
+    /**
+     * The weight. The range is 0 to 999.
+     */
+    Weight?: number;
+}
+/**
+ * [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.
+ */
+export interface AuthenticateOidcConfig {
+    /**
+     * The behavior if the user is not authenticated. The following are possible values:
+     *   +  deny```` - Return an HTTP 401 Unauthorized error.
+     *   +  allow```` - Allow the request to be forwarded to the target.
+     *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.
+     */
+    OnUnauthenticatedRequest?: string;
+    /**
+     * The token endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    TokenEndpoint: string;
+    /**
+     * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.
+     */
+    UseExistingClientSecret?: boolean;
+    /**
+     * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).
+     */
+    SessionTimeout?: string;
+    /**
+     * The set of user claims to be requested from the IdP. The default is ``openid``.
+     *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.
+     */
+    Scope?: string;
+    /**
+     * The OIDC issuer identifier of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    Issuer: string;
+    /**
+     * The OAuth 2.0 client secret. This parameter is required if you are creating a rule. If you are modifying a rule, you can omit this parameter if you set ``UseExistingClientSecret`` to true.
+     */
+    ClientSecret?: string;
+    /**
+     * The user info endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    UserInfoEndpoint: string;
+    /**
+     * The OAuth 2.0 client identifier.
+     */
+    ClientId: string;
+    /**
+     * The authorization endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.
+     */
+    AuthorizationEndpoint: string;
+    /**
+     * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.
+     */
+    SessionCookieName?: string;
+    /**
+     * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.
+     */
+    AuthenticationRequestExtraParams?: {
+        /**
+         * This interface was referenced by `undefined`'s JSON-Schema definition
+         * via the `patternProperty` "[a-zA-Z0-9]+".
+         */
+        [k: string]: string;
+    };
+}
+/**
+ * Specifies an SSL server certificate to use as the default certificate for a secure listener.
+ */
+export interface Certificate {
+    /**
+     * The Amazon Resource Name (ARN) of the certificate.
+     */
+    CertificateArn?: ({
+        [k: string]: unknown;
+    } & string);
+}

package/src/types/cfn-resource-types/aws-elasticloadbalancingv2-listener.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-elasticloadbalancingv2-listener.js","sourceRoot":"","sources":["aws-elasticloadbalancingv2-listener.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Specifies a listener for an Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.\n */\nexport interface _AWS_ELASTICLOADBALANCINGV2_LISTENER {\nListenerArn?: string\nMutualAuthentication?: MutualAuthentication\nListenerAttributes?: ListenerAttribute[]\n/**\n * [TLS listener] The name of the Application-Layer Protocol Negotiation (ALPN) policy.\n */\nAlpnPolicy?: string[]\n/**\n * [HTTPS and TLS listeners] The security policy that defines which protocols and ciphers are supported.\n *  Updating the security policy can result in interruptions if the load balancer is handling a high volume of traffic.\n *  For more information, see [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) in the *Application Load Balancers Guide* and [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies) in the *Network Load Balancers Guide*.\n */\nSslPolicy?: string\n/**\n * The Amazon Resource Name (ARN) of the load balancer.\n */\nLoadBalancerArn: string\n/**\n * The actions for the default rule. You cannot define a condition for a default rule.\n *  To create additional rules for an Application Load Balancer, use [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listenerrule.html).\n */\nDefaultActions: Action[]\n/**\n * The port on which the load balancer is listening. You cannot specify a port for a Gateway Load Balancer.\n */\nPort?: number\n/**\n * The default SSL server certificate for a secure listener. You must provide exactly one certificate if the listener protocol is HTTPS or TLS.\n *  To create a certificate list for a secure listener, use [AWS::ElasticLoadBalancingV2::ListenerCertificate](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-listenercertificate.html).\n */\nCertificates?: Certificate[]\n/**\n * The protocol for connections from clients to the load balancer. For Application Load Balancers, the supported protocols are HTTP and HTTPS. For Network Load Balancers, the supported protocols are TCP, TLS, UDP, and TCP_UDP. You can’t specify the UDP or TCP_UDP protocol if dual-stack mode is enabled. You cannot specify a protocol for a Gateway Load Balancer.\n */\nProtocol?: string\n}\n/**\n * The mutual authentication configuration information.\n */\nexport interface MutualAuthentication {\n/**\n * Indicates whether expired client certificates are ignored.\n */\nIgnoreClientCertificateExpiry?: boolean\n/**\n * The client certificate handling method. Options are ``off``, ``passthrough`` or ``verify``. The default value is ``off``.\n */\nMode?: string\n/**\n * The Amazon Resource Name (ARN) of the trust store.\n */\nTrustStoreArn?: string\n}\nexport interface ListenerAttribute {\nValue?: string\nKey?: string\n}\n/**\n * Specifies an action for a listener rule.\n */\nexport interface Action {\n/**\n * The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.\n */\nOrder?: number\n/**\n * The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.\n */\nTargetGroupArn?: string\nFixedResponseConfig?: FixedResponseConfig\nAuthenticateCognitoConfig?: AuthenticateCognitoConfig\n/**\n * The type of action.\n */\nType: string\nRedirectConfig?: RedirectConfig\nForwardConfig?: ForwardConfig\nAuthenticateOidcConfig?: AuthenticateOidcConfig\n}\n/**\n * [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.\n */\nexport interface FixedResponseConfig {\n/**\n * The content type.\n *  Valid Values: text/plain | text/css | text/html | application/javascript | application/json\n */\nContentType?: string\n/**\n * The HTTP response code (2XX, 4XX, or 5XX).\n */\nStatusCode: string\n/**\n * The message.\n */\nMessageBody?: string\n}\n/**\n * [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.\n */\nexport interface AuthenticateCognitoConfig {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The ID of the Amazon Cognito user pool client.\n */\nUserPoolClientId: ({\n[k: string]: unknown\n} & string)\n/**\n * The domain prefix or fully-qualified domain name of the Amazon Cognito user pool.\n */\nUserPoolDomain: string\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: string\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * The Amazon Resource Name (ARN) of the Amazon Cognito user pool.\n */\nUserPoolArn: string\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n}\n/**\n * [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.\n */\nexport interface RedirectConfig {\n/**\n * The absolute path, starting with the leading \"/\". This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.\n */\nPath?: string\n/**\n * 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.\n */\nQuery?: string\n/**\n * The port. You can specify a value from 1 to 65535 or #{port}.\n */\nPort?: string\n/**\n * The hostname. This component is not percent-encoded. The hostname can contain #{host}.\n */\nHost?: string\n/**\n * 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.\n */\nProtocol?: string\n/**\n * The HTTP redirect code. The redirect is either permanent (HTTP 301) or temporary (HTTP 302).\n */\nStatusCode: string\n}\n/**\n * Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.\n */\nexport interface ForwardConfig {\nTargetGroupStickinessConfig?: TargetGroupStickinessConfig\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nTargetGroups?: TargetGroupTuple[]\n}\n/**\n * Information about the target group stickiness for a rule.\n */\nexport interface TargetGroupStickinessConfig {\n/**\n * Indicates whether target group stickiness is enabled.\n */\nEnabled?: boolean\n/**\n * The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days).\n */\nDurationSeconds?: number\n}\n/**\n * Information about how traffic will be distributed between multiple target groups in a forward rule.\n */\nexport interface TargetGroupTuple {\n/**\n * The Amazon Resource Name (ARN) of the target group.\n */\nTargetGroupArn?: string\n/**\n * The weight. The range is 0 to 999.\n */\nWeight?: number\n}\n/**\n * [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.\n */\nexport interface AuthenticateOidcConfig {\n/**\n * The behavior if the user is not authenticated. The following are possible values:\n *   +  deny```` - Return an HTTP 401 Unauthorized error.\n *   +  allow```` - Allow the request to be forwarded to the target.\n *   +  authenticate```` - Redirect the request to the IdP authorization endpoint. This is the default value.\n */\nOnUnauthenticatedRequest?: string\n/**\n * The token endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nTokenEndpoint: string\n/**\n * Indicates whether to use the existing client secret when modifying a rule. If you are creating a rule, you can omit this parameter or set it to false.\n */\nUseExistingClientSecret?: boolean\n/**\n * The maximum duration of the authentication session, in seconds. The default is 604800 seconds (7 days).\n */\nSessionTimeout?: string\n/**\n * The set of user claims to be requested from the IdP. The default is ``openid``.\n *  To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n */\nScope?: string\n/**\n * The OIDC issuer identifier of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nIssuer: string\n/**\n * The OAuth 2.0 client secret. This parameter is required if you are creating a rule. If you are modifying a rule, you can omit this parameter if you set ``UseExistingClientSecret`` to true.\n */\nClientSecret?: string\n/**\n * The user info endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nUserInfoEndpoint: string\n/**\n * The OAuth 2.0 client identifier.\n */\nClientId: string\n/**\n * The authorization endpoint of the IdP. This must be a full URL, including the HTTPS protocol, the domain, and the path.\n */\nAuthorizationEndpoint: string\n/**\n * The name of the cookie used to maintain session information. The default is AWSELBAuthSessionCookie.\n */\nSessionCookieName?: string\n/**\n * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n */\nAuthenticationRequestExtraParams?: {\n/**\n * This interface was referenced by `undefined`'s JSON-Schema definition\n * via the `patternProperty` \"[a-zA-Z0-9]+\".\n */\n[k: string]: string\n}\n}\n/**\n * Specifies an SSL server certificate to use as the default certificate for a secure listener.\n */\nexport interface Certificate {\n/**\n * The Amazon Resource Name (ARN) of the certificate.\n */\nCertificateArn?: ({\n[k: string]: unknown\n} & string)\n}\n"]}

package/src/types/cfn-resource-types/aws-elasticloadbalancingv2-listenercertificate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resource Type definition for AWS::ElasticLoadBalancingV2::ListenerCertificate
+ */
+export interface _AWS_ELASTICLOADBALANCINGV2_LISTENERCERTIFICATE {
+    ListenerArn: string;
+    Certificates: Certificate[];
+    Id?: string;
+}
+export interface Certificate {
+    CertificateArn?: string;
+}

package/src/types/cfn-resource-types/aws-elasticloadbalancingv2-listenercertificate.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWVsYXN0aWNsb2FkYmFsYW5jaW5ndjItbGlzdGVuZXJjZXJ0aWZpY2F0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImF3cy1lbGFzdGljbG9hZGJhbGFuY2luZ3YyLWxpc3RlbmVyY2VydGlmaWNhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVzb3VyY2UgVHlwZSBkZWZpbml0aW9uIGZvciBBV1M6OkVsYXN0aWNMb2FkQmFsYW5jaW5nVjI6Okxpc3RlbmVyQ2VydGlmaWNhdGVcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBfQVdTX0VMQVNUSUNMT0FEQkFMQU5DSU5HVjJfTElTVEVORVJDRVJUSUZJQ0FURSB7XG5MaXN0ZW5lckFybjogc3RyaW5nXG5DZXJ0aWZpY2F0ZXM6IENlcnRpZmljYXRlW11cbklkPzogc3RyaW5nXG59XG5leHBvcnQgaW50ZXJmYWNlIENlcnRpZmljYXRlIHtcbkNlcnRpZmljYXRlQXJuPzogc3RyaW5nXG59XG4iXX0=