@aws-sdk/client-elastic-load-balancing-v2 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,750 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ElasticLoadBalancingV2ServiceException as __BaseException } from "./ElasticLoadBalancingV2ServiceException";
+export declare enum AuthenticateCognitoActionConditionalBehaviorEnum {
+    ALLOW = "allow",
+    AUTHENTICATE = "authenticate",
+    DENY = "deny"
+}
+
+export interface AuthenticateCognitoActionConfig {
+    
+    UserPoolArn: string | undefined;
+    
+    UserPoolClientId: string | undefined;
+    
+    UserPoolDomain: string | undefined;
+    
+    SessionCookieName?: string;
+    
+    Scope?: string;
+    
+    SessionTimeout?: number;
+    
+    AuthenticationRequestExtraParams?: {
+        [key: string]: string;
+    };
+    
+    OnUnauthenticatedRequest?: AuthenticateCognitoActionConditionalBehaviorEnum | string;
+}
+export declare namespace AuthenticateCognitoActionConfig {
+    
+    const filterSensitiveLog: (obj: AuthenticateCognitoActionConfig) => any;
+}
+export declare enum AuthenticateOidcActionConditionalBehaviorEnum {
+    ALLOW = "allow",
+    AUTHENTICATE = "authenticate",
+    DENY = "deny"
+}
+
+export interface AuthenticateOidcActionConfig {
+    
+    Issuer: string | undefined;
+    
+    AuthorizationEndpoint: string | undefined;
+    
+    TokenEndpoint: string | undefined;
+    
+    UserInfoEndpoint: string | undefined;
+    
+    ClientId: string | undefined;
+    
+    ClientSecret?: string;
+    
+    SessionCookieName?: string;
+    
+    Scope?: string;
+    
+    SessionTimeout?: number;
+    
+    AuthenticationRequestExtraParams?: {
+        [key: string]: string;
+    };
+    
+    OnUnauthenticatedRequest?: AuthenticateOidcActionConditionalBehaviorEnum | string;
+    
+    UseExistingClientSecret?: boolean;
+}
+export declare namespace AuthenticateOidcActionConfig {
+    
+    const filterSensitiveLog: (obj: AuthenticateOidcActionConfig) => any;
+}
+
+export interface FixedResponseActionConfig {
+    
+    MessageBody?: string;
+    
+    StatusCode: string | undefined;
+    
+    ContentType?: string;
+}
+export declare namespace FixedResponseActionConfig {
+    
+    const filterSensitiveLog: (obj: FixedResponseActionConfig) => any;
+}
+
+export interface TargetGroupTuple {
+    
+    TargetGroupArn?: string;
+    
+    Weight?: number;
+}
+export declare namespace TargetGroupTuple {
+    
+    const filterSensitiveLog: (obj: TargetGroupTuple) => any;
+}
+
+export interface TargetGroupStickinessConfig {
+    
+    Enabled?: boolean;
+    
+    DurationSeconds?: number;
+}
+export declare namespace TargetGroupStickinessConfig {
+    
+    const filterSensitiveLog: (obj: TargetGroupStickinessConfig) => any;
+}
+
+export interface ForwardActionConfig {
+    
+    TargetGroups?: TargetGroupTuple[];
+    
+    TargetGroupStickinessConfig?: TargetGroupStickinessConfig;
+}
+export declare namespace ForwardActionConfig {
+    
+    const filterSensitiveLog: (obj: ForwardActionConfig) => any;
+}
+export declare enum RedirectActionStatusCodeEnum {
+    HTTP_301 = "HTTP_301",
+    HTTP_302 = "HTTP_302"
+}
+
+export interface RedirectActionConfig {
+    
+    Protocol?: string;
+    
+    Port?: string;
+    
+    Host?: string;
+    
+    Path?: string;
+    
+    Query?: string;
+    
+    StatusCode: RedirectActionStatusCodeEnum | string | undefined;
+}
+export declare namespace RedirectActionConfig {
+    
+    const filterSensitiveLog: (obj: RedirectActionConfig) => any;
+}
+export declare enum ActionTypeEnum {
+    AUTHENTICATE_COGNITO = "authenticate-cognito",
+    AUTHENTICATE_OIDC = "authenticate-oidc",
+    FIXED_RESPONSE = "fixed-response",
+    FORWARD = "forward",
+    REDIRECT = "redirect"
+}
+
+export interface Action {
+    
+    Type: ActionTypeEnum | string | undefined;
+    
+    TargetGroupArn?: string;
+    
+    AuthenticateOidcConfig?: AuthenticateOidcActionConfig;
+    
+    AuthenticateCognitoConfig?: AuthenticateCognitoActionConfig;
+    
+    Order?: number;
+    
+    RedirectConfig?: RedirectActionConfig;
+    
+    FixedResponseConfig?: FixedResponseActionConfig;
+    
+    ForwardConfig?: ForwardActionConfig;
+}
+export declare namespace Action {
+    
+    const filterSensitiveLog: (obj: Action) => any;
+}
+
+export interface Certificate {
+    
+    CertificateArn?: string;
+    
+    IsDefault?: boolean;
+}
+export declare namespace Certificate {
+    
+    const filterSensitiveLog: (obj: Certificate) => any;
+}
+export interface AddListenerCertificatesInput {
+    
+    ListenerArn: string | undefined;
+    
+    Certificates: Certificate[] | undefined;
+}
+export declare namespace AddListenerCertificatesInput {
+    
+    const filterSensitiveLog: (obj: AddListenerCertificatesInput) => any;
+}
+export interface AddListenerCertificatesOutput {
+    
+    Certificates?: Certificate[];
+}
+export declare namespace AddListenerCertificatesOutput {
+    
+    const filterSensitiveLog: (obj: AddListenerCertificatesOutput) => any;
+}
+
+export declare class CertificateNotFoundException extends __BaseException {
+    readonly name: "CertificateNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CertificateNotFoundException, __BaseException>);
+}
+
+export declare class ListenerNotFoundException extends __BaseException {
+    readonly name: "ListenerNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
+}
+
+export declare class TooManyCertificatesException extends __BaseException {
+    readonly name: "TooManyCertificatesException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyCertificatesException, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface AddTagsInput {
+    
+    ResourceArns: string[] | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace AddTagsInput {
+    
+    const filterSensitiveLog: (obj: AddTagsInput) => any;
+}
+export interface AddTagsOutput {
+}
+export declare namespace AddTagsOutput {
+    
+    const filterSensitiveLog: (obj: AddTagsOutput) => any;
+}
+
+export declare class DuplicateTagKeysException extends __BaseException {
+    readonly name: "DuplicateTagKeysException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateTagKeysException, __BaseException>);
+}
+
+export declare class LoadBalancerNotFoundException extends __BaseException {
+    readonly name: "LoadBalancerNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LoadBalancerNotFoundException, __BaseException>);
+}
+
+export declare class RuleNotFoundException extends __BaseException {
+    readonly name: "RuleNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RuleNotFoundException, __BaseException>);
+}
+
+export declare class TargetGroupNotFoundException extends __BaseException {
+    readonly name: "TargetGroupNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TargetGroupNotFoundException, __BaseException>);
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+
+export declare class AllocationIdNotFoundException extends __BaseException {
+    readonly name: "AllocationIdNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AllocationIdNotFoundException, __BaseException>);
+}
+
+export declare class ALPNPolicyNotSupportedException extends __BaseException {
+    readonly name: "ALPNPolicyNotSupportedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ALPNPolicyNotSupportedException, __BaseException>);
+}
+
+export interface LoadBalancerAddress {
+    
+    IpAddress?: string;
+    
+    AllocationId?: string;
+    
+    PrivateIPv4Address?: string;
+    
+    IPv6Address?: string;
+}
+export declare namespace LoadBalancerAddress {
+    
+    const filterSensitiveLog: (obj: LoadBalancerAddress) => any;
+}
+
+export interface AvailabilityZone {
+    
+    ZoneName?: string;
+    
+    SubnetId?: string;
+    
+    OutpostId?: string;
+    
+    LoadBalancerAddresses?: LoadBalancerAddress[];
+}
+export declare namespace AvailabilityZone {
+    
+    const filterSensitiveLog: (obj: AvailabilityZone) => any;
+}
+
+export declare class AvailabilityZoneNotSupportedException extends __BaseException {
+    readonly name: "AvailabilityZoneNotSupportedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AvailabilityZoneNotSupportedException, __BaseException>);
+}
+
+export interface Cipher {
+    
+    Name?: string;
+    
+    Priority?: number;
+}
+export declare namespace Cipher {
+    
+    const filterSensitiveLog: (obj: Cipher) => any;
+}
+export declare type ProtocolEnum = "GENEVE" | "HTTP" | "HTTPS" | "TCP" | "TCP_UDP" | "TLS" | "UDP";
+export interface CreateListenerInput {
+    
+    LoadBalancerArn: string | undefined;
+    
+    Protocol?: ProtocolEnum | string;
+    
+    Port?: number;
+    
+    SslPolicy?: string;
+    
+    Certificates?: Certificate[];
+    
+    DefaultActions: Action[] | undefined;
+    
+    AlpnPolicy?: string[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateListenerInput {
+    
+    const filterSensitiveLog: (obj: CreateListenerInput) => any;
+}
+
+export interface Listener {
+    
+    ListenerArn?: string;
+    
+    LoadBalancerArn?: string;
+    
+    Port?: number;
+    
+    Protocol?: ProtocolEnum | string;
+    
+    Certificates?: Certificate[];
+    
+    SslPolicy?: string;
+    
+    DefaultActions?: Action[];
+    
+    AlpnPolicy?: string[];
+}
+export declare namespace Listener {
+    
+    const filterSensitiveLog: (obj: Listener) => any;
+}
+export interface CreateListenerOutput {
+    
+    Listeners?: Listener[];
+}
+export declare namespace CreateListenerOutput {
+    
+    const filterSensitiveLog: (obj: CreateListenerOutput) => any;
+}
+
+export declare class DuplicateListenerException extends __BaseException {
+    readonly name: "DuplicateListenerException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateListenerException, __BaseException>);
+}
+
+export declare class IncompatibleProtocolsException extends __BaseException {
+    readonly name: "IncompatibleProtocolsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IncompatibleProtocolsException, __BaseException>);
+}
+
+export declare class InvalidConfigurationRequestException extends __BaseException {
+    readonly name: "InvalidConfigurationRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidConfigurationRequestException, __BaseException>);
+}
+
+export declare class InvalidLoadBalancerActionException extends __BaseException {
+    readonly name: "InvalidLoadBalancerActionException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidLoadBalancerActionException, __BaseException>);
+}
+
+export declare class SSLPolicyNotFoundException extends __BaseException {
+    readonly name: "SSLPolicyNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SSLPolicyNotFoundException, __BaseException>);
+}
+
+export declare class TargetGroupAssociationLimitException extends __BaseException {
+    readonly name: "TargetGroupAssociationLimitException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TargetGroupAssociationLimitException, __BaseException>);
+}
+
+export declare class TooManyActionsException extends __BaseException {
+    readonly name: "TooManyActionsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyActionsException, __BaseException>);
+}
+
+export declare class TooManyListenersException extends __BaseException {
+    readonly name: "TooManyListenersException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyListenersException, __BaseException>);
+}
+
+export declare class TooManyRegistrationsForTargetIdException extends __BaseException {
+    readonly name: "TooManyRegistrationsForTargetIdException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRegistrationsForTargetIdException, __BaseException>);
+}
+
+export declare class TooManyTargetsException extends __BaseException {
+    readonly name: "TooManyTargetsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTargetsException, __BaseException>);
+}
+
+export declare class TooManyUniqueTargetGroupsPerLoadBalancerException extends __BaseException {
+    readonly name: "TooManyUniqueTargetGroupsPerLoadBalancerException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyUniqueTargetGroupsPerLoadBalancerException, __BaseException>);
+}
+
+export declare class UnsupportedProtocolException extends __BaseException {
+    readonly name: "UnsupportedProtocolException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedProtocolException, __BaseException>);
+}
+export declare enum IpAddressType {
+    DUALSTACK = "dualstack",
+    IPV4 = "ipv4"
+}
+export declare enum LoadBalancerSchemeEnum {
+    INTERNAL = "internal",
+    INTERNET_FACING = "internet-facing"
+}
+
+export interface SubnetMapping {
+    
+    SubnetId?: string;
+    
+    AllocationId?: string;
+    
+    PrivateIPv4Address?: string;
+    
+    IPv6Address?: string;
+}
+export declare namespace SubnetMapping {
+    
+    const filterSensitiveLog: (obj: SubnetMapping) => any;
+}
+export declare enum LoadBalancerTypeEnum {
+    APPLICATION = "application",
+    GATEWAY = "gateway",
+    NETWORK = "network"
+}
+export interface CreateLoadBalancerInput {
+    
+    Name: string | undefined;
+    
+    Subnets?: string[];
+    
+    SubnetMappings?: SubnetMapping[];
+    
+    SecurityGroups?: string[];
+    
+    Scheme?: LoadBalancerSchemeEnum | string;
+    
+    Tags?: Tag[];
+    
+    Type?: LoadBalancerTypeEnum | string;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    CustomerOwnedIpv4Pool?: string;
+}
+export declare namespace CreateLoadBalancerInput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerInput) => any;
+}
+export declare enum LoadBalancerStateEnum {
+    ACTIVE = "active",
+    ACTIVE_IMPAIRED = "active_impaired",
+    FAILED = "failed",
+    PROVISIONING = "provisioning"
+}
+
+export interface LoadBalancerState {
+    
+    Code?: LoadBalancerStateEnum | string;
+    
+    Reason?: string;
+}
+export declare namespace LoadBalancerState {
+    
+    const filterSensitiveLog: (obj: LoadBalancerState) => any;
+}
+
+export interface LoadBalancer {
+    
+    LoadBalancerArn?: string;
+    
+    DNSName?: string;
+    
+    CanonicalHostedZoneId?: string;
+    
+    CreatedTime?: Date;
+    
+    LoadBalancerName?: string;
+    
+    Scheme?: LoadBalancerSchemeEnum | string;
+    
+    VpcId?: string;
+    
+    State?: LoadBalancerState;
+    
+    Type?: LoadBalancerTypeEnum | string;
+    
+    AvailabilityZones?: AvailabilityZone[];
+    
+    SecurityGroups?: string[];
+    
+    IpAddressType?: IpAddressType | string;
+    
+    CustomerOwnedIpv4Pool?: string;
+}
+export declare namespace LoadBalancer {
+    
+    const filterSensitiveLog: (obj: LoadBalancer) => any;
+}
+export interface CreateLoadBalancerOutput {
+    
+    LoadBalancers?: LoadBalancer[];
+}
+export declare namespace CreateLoadBalancerOutput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerOutput) => any;
+}
+
+export declare class DuplicateLoadBalancerNameException extends __BaseException {
+    readonly name: "DuplicateLoadBalancerNameException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateLoadBalancerNameException, __BaseException>);
+}
+
+export declare class InvalidSchemeException extends __BaseException {
+    readonly name: "InvalidSchemeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSchemeException, __BaseException>);
+}
+
+export declare class InvalidSecurityGroupException extends __BaseException {
+    readonly name: "InvalidSecurityGroupException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSecurityGroupException, __BaseException>);
+}
+
+export declare class InvalidSubnetException extends __BaseException {
+    readonly name: "InvalidSubnetException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubnetException, __BaseException>);
+}
+
+export declare class OperationNotPermittedException extends __BaseException {
+    readonly name: "OperationNotPermittedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OperationNotPermittedException, __BaseException>);
+}
+
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+
+export declare class SubnetNotFoundException extends __BaseException {
+    readonly name: "SubnetNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SubnetNotFoundException, __BaseException>);
+}
+
+export declare class TooManyLoadBalancersException extends __BaseException {
+    readonly name: "TooManyLoadBalancersException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyLoadBalancersException, __BaseException>);
+}
+
+export interface HostHeaderConditionConfig {
+    
+    Values?: string[];
+}
+export declare namespace HostHeaderConditionConfig {
+    
+    const filterSensitiveLog: (obj: HostHeaderConditionConfig) => any;
+}
+
+export interface HttpHeaderConditionConfig {
+    
+    HttpHeaderName?: string;
+    
+    Values?: string[];
+}
+export declare namespace HttpHeaderConditionConfig {
+    
+    const filterSensitiveLog: (obj: HttpHeaderConditionConfig) => any;
+}
+
+export interface HttpRequestMethodConditionConfig {
+    
+    Values?: string[];
+}
+export declare namespace HttpRequestMethodConditionConfig {
+    
+    const filterSensitiveLog: (obj: HttpRequestMethodConditionConfig) => any;
+}
+
+export interface PathPatternConditionConfig {
+    
+    Values?: string[];
+}
+export declare namespace PathPatternConditionConfig {
+    
+    const filterSensitiveLog: (obj: PathPatternConditionConfig) => any;
+}
+
+export interface QueryStringKeyValuePair {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace QueryStringKeyValuePair {
+    
+    const filterSensitiveLog: (obj: QueryStringKeyValuePair) => any;
+}
+
+export interface QueryStringConditionConfig {
+    
+    Values?: QueryStringKeyValuePair[];
+}
+export declare namespace QueryStringConditionConfig {
+    
+    const filterSensitiveLog: (obj: QueryStringConditionConfig) => any;
+}
+
+export interface SourceIpConditionConfig {
+    
+    Values?: string[];
+}
+export declare namespace SourceIpConditionConfig {
+    
+    const filterSensitiveLog: (obj: SourceIpConditionConfig) => any;
+}
+
+export interface RuleCondition {
+    
+    Field?: string;
+