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

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

@@ -0,0 +1,1100 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ElasticLoadBalancingServiceException as __BaseException } from "./ElasticLoadBalancingServiceException";
+
+export interface AccessLog {
+    
+    Enabled: boolean | undefined;
+    
+    S3BucketName?: string;
+    
+    EmitInterval?: number;
+    
+    S3BucketPrefix?: string;
+}
+export declare namespace AccessLog {
+    
+    const filterSensitiveLog: (obj: AccessLog) => any;
+}
+
+export declare class AccessPointNotFoundException extends __BaseException {
+    readonly name: "AccessPointNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessPointNotFoundException, __BaseException>);
+}
+
+export interface AddAvailabilityZonesInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    AvailabilityZones: string[] | undefined;
+}
+export declare namespace AddAvailabilityZonesInput {
+    
+    const filterSensitiveLog: (obj: AddAvailabilityZonesInput) => any;
+}
+
+export interface AddAvailabilityZonesOutput {
+    
+    AvailabilityZones?: string[];
+}
+export declare namespace AddAvailabilityZonesOutput {
+    
+    const filterSensitiveLog: (obj: AddAvailabilityZonesOutput) => any;
+}
+
+export interface AdditionalAttribute {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace AdditionalAttribute {
+    
+    const filterSensitiveLog: (obj: AdditionalAttribute) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsInput {
+    
+    LoadBalancerNames: 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 TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+
+export interface AppCookieStickinessPolicy {
+    
+    PolicyName?: string;
+    
+    CookieName?: string;
+}
+export declare namespace AppCookieStickinessPolicy {
+    
+    const filterSensitiveLog: (obj: AppCookieStickinessPolicy) => any;
+}
+
+export interface ApplySecurityGroupsToLoadBalancerInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    SecurityGroups: string[] | undefined;
+}
+export declare namespace ApplySecurityGroupsToLoadBalancerInput {
+    
+    const filterSensitiveLog: (obj: ApplySecurityGroupsToLoadBalancerInput) => any;
+}
+
+export interface ApplySecurityGroupsToLoadBalancerOutput {
+    
+    SecurityGroups?: string[];
+}
+export declare namespace ApplySecurityGroupsToLoadBalancerOutput {
+    
+    const filterSensitiveLog: (obj: ApplySecurityGroupsToLoadBalancerOutput) => any;
+}
+
+export declare class InvalidConfigurationRequestException extends __BaseException {
+    readonly name: "InvalidConfigurationRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidConfigurationRequestException, __BaseException>);
+}
+
+export declare class InvalidSecurityGroupException extends __BaseException {
+    readonly name: "InvalidSecurityGroupException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSecurityGroupException, __BaseException>);
+}
+
+export interface AttachLoadBalancerToSubnetsInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Subnets: string[] | undefined;
+}
+export declare namespace AttachLoadBalancerToSubnetsInput {
+    
+    const filterSensitiveLog: (obj: AttachLoadBalancerToSubnetsInput) => any;
+}
+
+export interface AttachLoadBalancerToSubnetsOutput {
+    
+    Subnets?: string[];
+}
+export declare namespace AttachLoadBalancerToSubnetsOutput {
+    
+    const filterSensitiveLog: (obj: AttachLoadBalancerToSubnetsOutput) => any;
+}
+
+export declare class InvalidSubnetException extends __BaseException {
+    readonly name: "InvalidSubnetException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubnetException, __BaseException>);
+}
+
+export declare class SubnetNotFoundException extends __BaseException {
+    readonly name: "SubnetNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SubnetNotFoundException, __BaseException>);
+}
+
+export interface BackendServerDescription {
+    
+    InstancePort?: number;
+    
+    PolicyNames?: string[];
+}
+export declare namespace BackendServerDescription {
+    
+    const filterSensitiveLog: (obj: BackendServerDescription) => any;
+}
+
+export declare class CertificateNotFoundException extends __BaseException {
+    readonly name: "CertificateNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CertificateNotFoundException, __BaseException>);
+}
+
+export interface HealthCheck {
+    
+    Target: string | undefined;
+    
+    Interval: number | undefined;
+    
+    Timeout: number | undefined;
+    
+    UnhealthyThreshold: number | undefined;
+    
+    HealthyThreshold: number | undefined;
+}
+export declare namespace HealthCheck {
+    
+    const filterSensitiveLog: (obj: HealthCheck) => any;
+}
+
+export interface ConfigureHealthCheckInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    HealthCheck: HealthCheck | undefined;
+}
+export declare namespace ConfigureHealthCheckInput {
+    
+    const filterSensitiveLog: (obj: ConfigureHealthCheckInput) => any;
+}
+
+export interface ConfigureHealthCheckOutput {
+    
+    HealthCheck?: HealthCheck;
+}
+export declare namespace ConfigureHealthCheckOutput {
+    
+    const filterSensitiveLog: (obj: ConfigureHealthCheckOutput) => any;
+}
+
+export interface ConnectionDraining {
+    
+    Enabled: boolean | undefined;
+    
+    Timeout?: number;
+}
+export declare namespace ConnectionDraining {
+    
+    const filterSensitiveLog: (obj: ConnectionDraining) => any;
+}
+
+export interface ConnectionSettings {
+    
+    IdleTimeout: number | undefined;
+}
+export declare namespace ConnectionSettings {
+    
+    const filterSensitiveLog: (obj: ConnectionSettings) => any;
+}
+
+export interface Listener {
+    
+    Protocol: string | undefined;
+    
+    LoadBalancerPort: number | undefined;
+    
+    InstanceProtocol?: string;
+    
+    InstancePort: number | undefined;
+    
+    SSLCertificateId?: string;
+}
+export declare namespace Listener {
+    
+    const filterSensitiveLog: (obj: Listener) => any;
+}
+
+export interface CreateAccessPointInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Listeners: Listener[] | undefined;
+    
+    AvailabilityZones?: string[];
+    
+    Subnets?: string[];
+    
+    SecurityGroups?: string[];
+    
+    Scheme?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAccessPointInput {
+    
+    const filterSensitiveLog: (obj: CreateAccessPointInput) => any;
+}
+
+export interface CreateAccessPointOutput {
+    
+    DNSName?: string;
+}
+export declare namespace CreateAccessPointOutput {
+    
+    const filterSensitiveLog: (obj: CreateAccessPointOutput) => any;
+}
+
+export interface CreateAppCookieStickinessPolicyInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    PolicyName: string | undefined;
+    
+    CookieName: string | undefined;
+}
+export declare namespace CreateAppCookieStickinessPolicyInput {
+    
+    const filterSensitiveLog: (obj: CreateAppCookieStickinessPolicyInput) => any;
+}
+
+export interface CreateAppCookieStickinessPolicyOutput {
+}
+export declare namespace CreateAppCookieStickinessPolicyOutput {
+    
+    const filterSensitiveLog: (obj: CreateAppCookieStickinessPolicyOutput) => any;
+}
+
+export declare class DuplicatePolicyNameException extends __BaseException {
+    readonly name: "DuplicatePolicyNameException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicatePolicyNameException, __BaseException>);
+}
+
+export declare class TooManyPoliciesException extends __BaseException {
+    readonly name: "TooManyPoliciesException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyPoliciesException, __BaseException>);
+}
+
+export interface CreateLBCookieStickinessPolicyInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    PolicyName: string | undefined;
+    
+    CookieExpirationPeriod?: number;
+}
+export declare namespace CreateLBCookieStickinessPolicyInput {
+    
+    const filterSensitiveLog: (obj: CreateLBCookieStickinessPolicyInput) => any;
+}
+
+export interface CreateLBCookieStickinessPolicyOutput {
+}
+export declare namespace CreateLBCookieStickinessPolicyOutput {
+    
+    const filterSensitiveLog: (obj: CreateLBCookieStickinessPolicyOutput) => any;
+}
+
+export declare class DuplicateAccessPointNameException extends __BaseException {
+    readonly name: "DuplicateAccessPointNameException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateAccessPointNameException, __BaseException>);
+}
+
+export declare class InvalidSchemeException extends __BaseException {
+    readonly name: "InvalidSchemeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSchemeException, __BaseException>);
+}
+
+export declare class OperationNotPermittedException extends __BaseException {
+    readonly name: "OperationNotPermittedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OperationNotPermittedException, __BaseException>);
+}
+
+export declare class TooManyAccessPointsException extends __BaseException {
+    readonly name: "TooManyAccessPointsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyAccessPointsException, __BaseException>);
+}
+
+export declare class UnsupportedProtocolException extends __BaseException {
+    readonly name: "UnsupportedProtocolException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedProtocolException, __BaseException>);
+}
+
+export interface CreateLoadBalancerListenerInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Listeners: Listener[] | undefined;
+}
+export declare namespace CreateLoadBalancerListenerInput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerListenerInput) => any;
+}
+
+export interface CreateLoadBalancerListenerOutput {
+}
+export declare namespace CreateLoadBalancerListenerOutput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerListenerOutput) => any;
+}
+
+export declare class DuplicateListenerException extends __BaseException {
+    readonly name: "DuplicateListenerException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateListenerException, __BaseException>);
+}
+
+export interface PolicyAttribute {
+    
+    AttributeName?: string;
+    
+    AttributeValue?: string;
+}
+export declare namespace PolicyAttribute {
+    
+    const filterSensitiveLog: (obj: PolicyAttribute) => any;
+}
+
+export interface CreateLoadBalancerPolicyInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    PolicyName: string | undefined;
+    
+    PolicyTypeName: string | undefined;
+    
+    PolicyAttributes?: PolicyAttribute[];
+}
+export declare namespace CreateLoadBalancerPolicyInput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerPolicyInput) => any;
+}
+
+export interface CreateLoadBalancerPolicyOutput {
+}
+export declare namespace CreateLoadBalancerPolicyOutput {
+    
+    const filterSensitiveLog: (obj: CreateLoadBalancerPolicyOutput) => any;
+}
+
+export declare class PolicyTypeNotFoundException extends __BaseException {
+    readonly name: "PolicyTypeNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyTypeNotFoundException, __BaseException>);
+}
+
+export interface CrossZoneLoadBalancing {
+    
+    Enabled: boolean | undefined;
+}
+export declare namespace CrossZoneLoadBalancing {
+    
+    const filterSensitiveLog: (obj: CrossZoneLoadBalancing) => any;
+}
+
+export interface DeleteAccessPointInput {
+    
+    LoadBalancerName: string | undefined;
+}
+export declare namespace DeleteAccessPointInput {
+    
+    const filterSensitiveLog: (obj: DeleteAccessPointInput) => any;
+}
+
+export interface DeleteAccessPointOutput {
+}
+export declare namespace DeleteAccessPointOutput {
+    
+    const filterSensitiveLog: (obj: DeleteAccessPointOutput) => any;
+}
+
+export interface DeleteLoadBalancerListenerInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    LoadBalancerPorts: number[] | undefined;
+}
+export declare namespace DeleteLoadBalancerListenerInput {
+    
+    const filterSensitiveLog: (obj: DeleteLoadBalancerListenerInput) => any;
+}
+
+export interface DeleteLoadBalancerListenerOutput {
+}
+export declare namespace DeleteLoadBalancerListenerOutput {
+    
+    const filterSensitiveLog: (obj: DeleteLoadBalancerListenerOutput) => any;
+}
+
+export interface DeleteLoadBalancerPolicyInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    PolicyName: string | undefined;
+}
+export declare namespace DeleteLoadBalancerPolicyInput {
+    
+    const filterSensitiveLog: (obj: DeleteLoadBalancerPolicyInput) => any;
+}
+
+export interface DeleteLoadBalancerPolicyOutput {
+}
+export declare namespace DeleteLoadBalancerPolicyOutput {
+    
+    const filterSensitiveLog: (obj: DeleteLoadBalancerPolicyOutput) => any;
+}
+
+export declare class DependencyThrottleException extends __BaseException {
+    readonly name: "DependencyThrottleException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DependencyThrottleException, __BaseException>);
+}
+
+export interface Instance {
+    
+    InstanceId?: string;
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+
+export interface DeregisterEndPointsInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Instances: Instance[] | undefined;
+}
+export declare namespace DeregisterEndPointsInput {
+    
+    const filterSensitiveLog: (obj: DeregisterEndPointsInput) => any;
+}
+
+export interface DeregisterEndPointsOutput {
+    
+    Instances?: Instance[];
+}
+export declare namespace DeregisterEndPointsOutput {
+    
+    const filterSensitiveLog: (obj: DeregisterEndPointsOutput) => any;
+}
+
+export declare class InvalidEndPointException extends __BaseException {
+    readonly name: "InvalidEndPointException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidEndPointException, __BaseException>);
+}
+
+export interface DescribeAccessPointsInput {
+    
+    LoadBalancerNames?: string[];
+    
+    Marker?: string;
+    
+    PageSize?: number;
+}
+export declare namespace DescribeAccessPointsInput {
+    
+    const filterSensitiveLog: (obj: DescribeAccessPointsInput) => any;
+}
+
+export interface ListenerDescription {
+    
+    Listener?: Listener;
+    
+    PolicyNames?: string[];
+}
+export declare namespace ListenerDescription {
+    
+    const filterSensitiveLog: (obj: ListenerDescription) => any;
+}
+
+export interface LBCookieStickinessPolicy {
+    
+    PolicyName?: string;
+    
+    CookieExpirationPeriod?: number;
+}
+export declare namespace LBCookieStickinessPolicy {
+    
+    const filterSensitiveLog: (obj: LBCookieStickinessPolicy) => any;
+}
+
+export interface Policies {
+    
+    AppCookieStickinessPolicies?: AppCookieStickinessPolicy[];
+    
+    LBCookieStickinessPolicies?: LBCookieStickinessPolicy[];
+    
+    OtherPolicies?: string[];
+}
+export declare namespace Policies {
+    
+    const filterSensitiveLog: (obj: Policies) => any;
+}
+
+export interface SourceSecurityGroup {
+    
+    OwnerAlias?: string;
+    
+    GroupName?: string;
+}
+export declare namespace SourceSecurityGroup {
+    
+    const filterSensitiveLog: (obj: SourceSecurityGroup) => any;
+}
+
+export interface LoadBalancerDescription {
+    
+    LoadBalancerName?: string;
+    
+    DNSName?: string;
+    
+    CanonicalHostedZoneName?: string;
+    
+    CanonicalHostedZoneNameID?: string;
+    
+    ListenerDescriptions?: ListenerDescription[];
+    
+    Policies?: Policies;
+    
+    BackendServerDescriptions?: BackendServerDescription[];
+    
+    AvailabilityZones?: string[];
+    
+    Subnets?: string[];
+    
+    VPCId?: string;
+    
+    Instances?: Instance[];
+    
+    HealthCheck?: HealthCheck;
+    
+    SourceSecurityGroup?: SourceSecurityGroup;
+    
+    SecurityGroups?: string[];
+    
+    CreatedTime?: Date;
+    
+    Scheme?: string;
+}
+export declare namespace LoadBalancerDescription {
+    
+    const filterSensitiveLog: (obj: LoadBalancerDescription) => any;
+}
+
+export interface DescribeAccessPointsOutput {
+    
+    LoadBalancerDescriptions?: LoadBalancerDescription[];
+    
+    NextMarker?: string;
+}
+export declare namespace DescribeAccessPointsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeAccessPointsOutput) => any;
+}
+export interface DescribeAccountLimitsInput {
+    
+    Marker?: string;
+    
+    PageSize?: number;
+}
+export declare namespace DescribeAccountLimitsInput {
+    
+    const filterSensitiveLog: (obj: DescribeAccountLimitsInput) => any;
+}
+
+export interface Limit {
+    
+    Name?: string;
+    
+    Max?: string;
+}
+export declare namespace Limit {
+    
+    const filterSensitiveLog: (obj: Limit) => any;
+}
+export interface DescribeAccountLimitsOutput {
+    
+    Limits?: Limit[];
+    
+    NextMarker?: string;
+}
+export declare namespace DescribeAccountLimitsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeAccountLimitsOutput) => any;
+}
+
+export interface DescribeEndPointStateInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Instances?: Instance[];
+}
+export declare namespace DescribeEndPointStateInput {
+    
+    const filterSensitiveLog: (obj: DescribeEndPointStateInput) => any;
+}
+
+export interface InstanceState {
+    
+    InstanceId?: string;
+    
+    State?: string;
+    
+    ReasonCode?: string;
+    
+    Description?: string;
+}
+export declare namespace InstanceState {
+    
+    const filterSensitiveLog: (obj: InstanceState) => any;
+}
+
+export interface DescribeEndPointStateOutput {
+    
+    InstanceStates?: InstanceState[];
+}
+export declare namespace DescribeEndPointStateOutput {
+    
+    const filterSensitiveLog: (obj: DescribeEndPointStateOutput) => any;
+}
+
+export interface DescribeLoadBalancerAttributesInput {
+    
+    LoadBalancerName: string | undefined;
+}
+export declare namespace DescribeLoadBalancerAttributesInput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerAttributesInput) => any;
+}
+
+export interface LoadBalancerAttributes {
+    
+    CrossZoneLoadBalancing?: CrossZoneLoadBalancing;
+    
+    AccessLog?: AccessLog;
+    
+    ConnectionDraining?: ConnectionDraining;
+    
+    ConnectionSettings?: ConnectionSettings;
+    
+    AdditionalAttributes?: AdditionalAttribute[];
+}
+export declare namespace LoadBalancerAttributes {
+    
+    const filterSensitiveLog: (obj: LoadBalancerAttributes) => any;
+}
+
+export interface DescribeLoadBalancerAttributesOutput {
+    
+    LoadBalancerAttributes?: LoadBalancerAttributes;
+}
+export declare namespace DescribeLoadBalancerAttributesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerAttributesOutput) => any;
+}
+
+export declare class LoadBalancerAttributeNotFoundException extends __BaseException {
+    readonly name: "LoadBalancerAttributeNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LoadBalancerAttributeNotFoundException, __BaseException>);
+}
+
+export interface DescribeLoadBalancerPoliciesInput {
+    
+    LoadBalancerName?: string;
+    
+    PolicyNames?: string[];
+}
+export declare namespace DescribeLoadBalancerPoliciesInput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerPoliciesInput) => any;
+}
+
+export interface PolicyAttributeDescription {
+    
+    AttributeName?: string;
+    
+    AttributeValue?: string;
+}
+export declare namespace PolicyAttributeDescription {
+    
+    const filterSensitiveLog: (obj: PolicyAttributeDescription) => any;
+}
+
+export interface PolicyDescription {
+    
+    PolicyName?: string;
+    
+    PolicyTypeName?: string;
+    
+    PolicyAttributeDescriptions?: PolicyAttributeDescription[];
+}
+export declare namespace PolicyDescription {
+    
+    const filterSensitiveLog: (obj: PolicyDescription) => any;
+}
+
+export interface DescribeLoadBalancerPoliciesOutput {
+    
+    PolicyDescriptions?: PolicyDescription[];
+}
+export declare namespace DescribeLoadBalancerPoliciesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerPoliciesOutput) => any;
+}
+
+export declare class PolicyNotFoundException extends __BaseException {
+    readonly name: "PolicyNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyNotFoundException, __BaseException>);
+}
+
+export interface DescribeLoadBalancerPolicyTypesInput {
+    
+    PolicyTypeNames?: string[];
+}
+export declare namespace DescribeLoadBalancerPolicyTypesInput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerPolicyTypesInput) => any;
+}
+
+export interface PolicyAttributeTypeDescription {
+    
+    AttributeName?: string;
+    
+    AttributeType?: string;
+    
+    Description?: string;
+    
+    DefaultValue?: string;
+    
+    Cardinality?: string;
+}
+export declare namespace PolicyAttributeTypeDescription {
+    
+    const filterSensitiveLog: (obj: PolicyAttributeTypeDescription) => any;
+}
+
+export interface PolicyTypeDescription {
+    
+    PolicyTypeName?: string;
+    
+    Description?: string;
+    
+    PolicyAttributeTypeDescriptions?: PolicyAttributeTypeDescription[];
+}
+export declare namespace PolicyTypeDescription {
+    
+    const filterSensitiveLog: (obj: PolicyTypeDescription) => any;
+}
+
+export interface DescribeLoadBalancerPolicyTypesOutput {
+    
+    PolicyTypeDescriptions?: PolicyTypeDescription[];
+}
+export declare namespace DescribeLoadBalancerPolicyTypesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeLoadBalancerPolicyTypesOutput) => any;
+}
+
+export interface DescribeTagsInput {
+    
+    LoadBalancerNames: string[] | undefined;
+}
+export declare namespace DescribeTagsInput {
+    
+    const filterSensitiveLog: (obj: DescribeTagsInput) => any;
+}
+
+export interface TagDescription {
+    
+    LoadBalancerName?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace TagDescription {
+    
+    const filterSensitiveLog: (obj: TagDescription) => any;
+}
+
+export interface DescribeTagsOutput {
+    
+    TagDescriptions?: TagDescription[];
+}
+export declare namespace DescribeTagsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeTagsOutput) => any;
+}
+
+export interface DetachLoadBalancerFromSubnetsInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Subnets: string[] | undefined;
+}
+export declare namespace DetachLoadBalancerFromSubnetsInput {
+    
+    const filterSensitiveLog: (obj: DetachLoadBalancerFromSubnetsInput) => any;
+}
+
+export interface DetachLoadBalancerFromSubnetsOutput {
+    
+    Subnets?: string[];
+}
+export declare namespace DetachLoadBalancerFromSubnetsOutput {
+    
+    const filterSensitiveLog: (obj: DetachLoadBalancerFromSubnetsOutput) => any;
+}
+
+export interface RemoveAvailabilityZonesInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    AvailabilityZones: string[] | undefined;
+}
+export declare namespace RemoveAvailabilityZonesInput {
+    
+    const filterSensitiveLog: (obj: RemoveAvailabilityZonesInput) => any;
+}
+
+export interface RemoveAvailabilityZonesOutput {
+    
+    AvailabilityZones?: string[];
+}
+export declare namespace RemoveAvailabilityZonesOutput {
+    
+    const filterSensitiveLog: (obj: RemoveAvailabilityZonesOutput) => any;
+}
+
+export interface ModifyLoadBalancerAttributesInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    LoadBalancerAttributes: LoadBalancerAttributes | undefined;
+}
+export declare namespace ModifyLoadBalancerAttributesInput {
+    
+    const filterSensitiveLog: (obj: ModifyLoadBalancerAttributesInput) => any;
+}
+
+export interface ModifyLoadBalancerAttributesOutput {
+    
+    LoadBalancerName?: string;
+    
+    LoadBalancerAttributes?: LoadBalancerAttributes;
+}
+export declare namespace ModifyLoadBalancerAttributesOutput {
+    
+    const filterSensitiveLog: (obj: ModifyLoadBalancerAttributesOutput) => any;
+}
+
+export interface RegisterEndPointsInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    Instances: Instance[] | undefined;
+}
+export declare namespace RegisterEndPointsInput {
+    
+    const filterSensitiveLog: (obj: RegisterEndPointsInput) => any;
+}
+
+export interface RegisterEndPointsOutput {
+    
+    Instances?: Instance[];
+}
+export declare namespace RegisterEndPointsOutput {
+    
+    const filterSensitiveLog: (obj: RegisterEndPointsOutput) => any;
+}
+
+export interface TagKeyOnly {
+    
+    Key?: string;
+}
+export declare namespace TagKeyOnly {
+    
+    const filterSensitiveLog: (obj: TagKeyOnly) => any;
+}
+
+export interface RemoveTagsInput {
+    
+    LoadBalancerNames: string[] | undefined;
+    
+    Tags: TagKeyOnly[] | undefined;
+}
+export declare namespace RemoveTagsInput {
+    
+    const filterSensitiveLog: (obj: RemoveTagsInput) => any;
+}
+
+export interface RemoveTagsOutput {
+}
+export declare namespace RemoveTagsOutput {
+    
+    const filterSensitiveLog: (obj: RemoveTagsOutput) => any;
+}
+
+export declare class ListenerNotFoundException extends __BaseException {
+    readonly name: "ListenerNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
+}
+
+export interface SetLoadBalancerListenerSSLCertificateInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    LoadBalancerPort: number | undefined;
+    
+    SSLCertificateId: string | undefined;
+}
+export declare namespace SetLoadBalancerListenerSSLCertificateInput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerListenerSSLCertificateInput) => any;
+}
+
+export interface SetLoadBalancerListenerSSLCertificateOutput {
+}
+export declare namespace SetLoadBalancerListenerSSLCertificateOutput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerListenerSSLCertificateOutput) => any;
+}
+
+export interface SetLoadBalancerPoliciesForBackendServerInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    InstancePort: number | undefined;
+    
+    PolicyNames: string[] | undefined;
+}
+export declare namespace SetLoadBalancerPoliciesForBackendServerInput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerPoliciesForBackendServerInput) => any;
+}
+
+export interface SetLoadBalancerPoliciesForBackendServerOutput {
+}
+export declare namespace SetLoadBalancerPoliciesForBackendServerOutput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerPoliciesForBackendServerOutput) => any;
+}
+
+export interface SetLoadBalancerPoliciesOfListenerInput {
+    
+    LoadBalancerName: string | undefined;
+    
+    LoadBalancerPort: number | undefined;
+    
+    PolicyNames: string[] | undefined;
+}
+export declare namespace SetLoadBalancerPoliciesOfListenerInput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerPoliciesOfListenerInput) => any;
+}
+
+export interface SetLoadBalancerPoliciesOfListenerOutput {
+}
+export declare namespace SetLoadBalancerPoliciesOfListenerOutput {
+    
+    const filterSensitiveLog: (obj: SetLoadBalancerPoliciesOfListenerOutput) => any;
+}