@aws-sdk/client-global-accelerator 3.50.0 → 3.53.0

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

@@ -0,0 +1,1395 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { GlobalAcceleratorServiceException as __BaseException } from "./GlobalAcceleratorServiceException";
+export declare enum IpAddressType {
+    IPV4 = "IPV4"
+}
+
+export interface IpSet {
+    
+    IpFamily?: string;
+    
+    IpAddresses?: string[];
+}
+export declare namespace IpSet {
+    
+    const filterSensitiveLog: (obj: IpSet) => any;
+}
+export declare type AcceleratorStatus = "DEPLOYED" | "IN_PROGRESS";
+
+export interface Accelerator {
+    
+    AcceleratorArn?: string;
+    
+    Name?: string;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    Enabled?: boolean;
+    
+    IpSets?: IpSet[];
+    
+    DnsName?: string;
+    
+    Status?: AcceleratorStatus | string;
+    
+    CreatedTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace Accelerator {
+    
+    const filterSensitiveLog: (obj: Accelerator) => any;
+}
+
+export interface AcceleratorAttributes {
+    
+    FlowLogsEnabled?: boolean;
+    
+    FlowLogsS3Bucket?: string;
+    
+    FlowLogsS3Prefix?: string;
+}
+export declare namespace AcceleratorAttributes {
+    
+    const filterSensitiveLog: (obj: AcceleratorAttributes) => any;
+}
+
+export declare class AcceleratorNotDisabledException extends __BaseException {
+    readonly name: "AcceleratorNotDisabledException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AcceleratorNotDisabledException, __BaseException>);
+}
+
+export declare class AcceleratorNotFoundException extends __BaseException {
+    readonly name: "AcceleratorNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AcceleratorNotFoundException, __BaseException>);
+}
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface CustomRoutingEndpointConfiguration {
+    
+    EndpointId?: string;
+}
+export declare namespace CustomRoutingEndpointConfiguration {
+    
+    const filterSensitiveLog: (obj: CustomRoutingEndpointConfiguration) => any;
+}
+export interface AddCustomRoutingEndpointsRequest {
+    
+    EndpointConfigurations: CustomRoutingEndpointConfiguration[] | undefined;
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace AddCustomRoutingEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: AddCustomRoutingEndpointsRequest) => any;
+}
+
+export interface CustomRoutingEndpointDescription {
+    
+    EndpointId?: string;
+}
+export declare namespace CustomRoutingEndpointDescription {
+    
+    const filterSensitiveLog: (obj: CustomRoutingEndpointDescription) => any;
+}
+export interface AddCustomRoutingEndpointsResponse {
+    
+    EndpointDescriptions?: CustomRoutingEndpointDescription[];
+    
+    EndpointGroupArn?: string;
+}
+export declare namespace AddCustomRoutingEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: AddCustomRoutingEndpointsResponse) => any;
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class EndpointAlreadyExistsException extends __BaseException {
+    readonly name: "EndpointAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EndpointAlreadyExistsException, __BaseException>);
+}
+
+export declare class EndpointGroupNotFoundException extends __BaseException {
+    readonly name: "EndpointGroupNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EndpointGroupNotFoundException, __BaseException>);
+}
+
+export declare class InternalServiceErrorException extends __BaseException {
+    readonly name: "InternalServiceErrorException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServiceErrorException, __BaseException>);
+}
+
+export declare class InvalidArgumentException extends __BaseException {
+    readonly name: "InvalidArgumentException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidArgumentException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+export interface AdvertiseByoipCidrRequest {
+    
+    Cidr: string | undefined;
+}
+export declare namespace AdvertiseByoipCidrRequest {
+    
+    const filterSensitiveLog: (obj: AdvertiseByoipCidrRequest) => any;
+}
+
+export interface ByoipCidrEvent {
+    
+    Message?: string;
+    
+    Timestamp?: Date;
+}
+export declare namespace ByoipCidrEvent {
+    
+    const filterSensitiveLog: (obj: ByoipCidrEvent) => any;
+}
+export declare enum ByoipCidrState {
+    ADVERTISING = "ADVERTISING",
+    DEPROVISIONED = "DEPROVISIONED",
+    FAILED_ADVERTISING = "FAILED_ADVERTISING",
+    FAILED_DEPROVISION = "FAILED_DEPROVISION",
+    FAILED_PROVISION = "FAILED_PROVISION",
+    FAILED_WITHDRAW = "FAILED_WITHDRAW",
+    PENDING_ADVERTISING = "PENDING_ADVERTISING",
+    PENDING_DEPROVISIONING = "PENDING_DEPROVISIONING",
+    PENDING_PROVISIONING = "PENDING_PROVISIONING",
+    PENDING_WITHDRAWING = "PENDING_WITHDRAWING",
+    READY = "READY"
+}
+
+export interface ByoipCidr {
+    
+    Cidr?: string;
+    
+    State?: ByoipCidrState | string;
+    
+    Events?: ByoipCidrEvent[];
+}
+export declare namespace ByoipCidr {
+    
+    const filterSensitiveLog: (obj: ByoipCidr) => any;
+}
+export interface AdvertiseByoipCidrResponse {
+    
+    ByoipCidr?: ByoipCidr;
+}
+export declare namespace AdvertiseByoipCidrResponse {
+    
+    const filterSensitiveLog: (obj: AdvertiseByoipCidrResponse) => any;
+}
+
+export declare class ByoipCidrNotFoundException extends __BaseException {
+    readonly name: "ByoipCidrNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ByoipCidrNotFoundException, __BaseException>);
+}
+
+export declare class IncorrectCidrStateException extends __BaseException {
+    readonly name: "IncorrectCidrStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IncorrectCidrStateException, __BaseException>);
+}
+export interface AllowCustomRoutingTrafficRequest {
+    
+    EndpointGroupArn: string | undefined;
+    
+    EndpointId: string | undefined;
+    
+    DestinationAddresses?: string[];
+    
+    DestinationPorts?: number[];
+    
+    AllowAllTrafficToEndpoint?: boolean;
+}
+export declare namespace AllowCustomRoutingTrafficRequest {
+    
+    const filterSensitiveLog: (obj: AllowCustomRoutingTrafficRequest) => any;
+}
+
+export declare class AssociatedEndpointGroupFoundException extends __BaseException {
+    readonly name: "AssociatedEndpointGroupFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AssociatedEndpointGroupFoundException, __BaseException>);
+}
+
+export declare class AssociatedListenerFoundException extends __BaseException {
+    readonly name: "AssociatedListenerFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AssociatedListenerFoundException, __BaseException>);
+}
+
+export interface CidrAuthorizationContext {
+    
+    Message: string | undefined;
+    
+    Signature: string | undefined;
+}
+export declare namespace CidrAuthorizationContext {
+    
+    const filterSensitiveLog: (obj: CidrAuthorizationContext) => any;
+}
+export declare type ClientAffinity = "NONE" | "SOURCE_IP";
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateAcceleratorRequest {
+    
+    Name: string | undefined;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    IpAddresses?: string[];
+    
+    Enabled?: boolean;
+    
+    IdempotencyToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: CreateAcceleratorRequest) => any;
+}
+export interface CreateAcceleratorResponse {
+    
+    Accelerator?: Accelerator;
+}
+export declare namespace CreateAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: CreateAcceleratorResponse) => any;
+}
+export interface CreateCustomRoutingAcceleratorRequest {
+    
+    Name: string | undefined;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    IpAddresses?: string[];
+    
+    Enabled?: boolean;
+    
+    IdempotencyToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateCustomRoutingAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingAcceleratorRequest) => any;
+}
+export declare type CustomRoutingAcceleratorStatus = "DEPLOYED" | "IN_PROGRESS";
+
+export interface CustomRoutingAccelerator {
+    
+    AcceleratorArn?: string;
+    
+    Name?: string;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    Enabled?: boolean;
+    
+    IpSets?: IpSet[];
+    
+    DnsName?: string;
+    
+    Status?: CustomRoutingAcceleratorStatus | string;
+    
+    CreatedTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace CustomRoutingAccelerator {
+    
+    const filterSensitiveLog: (obj: CustomRoutingAccelerator) => any;
+}
+export interface CreateCustomRoutingAcceleratorResponse {
+    
+    Accelerator?: CustomRoutingAccelerator;
+}
+export declare namespace CreateCustomRoutingAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingAcceleratorResponse) => any;
+}
+export declare enum CustomRoutingProtocol {
+    TCP = "TCP",
+    UDP = "UDP"
+}
+
+export interface CustomRoutingDestinationConfiguration {
+    
+    FromPort: number | undefined;
+    
+    ToPort: number | undefined;
+    
+    Protocols: (CustomRoutingProtocol | string)[] | undefined;
+}
+export declare namespace CustomRoutingDestinationConfiguration {
+    
+    const filterSensitiveLog: (obj: CustomRoutingDestinationConfiguration) => any;
+}
+export interface CreateCustomRoutingEndpointGroupRequest {
+    
+    ListenerArn: string | undefined;
+    
+    EndpointGroupRegion: string | undefined;
+    
+    DestinationConfigurations: CustomRoutingDestinationConfiguration[] | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateCustomRoutingEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingEndpointGroupRequest) => any;
+}
+export declare enum Protocol {
+    TCP = "TCP",
+    UDP = "UDP"
+}
+
+export interface CustomRoutingDestinationDescription {
+    
+    FromPort?: number;
+    
+    ToPort?: number;
+    
+    Protocols?: (Protocol | string)[];
+}
+export declare namespace CustomRoutingDestinationDescription {
+    
+    const filterSensitiveLog: (obj: CustomRoutingDestinationDescription) => any;
+}
+
+export interface CustomRoutingEndpointGroup {
+    
+    EndpointGroupArn?: string;
+    
+    EndpointGroupRegion?: string;
+    
+    DestinationDescriptions?: CustomRoutingDestinationDescription[];
+    
+    EndpointDescriptions?: CustomRoutingEndpointDescription[];
+}
+export declare namespace CustomRoutingEndpointGroup {
+    
+    const filterSensitiveLog: (obj: CustomRoutingEndpointGroup) => any;
+}
+export interface CreateCustomRoutingEndpointGroupResponse {
+    
+    EndpointGroup?: CustomRoutingEndpointGroup;
+}
+export declare namespace CreateCustomRoutingEndpointGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingEndpointGroupResponse) => any;
+}
+
+export declare class EndpointGroupAlreadyExistsException extends __BaseException {
+    readonly name: "EndpointGroupAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EndpointGroupAlreadyExistsException, __BaseException>);
+}
+
+export declare class InvalidPortRangeException extends __BaseException {
+    readonly name: "InvalidPortRangeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidPortRangeException, __BaseException>);
+}
+
+export declare class ListenerNotFoundException extends __BaseException {
+    readonly name: "ListenerNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
+}
+
+export interface PortRange {
+    
+    FromPort?: number;
+    
+    ToPort?: number;
+}
+export declare namespace PortRange {
+    
+    const filterSensitiveLog: (obj: PortRange) => any;
+}
+export interface CreateCustomRoutingListenerRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    PortRanges: PortRange[] | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateCustomRoutingListenerRequest {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingListenerRequest) => any;
+}
+
+export interface CustomRoutingListener {
+    
+    ListenerArn?: string;
+    
+    PortRanges?: PortRange[];
+}
+export declare namespace CustomRoutingListener {
+    
+    const filterSensitiveLog: (obj: CustomRoutingListener) => any;
+}
+export interface CreateCustomRoutingListenerResponse {
+    
+    Listener?: CustomRoutingListener;
+}
+export declare namespace CreateCustomRoutingListenerResponse {
+    
+    const filterSensitiveLog: (obj: CreateCustomRoutingListenerResponse) => any;
+}
+
+export interface EndpointConfiguration {
+    
+    EndpointId?: string;
+    
+    Weight?: number;
+    
+    ClientIPPreservationEnabled?: boolean;
+}
+export declare namespace EndpointConfiguration {
+    
+    const filterSensitiveLog: (obj: EndpointConfiguration) => any;
+}
+export declare enum HealthCheckProtocol {
+    HTTP = "HTTP",
+    HTTPS = "HTTPS",
+    TCP = "TCP"
+}
+
+export interface PortOverride {
+    
+    ListenerPort?: number;
+    
+    EndpointPort?: number;
+}
+export declare namespace PortOverride {
+    
+    const filterSensitiveLog: (obj: PortOverride) => any;
+}
+export interface CreateEndpointGroupRequest {
+    
+    ListenerArn: string | undefined;
+    
+    EndpointGroupRegion: string | undefined;
+    
+    EndpointConfigurations?: EndpointConfiguration[];
+    
+    TrafficDialPercentage?: number;
+    
+    HealthCheckPort?: number;
+    
+    HealthCheckProtocol?: HealthCheckProtocol | string;
+    
+    HealthCheckPath?: string;
+    
+    HealthCheckIntervalSeconds?: number;
+    
+    ThresholdCount?: number;
+    
+    IdempotencyToken?: string;
+    
+    PortOverrides?: PortOverride[];
+}
+export declare namespace CreateEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateEndpointGroupRequest) => any;
+}
+export declare type HealthState = "HEALTHY" | "INITIAL" | "UNHEALTHY";
+
+export interface EndpointDescription {
+    
+    EndpointId?: string;
+    
+    Weight?: number;
+    
+    HealthState?: HealthState | string;
+    
+    HealthReason?: string;
+    
+    ClientIPPreservationEnabled?: boolean;
+}
+export declare namespace EndpointDescription {
+    
+    const filterSensitiveLog: (obj: EndpointDescription) => any;
+}
+
+export interface EndpointGroup {
+    
+    EndpointGroupArn?: string;
+    
+    EndpointGroupRegion?: string;
+    
+    EndpointDescriptions?: EndpointDescription[];
+    
+    TrafficDialPercentage?: number;
+    
+    HealthCheckPort?: number;
+    
+    HealthCheckProtocol?: HealthCheckProtocol | string;
+    
+    HealthCheckPath?: string;
+    
+    HealthCheckIntervalSeconds?: number;
+    
+    ThresholdCount?: number;
+    
+    PortOverrides?: PortOverride[];
+}
+export declare namespace EndpointGroup {
+    
+    const filterSensitiveLog: (obj: EndpointGroup) => any;
+}
+export interface CreateEndpointGroupResponse {
+    
+    EndpointGroup?: EndpointGroup;
+}
+export declare namespace CreateEndpointGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateEndpointGroupResponse) => any;
+}
+export interface CreateListenerRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    PortRanges: PortRange[] | undefined;
+    
+    Protocol: Protocol | string | undefined;
+    
+    ClientAffinity?: ClientAffinity | string;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateListenerRequest {
+    
+    const filterSensitiveLog: (obj: CreateListenerRequest) => any;
+}
+
+export interface Listener {
+    
+    ListenerArn?: string;
+    
+    PortRanges?: PortRange[];
+    
+    Protocol?: Protocol | string;
+    
+    ClientAffinity?: ClientAffinity | string;
+}
+export declare namespace Listener {
+    
+    const filterSensitiveLog: (obj: Listener) => any;
+}
+export interface CreateListenerResponse {
+    
+    Listener?: Listener;
+}
+export declare namespace CreateListenerResponse {
+    
+    const filterSensitiveLog: (obj: CreateListenerResponse) => any;
+}
+
+export interface CustomRoutingAcceleratorAttributes {
+    
+    FlowLogsEnabled?: boolean;
+    
+    FlowLogsS3Bucket?: string;
+    
+    FlowLogsS3Prefix?: string;
+}
+export declare namespace CustomRoutingAcceleratorAttributes {
+    
+    const filterSensitiveLog: (obj: CustomRoutingAcceleratorAttributes) => any;
+}
+export declare enum CustomRoutingDestinationTrafficState {
+    ALLOW = "ALLOW",
+    DENY = "DENY"
+}
+export interface DeleteAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DeleteAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAcceleratorRequest) => any;
+}
+export interface DeleteCustomRoutingAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DeleteCustomRoutingAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCustomRoutingAcceleratorRequest) => any;
+}
+export interface DeleteCustomRoutingEndpointGroupRequest {
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace DeleteCustomRoutingEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCustomRoutingEndpointGroupRequest) => any;
+}
+export interface DeleteCustomRoutingListenerRequest {
+    
+    ListenerArn: string | undefined;
+}
+export declare namespace DeleteCustomRoutingListenerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCustomRoutingListenerRequest) => any;
+}
+export interface DeleteEndpointGroupRequest {
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace DeleteEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointGroupRequest) => any;
+}
+export interface DeleteListenerRequest {
+    
+    ListenerArn: string | undefined;
+}
+export declare namespace DeleteListenerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteListenerRequest) => any;
+}
+export interface DenyCustomRoutingTrafficRequest {
+    
+    EndpointGroupArn: string | undefined;
+    
+    EndpointId: string | undefined;
+    
+    DestinationAddresses?: string[];
+    
+    DestinationPorts?: number[];
+    
+    DenyAllTrafficToEndpoint?: boolean;
+}
+export declare namespace DenyCustomRoutingTrafficRequest {
+    
+    const filterSensitiveLog: (obj: DenyCustomRoutingTrafficRequest) => any;
+}
+export interface DeprovisionByoipCidrRequest {
+    
+    Cidr: string | undefined;
+}
+export declare namespace DeprovisionByoipCidrRequest {
+    
+    const filterSensitiveLog: (obj: DeprovisionByoipCidrRequest) => any;
+}
+export interface DeprovisionByoipCidrResponse {
+    
+    ByoipCidr?: ByoipCidr;
+}
+export declare namespace DeprovisionByoipCidrResponse {
+    
+    const filterSensitiveLog: (obj: DeprovisionByoipCidrResponse) => any;
+}
+export interface DescribeAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DescribeAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAcceleratorRequest) => any;
+}
+export interface DescribeAcceleratorResponse {
+    
+    Accelerator?: Accelerator;
+}
+export declare namespace DescribeAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAcceleratorResponse) => any;
+}
+export interface DescribeAcceleratorAttributesRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DescribeAcceleratorAttributesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAcceleratorAttributesRequest) => any;
+}
+export interface DescribeAcceleratorAttributesResponse {
+    
+    AcceleratorAttributes?: AcceleratorAttributes;
+}
+export declare namespace DescribeAcceleratorAttributesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAcceleratorAttributesResponse) => any;
+}
+export interface DescribeCustomRoutingAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DescribeCustomRoutingAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingAcceleratorRequest) => any;
+}
+export interface DescribeCustomRoutingAcceleratorResponse {
+    
+    Accelerator?: CustomRoutingAccelerator;
+}
+export declare namespace DescribeCustomRoutingAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingAcceleratorResponse) => any;
+}
+export interface DescribeCustomRoutingAcceleratorAttributesRequest {
+    
+    AcceleratorArn: string | undefined;
+}
+export declare namespace DescribeCustomRoutingAcceleratorAttributesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingAcceleratorAttributesRequest) => any;
+}
+export interface DescribeCustomRoutingAcceleratorAttributesResponse {
+    
+    AcceleratorAttributes?: CustomRoutingAcceleratorAttributes;
+}
+export declare namespace DescribeCustomRoutingAcceleratorAttributesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingAcceleratorAttributesResponse) => any;
+}
+export interface DescribeCustomRoutingEndpointGroupRequest {
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace DescribeCustomRoutingEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingEndpointGroupRequest) => any;
+}
+export interface DescribeCustomRoutingEndpointGroupResponse {
+    
+    EndpointGroup?: CustomRoutingEndpointGroup;
+}
+export declare namespace DescribeCustomRoutingEndpointGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingEndpointGroupResponse) => any;
+}
+export interface DescribeCustomRoutingListenerRequest {
+    
+    ListenerArn: string | undefined;
+}
+export declare namespace DescribeCustomRoutingListenerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingListenerRequest) => any;
+}
+export interface DescribeCustomRoutingListenerResponse {
+    
+    Listener?: CustomRoutingListener;
+}
+export declare namespace DescribeCustomRoutingListenerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomRoutingListenerResponse) => any;
+}
+export interface DescribeEndpointGroupRequest {
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace DescribeEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointGroupRequest) => any;
+}
+export interface DescribeEndpointGroupResponse {
+    
+    EndpointGroup?: EndpointGroup;
+}
+export declare namespace DescribeEndpointGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointGroupResponse) => any;
+}
+export interface DescribeListenerRequest {
+    
+    ListenerArn: string | undefined;
+}
+export declare namespace DescribeListenerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeListenerRequest) => any;
+}
+export interface DescribeListenerResponse {
+    
+    Listener?: Listener;
+}
+export declare namespace DescribeListenerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeListenerResponse) => any;
+}
+
+export interface SocketAddress {
+    
+    IpAddress?: string;
+    
+    Port?: number;
+}
+export declare namespace SocketAddress {
+    
+    const filterSensitiveLog: (obj: SocketAddress) => any;
+}
+
+export interface DestinationPortMapping {
+    
+    AcceleratorArn?: string;
+    
+    AcceleratorSocketAddresses?: SocketAddress[];
+    
+    EndpointGroupArn?: string;
+    
+    EndpointId?: string;
+    
+    EndpointGroupRegion?: string;
+    
+    DestinationSocketAddress?: SocketAddress;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    DestinationTrafficState?: CustomRoutingDestinationTrafficState | string;
+}
+export declare namespace DestinationPortMapping {
+    
+    const filterSensitiveLog: (obj: DestinationPortMapping) => any;
+}
+
+export declare class EndpointNotFoundException extends __BaseException {
+    readonly name: "EndpointNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EndpointNotFoundException, __BaseException>);
+}
+
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
+}
+export interface ListAcceleratorsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAcceleratorsRequest {
+    
+    const filterSensitiveLog: (obj: ListAcceleratorsRequest) => any;
+}
+export interface ListAcceleratorsResponse {
+    
+    Accelerators?: Accelerator[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAcceleratorsResponse {
+    
+    const filterSensitiveLog: (obj: ListAcceleratorsResponse) => any;
+}
+export interface ListByoipCidrsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListByoipCidrsRequest {
+    
+    const filterSensitiveLog: (obj: ListByoipCidrsRequest) => any;
+}
+export interface ListByoipCidrsResponse {
+    
+    ByoipCidrs?: ByoipCidr[];
+    
+    NextToken?: string;
+}
+export declare namespace ListByoipCidrsResponse {
+    
+    const filterSensitiveLog: (obj: ListByoipCidrsResponse) => any;
+}
+export interface ListCustomRoutingAcceleratorsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingAcceleratorsRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingAcceleratorsRequest) => any;
+}
+export interface ListCustomRoutingAcceleratorsResponse {
+    
+    Accelerators?: CustomRoutingAccelerator[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingAcceleratorsResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingAcceleratorsResponse) => any;
+}
+export interface ListCustomRoutingEndpointGroupsRequest {
+    
+    ListenerArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingEndpointGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingEndpointGroupsRequest) => any;
+}
+export interface ListCustomRoutingEndpointGroupsResponse {
+    
+    EndpointGroups?: CustomRoutingEndpointGroup[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingEndpointGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingEndpointGroupsResponse) => any;
+}
+export interface ListCustomRoutingListenersRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingListenersRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingListenersRequest) => any;
+}
+export interface ListCustomRoutingListenersResponse {
+    
+    Listeners?: CustomRoutingListener[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingListenersResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingListenersResponse) => any;
+}
+export interface ListCustomRoutingPortMappingsRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    EndpointGroupArn?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingPortMappingsRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingPortMappingsRequest) => any;
+}
+
+export interface PortMapping {
+    
+    AcceleratorPort?: number;
+    
+    EndpointGroupArn?: string;
+    
+    EndpointId?: string;
+    
+    DestinationSocketAddress?: SocketAddress;
+    
+    Protocols?: (CustomRoutingProtocol | string)[];
+    
+    DestinationTrafficState?: CustomRoutingDestinationTrafficState | string;
+}
+export declare namespace PortMapping {
+    
+    const filterSensitiveLog: (obj: PortMapping) => any;
+}
+export interface ListCustomRoutingPortMappingsResponse {
+    
+    PortMappings?: PortMapping[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingPortMappingsResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingPortMappingsResponse) => any;
+}
+export interface ListCustomRoutingPortMappingsByDestinationRequest {
+    
+    EndpointId: string | undefined;
+    
+    DestinationAddress: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingPortMappingsByDestinationRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingPortMappingsByDestinationRequest) => any;
+}
+export interface ListCustomRoutingPortMappingsByDestinationResponse {
+    
+    DestinationPortMappings?: DestinationPortMapping[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCustomRoutingPortMappingsByDestinationResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomRoutingPortMappingsByDestinationResponse) => any;
+}
+export interface ListEndpointGroupsRequest {
+    
+    ListenerArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListEndpointGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListEndpointGroupsRequest) => any;
+}
+export interface ListEndpointGroupsResponse {
+    
+    EndpointGroups?: EndpointGroup[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEndpointGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListEndpointGroupsResponse) => any;
+}
+export interface ListListenersRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListListenersRequest {
+    
+    const filterSensitiveLog: (obj: ListListenersRequest) => any;
+}
+export interface ListListenersResponse {
+    
+    Listeners?: Listener[];
+    
+    NextToken?: string;
+}
+export declare namespace ListListenersResponse {
+    
+    const filterSensitiveLog: (obj: ListListenersResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ProvisionByoipCidrRequest {
+    
+    Cidr: string | undefined;
+    
+    CidrAuthorizationContext: CidrAuthorizationContext | undefined;
+}
+export declare namespace ProvisionByoipCidrRequest {
+    
+    const filterSensitiveLog: (obj: ProvisionByoipCidrRequest) => any;
+}
+export interface ProvisionByoipCidrResponse {
+    
+    ByoipCidr?: ByoipCidr;
+}
+export declare namespace ProvisionByoipCidrResponse {
+    
+    const filterSensitiveLog: (obj: ProvisionByoipCidrResponse) => any;
+}
+export interface RemoveCustomRoutingEndpointsRequest {
+    
+    EndpointIds: string[] | undefined;
+    
+    EndpointGroupArn: string | undefined;
+}
+export declare namespace RemoveCustomRoutingEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: RemoveCustomRoutingEndpointsRequest) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    Name?: string;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    Enabled?: boolean;
+}
+export declare namespace UpdateAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAcceleratorRequest) => any;
+}
+export interface UpdateAcceleratorResponse {
+    
+    Accelerator?: Accelerator;
+}
+export declare namespace UpdateAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAcceleratorResponse) => any;
+}
+export interface UpdateAcceleratorAttributesRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    FlowLogsEnabled?: boolean;
+    
+    FlowLogsS3Bucket?: string;
+    
+    FlowLogsS3Prefix?: string;
+}
+export declare namespace UpdateAcceleratorAttributesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAcceleratorAttributesRequest) => any;
+}
+export interface UpdateAcceleratorAttributesResponse {
+    
+    AcceleratorAttributes?: AcceleratorAttributes;
+}
+export declare namespace UpdateAcceleratorAttributesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAcceleratorAttributesResponse) => any;
+}
+export interface UpdateCustomRoutingAcceleratorRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    Name?: string;
+    
+    IpAddressType?: IpAddressType | string;
+    
+    Enabled?: boolean;
+}
+export declare namespace UpdateCustomRoutingAcceleratorRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingAcceleratorRequest) => any;
+}
+export interface UpdateCustomRoutingAcceleratorResponse {
+    
+    Accelerator?: CustomRoutingAccelerator;
+}
+export declare namespace UpdateCustomRoutingAcceleratorResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingAcceleratorResponse) => any;
+}
+export interface UpdateCustomRoutingAcceleratorAttributesRequest {
+    
+    AcceleratorArn: string | undefined;
+    
+    FlowLogsEnabled?: boolean;
+    
+    FlowLogsS3Bucket?: string;
+    
+    FlowLogsS3Prefix?: string;
+}
+export declare namespace UpdateCustomRoutingAcceleratorAttributesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingAcceleratorAttributesRequest) => any;
+}
+export interface UpdateCustomRoutingAcceleratorAttributesResponse {
+    
+    AcceleratorAttributes?: CustomRoutingAcceleratorAttributes;
+}
+export declare namespace UpdateCustomRoutingAcceleratorAttributesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingAcceleratorAttributesResponse) => any;
+}
+export interface UpdateCustomRoutingListenerRequest {
+    
+    ListenerArn: string | undefined;
+    
+    PortRanges: PortRange[] | undefined;
+}
+export declare namespace UpdateCustomRoutingListenerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingListenerRequest) => any;
+}
+export interface UpdateCustomRoutingListenerResponse {
+    
+    Listener?: CustomRoutingListener;
+}
+export declare namespace UpdateCustomRoutingListenerResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCustomRoutingListenerResponse) => any;
+}
+export interface UpdateEndpointGroupRequest {
+    
+    EndpointGroupArn: string | undefined;
+    
+    EndpointConfigurations?: EndpointConfiguration[];
+    
+    TrafficDialPercentage?: number;
+    
+    HealthCheckPort?: number;
+    
+    HealthCheckProtocol?: HealthCheckProtocol | string;
+    
+    HealthCheckPath?: string;
+    
+    HealthCheckIntervalSeconds?: number;
+    
+    ThresholdCount?: number;
+    
+    PortOverrides?: PortOverride[];
+}
+export declare namespace UpdateEndpointGroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointGroupRequest) => any;
+}
+export interface UpdateEndpointGroupResponse {
+    
+    EndpointGroup?: EndpointGroup;
+}
+export declare namespace UpdateEndpointGroupResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointGroupResponse) => any;
+}
+export interface UpdateListenerRequest {
+    
+    ListenerArn: string | undefined;
+    
+    PortRanges?: PortRange[];
+    
+    Protocol?: Protocol | string;
+    
+    ClientAffinity?: ClientAffinity | string;
+}
+export declare namespace UpdateListenerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateListenerRequest) => any;
+}
+export interface UpdateListenerResponse {
+    
+    Listener?: Listener;
+}
+export declare namespace UpdateListenerResponse {
+    
+    const filterSensitiveLog: (obj: UpdateListenerResponse) => any;
+}
+export interface WithdrawByoipCidrRequest {
+    
+    Cidr: string | undefined;
+}
+export declare namespace WithdrawByoipCidrRequest {
+    
+    const filterSensitiveLog: (obj: WithdrawByoipCidrRequest) => any;
+}
+export interface WithdrawByoipCidrResponse {
+    
+    ByoipCidr?: ByoipCidr;
+}
+export declare namespace WithdrawByoipCidrResponse {
+    
+    const filterSensitiveLog: (obj: WithdrawByoipCidrResponse) => any;
+}