@aws-sdk/client-elastic-load-balancing-v2 3.34.0 → 3.37.0

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

@@ -0,0 +1,811 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+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 interface CertificateNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "CertificateNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace CertificateNotFoundException {
+    
+    const filterSensitiveLog: (obj: CertificateNotFoundException) => any;
+}
+
+export interface ListenerNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ListenerNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ListenerNotFoundException {
+    
+    const filterSensitiveLog: (obj: ListenerNotFoundException) => any;
+}
+
+export interface TooManyCertificatesException extends __SmithyException, $MetadataBearer {
+    name: "TooManyCertificatesException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyCertificatesException {
+    
+    const filterSensitiveLog: (obj: TooManyCertificatesException) => any;
+}
+
+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 interface DuplicateTagKeysException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateTagKeysException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DuplicateTagKeysException {
+    
+    const filterSensitiveLog: (obj: DuplicateTagKeysException) => any;
+}
+
+export interface LoadBalancerNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "LoadBalancerNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace LoadBalancerNotFoundException {
+    
+    const filterSensitiveLog: (obj: LoadBalancerNotFoundException) => any;
+}
+
+export interface RuleNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "RuleNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace RuleNotFoundException {
+    
+    const filterSensitiveLog: (obj: RuleNotFoundException) => any;
+}
+
+export interface TargetGroupNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "TargetGroupNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TargetGroupNotFoundException {
+    
+    const filterSensitiveLog: (obj: TargetGroupNotFoundException) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+
+export interface AllocationIdNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "AllocationIdNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AllocationIdNotFoundException {
+    
+    const filterSensitiveLog: (obj: AllocationIdNotFoundException) => any;
+}
+
+export interface ALPNPolicyNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "ALPNPolicyNotSupportedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ALPNPolicyNotSupportedException {
+    
+    const filterSensitiveLog: (obj: ALPNPolicyNotSupportedException) => any;
+}
+
+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 interface AvailabilityZoneNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "AvailabilityZoneNotSupportedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AvailabilityZoneNotSupportedException {
+    
+    const filterSensitiveLog: (obj: AvailabilityZoneNotSupportedException) => any;
+}
+
+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 interface DuplicateListenerException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateListenerException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DuplicateListenerException {
+    
+    const filterSensitiveLog: (obj: DuplicateListenerException) => any;
+}
+
+export interface IncompatibleProtocolsException extends __SmithyException, $MetadataBearer {
+    name: "IncompatibleProtocolsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace IncompatibleProtocolsException {
+    
+    const filterSensitiveLog: (obj: IncompatibleProtocolsException) => any;
+}
+
+export interface InvalidConfigurationRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidConfigurationRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidConfigurationRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidConfigurationRequestException) => any;
+}
+
+export interface InvalidLoadBalancerActionException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLoadBalancerActionException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidLoadBalancerActionException {
+    
+    const filterSensitiveLog: (obj: InvalidLoadBalancerActionException) => any;
+}
+
+export interface SSLPolicyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "SSLPolicyNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace SSLPolicyNotFoundException {
+    
+    const filterSensitiveLog: (obj: SSLPolicyNotFoundException) => any;
+}
+
+export interface TargetGroupAssociationLimitException extends __SmithyException, $MetadataBearer {
+    name: "TargetGroupAssociationLimitException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TargetGroupAssociationLimitException {
+    
+    const filterSensitiveLog: (obj: TargetGroupAssociationLimitException) => any;
+}
+
+export interface TooManyActionsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyActionsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyActionsException {
+    
+    const filterSensitiveLog: (obj: TooManyActionsException) => any;
+}
+
+export interface TooManyListenersException extends __SmithyException, $MetadataBearer {
+    name: "TooManyListenersException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyListenersException {
+    
+    const filterSensitiveLog: (obj: TooManyListenersException) => any;
+}
+
+export interface TooManyRegistrationsForTargetIdException extends __SmithyException, $MetadataBearer {
+    name: "TooManyRegistrationsForTargetIdException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyRegistrationsForTargetIdException {
+    
+    const filterSensitiveLog: (obj: TooManyRegistrationsForTargetIdException) => any;
+}
+
+export interface TooManyTargetsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTargetsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyTargetsException {
+    
+    const filterSensitiveLog: (obj: TooManyTargetsException) => any;
+}
+
+export interface TooManyUniqueTargetGroupsPerLoadBalancerException extends __SmithyException, $MetadataBearer {
+    name: "TooManyUniqueTargetGroupsPerLoadBalancerException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyUniqueTargetGroupsPerLoadBalancerException {
+    
+    const filterSensitiveLog: (obj: TooManyUniqueTargetGroupsPerLoadBalancerException) => any;
+}
+
+export interface UnsupportedProtocolException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedProtocolException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UnsupportedProtocolException {
+    
+    const filterSensitiveLog: (obj: UnsupportedProtocolException) => any;
+}
+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 interface DuplicateLoadBalancerNameException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateLoadBalancerNameException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DuplicateLoadBalancerNameException {
+    
+    const filterSensitiveLog: (obj: DuplicateLoadBalancerNameException) => any;
+}
+
+export interface InvalidSchemeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSchemeException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidSchemeException {
+    
+    const filterSensitiveLog: (obj: InvalidSchemeException) => any;
+}
+
+export interface InvalidSecurityGroupException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSecurityGroupException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidSecurityGroupException {
+    
+    const filterSensitiveLog: (obj: InvalidSecurityGroupException) => any;
+}
+
+export interface InvalidSubnetException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSubnetException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidSubnetException {
+    
+    const filterSensitiveLog: (obj: InvalidSubnetException) => any;
+}
+
+export interface OperationNotPermittedException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotPermittedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace OperationNotPermittedException {
+    
+    const filterSensitiveLog: (obj: OperationNotPermittedException) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+
+export interface SubnetNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "SubnetNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace SubnetNotFoundException {
+    
+    const filterSensitiveLog: (obj: SubnetNotFoundException) => any;
+}
+
+export interface TooManyLoadBalancersException extends __SmithyException, $MetadataBearer {
+    name: "TooManyLoadBalancersException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyLoadBalancersException {
+    
+    const filterSensitiveLog: (obj: TooManyLoadBalancersException) => any;
+}
+
+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;
+