import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const svc = T.AwsApiService({
    sdkId: "Global Accelerator",
    serviceShapeName: "GlobalAccelerator_V20180706",
});
const auth = T.AwsAuthSigv4({ name: "globalaccelerator" });
const ver = T.ServiceVersion("2018-08-08");
const proto = T.AwsProtocolsAwsJson1_1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://globalaccelerator-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://globalaccelerator-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://globalaccelerator.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://globalaccelerator.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const CustomRoutingEndpointConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(S.String),
    AttachmentArn: S.optional(S.String),
})).annotate({
    identifier: "CustomRoutingEndpointConfiguration",
});
export const CustomRoutingEndpointConfigurations = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingEndpointConfiguration);
export const AddCustomRoutingEndpointsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointConfigurations: CustomRoutingEndpointConfigurations,
    EndpointGroupArn: S.String,
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AddCustomRoutingEndpointsRequest",
});
export const CustomRoutingEndpointDescription = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointId: S.optional(S.String) })).annotate({
    identifier: "CustomRoutingEndpointDescription",
});
export const CustomRoutingEndpointDescriptions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingEndpointDescription);
export const AddCustomRoutingEndpointsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointDescriptions: S.optional(CustomRoutingEndpointDescriptions),
    EndpointGroupArn: S.optional(S.String),
})).annotate({
    identifier: "AddCustomRoutingEndpointsResponse",
});
export const EndpointConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(S.String),
    Weight: S.optional(S.Number),
    ClientIPPreservationEnabled: S.optional(S.Boolean),
    AttachmentArn: S.optional(S.String),
})).annotate({
    identifier: "EndpointConfiguration",
});
export const EndpointConfigurations = /*@__PURE__*/ /*#__PURE__*/ S.Array(EndpointConfiguration);
export const AddEndpointsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointConfigurations: EndpointConfigurations,
    EndpointGroupArn: S.String,
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AddEndpointsRequest",
});
export const HealthState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const EndpointDescription = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(S.String),
    Weight: S.optional(S.Number),
    HealthState: S.optional(HealthState),
    HealthReason: S.optional(S.String),
    ClientIPPreservationEnabled: S.optional(S.Boolean),
})).annotate({
    identifier: "EndpointDescription",
});
export const EndpointDescriptions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EndpointDescription);
export const AddEndpointsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointDescriptions: S.optional(EndpointDescriptions),
    EndpointGroupArn: S.optional(S.String),
})).annotate({
    identifier: "AddEndpointsResponse",
});
export const AdvertiseByoipCidrRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cidr: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AdvertiseByoipCidrRequest",
});
export const ByoipCidrState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ByoipCidrEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Message: S.optional(S.String),
    Timestamp: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "ByoipCidrEvent" });
export const ByoipCidrEvents = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ByoipCidrEvent);
export const ByoipCidr = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Cidr: S.optional(S.String),
    State: S.optional(ByoipCidrState),
    Events: S.optional(ByoipCidrEvents),
})).annotate({ identifier: "ByoipCidr" });
export const AdvertiseByoipCidrResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ByoipCidr: S.optional(ByoipCidr) })).annotate({
    identifier: "AdvertiseByoipCidrResponse",
});
export const DestinationAddresses = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DestinationPorts = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.Number);
export const AllowCustomRoutingTrafficRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroupArn: S.String,
    EndpointId: S.String,
    DestinationAddresses: S.optional(DestinationAddresses),
    DestinationPorts: S.optional(DestinationPorts),
    AllowAllTrafficToEndpoint: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "AllowCustomRoutingTrafficRequest",
});
export const AllowCustomRoutingTrafficResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "AllowCustomRoutingTrafficResponse",
});
export const IpAddressType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const IpAddresses = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Value: S.String })).annotate({ identifier: "Tag" });
export const Tags = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const CreateAcceleratorRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    IpAddressType: S.optional(IpAddressType),
    IpAddresses: S.optional(IpAddresses),
    Enabled: S.optional(S.Boolean),
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
    Tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateAcceleratorRequest",
});
export const IpAddressFamily = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const IpSet = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    IpFamily: S.optional(S.String),
    IpAddresses: S.optional(IpAddresses),
    IpAddressFamily: S.optional(IpAddressFamily),
})).annotate({ identifier: "IpSet" });
export const IpSets = /*@__PURE__*/ /*#__PURE__*/ S.Array(IpSet);
export const AcceleratorStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AcceleratorEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Message: S.optional(S.String),
    Timestamp: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "AcceleratorEvent",
});
export const AcceleratorEvents = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(AcceleratorEvent);
export const Accelerator = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.optional(S.String),
    Name: S.optional(S.String),
    IpAddressType: S.optional(IpAddressType),
    Enabled: S.optional(S.Boolean),
    IpSets: S.optional(IpSets),
    DnsName: S.optional(S.String),
    Status: S.optional(AcceleratorStatus),
    CreatedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    DualStackDnsName: S.optional(S.String),
    Events: S.optional(AcceleratorEvents),
})).annotate({ identifier: "Accelerator" });
export const CreateAcceleratorResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(Accelerator) })).annotate({
    identifier: "CreateAcceleratorResponse",
});
export const Principals = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Resource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(S.String),
    Cidr: S.optional(S.String),
    Region: S.optional(S.String),
})).annotate({ identifier: "Resource" });
export const Resources = /*@__PURE__*/ /*#__PURE__*/ S.Array(Resource);
export const CreateCrossAccountAttachmentRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    Principals: S.optional(Principals),
    Resources: S.optional(Resources),
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
    Tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateCrossAccountAttachmentRequest",
});
export const Attachment = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AttachmentArn: S.optional(S.String),
    Name: S.optional(S.String),
    Principals: S.optional(Principals),
    Resources: S.optional(Resources),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    CreatedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Attachment" });
export const CreateCrossAccountAttachmentResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CrossAccountAttachment: S.optional(Attachment) })).annotate({
    identifier: "CreateCrossAccountAttachmentResponse",
});
export const CreateCustomRoutingAcceleratorRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String,
    IpAddressType: S.optional(IpAddressType),
    IpAddresses: S.optional(IpAddresses),
    Enabled: S.optional(S.Boolean),
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
    Tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateCustomRoutingAcceleratorRequest",
});
export const CustomRoutingAcceleratorStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const CustomRoutingAccelerator = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.optional(S.String),
    Name: S.optional(S.String),
    IpAddressType: S.optional(IpAddressType),
    Enabled: S.optional(S.Boolean),
    IpSets: S.optional(IpSets),
    DnsName: S.optional(S.String),
    Status: S.optional(CustomRoutingAcceleratorStatus),
    CreatedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "CustomRoutingAccelerator",
});
export const CreateCustomRoutingAcceleratorResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(CustomRoutingAccelerator) })).annotate({
    identifier: "CreateCustomRoutingAcceleratorResponse",
});
export const CustomRoutingProtocol = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CustomRoutingProtocols = /*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingProtocol);
export const CustomRoutingDestinationConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FromPort: S.Number,
    ToPort: S.Number,
    Protocols: CustomRoutingProtocols,
})).annotate({
    identifier: "CustomRoutingDestinationConfiguration",
});
export const CustomRoutingDestinationConfigurations = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingDestinationConfiguration);
export const CreateCustomRoutingEndpointGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.String,
    EndpointGroupRegion: S.String,
    DestinationConfigurations: CustomRoutingDestinationConfigurations,
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateCustomRoutingEndpointGroupRequest",
});
export const Protocol = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Protocols = /*@__PURE__*/ /*#__PURE__*/ S.Array(Protocol);
export const CustomRoutingDestinationDescription = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FromPort: S.optional(S.Number),
    ToPort: S.optional(S.Number),
    Protocols: S.optional(Protocols),
})).annotate({
    identifier: "CustomRoutingDestinationDescription",
});
export const CustomRoutingDestinationDescriptions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingDestinationDescription);
export const CustomRoutingEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroupArn: S.optional(S.String),
    EndpointGroupRegion: S.optional(S.String),
    DestinationDescriptions: S.optional(CustomRoutingDestinationDescriptions),
    EndpointDescriptions: S.optional(CustomRoutingEndpointDescriptions),
})).annotate({
    identifier: "CustomRoutingEndpointGroup",
});
export const CreateCustomRoutingEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroup: S.optional(CustomRoutingEndpointGroup) })).annotate({
    identifier: "CreateCustomRoutingEndpointGroupResponse",
});
export const PortRange = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ FromPort: S.optional(S.Number), ToPort: S.optional(S.Number) })).annotate({ identifier: "PortRange" });
export const PortRanges = /*@__PURE__*/ /*#__PURE__*/ S.Array(PortRange);
export const CreateCustomRoutingListenerRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    PortRanges: PortRanges,
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateCustomRoutingListenerRequest",
});
export const CustomRoutingListener = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.optional(S.String),
    PortRanges: S.optional(PortRanges),
})).annotate({
    identifier: "CustomRoutingListener",
});
export const CreateCustomRoutingListenerResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(CustomRoutingListener) })).annotate({
    identifier: "CreateCustomRoutingListenerResponse",
});
export const HealthCheckProtocol = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PortOverride = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerPort: S.optional(S.Number),
    EndpointPort: S.optional(S.Number),
})).annotate({ identifier: "PortOverride" });
export const PortOverrides = /*@__PURE__*/ /*#__PURE__*/ S.Array(PortOverride);
export const CreateEndpointGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.String,
    EndpointGroupRegion: S.String,
    EndpointConfigurations: S.optional(EndpointConfigurations),
    TrafficDialPercentage: S.optional(S.Number),
    HealthCheckPort: S.optional(S.Number),
    HealthCheckProtocol: S.optional(HealthCheckProtocol),
    HealthCheckPath: S.optional(S.String),
    HealthCheckIntervalSeconds: S.optional(S.Number),
    ThresholdCount: S.optional(S.Number),
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
    PortOverrides: S.optional(PortOverrides),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateEndpointGroupRequest",
});
export const EndpointGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroupArn: S.optional(S.String),
    EndpointGroupRegion: S.optional(S.String),
    EndpointDescriptions: S.optional(EndpointDescriptions),
    TrafficDialPercentage: S.optional(S.Number),
    HealthCheckPort: S.optional(S.Number),
    HealthCheckProtocol: S.optional(HealthCheckProtocol),
    HealthCheckPath: S.optional(S.String),
    HealthCheckIntervalSeconds: S.optional(S.Number),
    ThresholdCount: S.optional(S.Number),
    PortOverrides: S.optional(PortOverrides),
})).annotate({ identifier: "EndpointGroup" });
export const CreateEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroup: S.optional(EndpointGroup) })).annotate({
    identifier: "CreateEndpointGroupResponse",
});
export const ClientAffinity = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateListenerRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    PortRanges: PortRanges,
    Protocol: Protocol,
    ClientAffinity: S.optional(ClientAffinity),
    IdempotencyToken: S.String.pipe(T.IdempotencyToken()),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateListenerRequest",
});
export const Listener = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.optional(S.String),
    PortRanges: S.optional(PortRanges),
    Protocol: S.optional(Protocol),
    ClientAffinity: S.optional(ClientAffinity),
})).annotate({ identifier: "Listener" });
export const CreateListenerResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(Listener) })).annotate({
    identifier: "CreateListenerResponse",
});
export const DeleteAcceleratorRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteAcceleratorRequest",
});
export const DeleteAcceleratorResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteAcceleratorResponse",
});
export const DeleteCrossAccountAttachmentRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AttachmentArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteCrossAccountAttachmentRequest",
});
export const DeleteCrossAccountAttachmentResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteCrossAccountAttachmentResponse",
});
export const DeleteCustomRoutingAcceleratorRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteCustomRoutingAcceleratorRequest",
});
export const DeleteCustomRoutingAcceleratorResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteCustomRoutingAcceleratorResponse",
});
export const DeleteCustomRoutingEndpointGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroupArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteCustomRoutingEndpointGroupRequest",
});
export const DeleteCustomRoutingEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteCustomRoutingEndpointGroupResponse",
});
export const DeleteCustomRoutingListenerRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ListenerArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteCustomRoutingListenerRequest",
});
export const DeleteCustomRoutingListenerResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteCustomRoutingListenerResponse",
});
export const DeleteEndpointGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroupArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteEndpointGroupRequest",
});
export const DeleteEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteEndpointGroupResponse",
});
export const DeleteListenerRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ListenerArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteListenerRequest",
});
export const DeleteListenerResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteListenerResponse",
});
export const DenyCustomRoutingTrafficRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroupArn: S.String,
    EndpointId: S.String,
    DestinationAddresses: S.optional(DestinationAddresses),
    DestinationPorts: S.optional(DestinationPorts),
    DenyAllTrafficToEndpoint: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DenyCustomRoutingTrafficRequest",
});
export const DenyCustomRoutingTrafficResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DenyCustomRoutingTrafficResponse",
});
export const DeprovisionByoipCidrRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cidr: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeprovisionByoipCidrRequest",
});
export const DeprovisionByoipCidrResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ByoipCidr: S.optional(ByoipCidr) })).annotate({
    identifier: "DeprovisionByoipCidrResponse",
});
export const DescribeAcceleratorRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeAcceleratorRequest",
});
export const DescribeAcceleratorResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(Accelerator) })).annotate({
    identifier: "DescribeAcceleratorResponse",
});
export const DescribeAcceleratorAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeAcceleratorAttributesRequest",
});
export const AcceleratorAttributes = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FlowLogsEnabled: S.optional(S.Boolean),
    FlowLogsS3Bucket: S.optional(S.String),
    FlowLogsS3Prefix: S.optional(S.String),
})).annotate({
    identifier: "AcceleratorAttributes",
});
export const DescribeAcceleratorAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorAttributes: S.optional(AcceleratorAttributes) })).annotate({
    identifier: "DescribeAcceleratorAttributesResponse",
});
export const DescribeCrossAccountAttachmentRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AttachmentArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeCrossAccountAttachmentRequest",
});
export const DescribeCrossAccountAttachmentResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CrossAccountAttachment: S.optional(Attachment) })).annotate({
    identifier: "DescribeCrossAccountAttachmentResponse",
});
export const DescribeCustomRoutingAcceleratorRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeCustomRoutingAcceleratorRequest",
});
export const DescribeCustomRoutingAcceleratorResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(CustomRoutingAccelerator) })).annotate({
    identifier: "DescribeCustomRoutingAcceleratorResponse",
});
export const DescribeCustomRoutingAcceleratorAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeCustomRoutingAcceleratorAttributesRequest",
});
export const CustomRoutingAcceleratorAttributes = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FlowLogsEnabled: S.optional(S.Boolean),
    FlowLogsS3Bucket: S.optional(S.String),
    FlowLogsS3Prefix: S.optional(S.String),
})).annotate({
    identifier: "CustomRoutingAcceleratorAttributes",
});
export const DescribeCustomRoutingAcceleratorAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorAttributes: S.optional(CustomRoutingAcceleratorAttributes),
})).annotate({
    identifier: "DescribeCustomRoutingAcceleratorAttributesResponse",
});
export const DescribeCustomRoutingEndpointGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroupArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeCustomRoutingEndpointGroupRequest",
});
export const DescribeCustomRoutingEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroup: S.optional(CustomRoutingEndpointGroup) })).annotate({
    identifier: "DescribeCustomRoutingEndpointGroupResponse",
});
export const DescribeCustomRoutingListenerRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ListenerArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeCustomRoutingListenerRequest",
});
export const DescribeCustomRoutingListenerResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(CustomRoutingListener) })).annotate({
    identifier: "DescribeCustomRoutingListenerResponse",
});
export const DescribeEndpointGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroupArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeEndpointGroupRequest",
});
export const DescribeEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroup: S.optional(EndpointGroup) })).annotate({
    identifier: "DescribeEndpointGroupResponse",
});
export const DescribeListenerRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ListenerArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeListenerRequest",
});
export const DescribeListenerResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(Listener) })).annotate({
    identifier: "DescribeListenerResponse",
});
export const ListAcceleratorsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListAcceleratorsRequest",
});
export const Accelerators = /*@__PURE__*/ /*#__PURE__*/ S.Array(Accelerator);
export const ListAcceleratorsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Accelerators: S.optional(Accelerators),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListAcceleratorsResponse",
});
export const ListByoipCidrsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListByoipCidrsRequest",
});
export const ByoipCidrs = /*@__PURE__*/ /*#__PURE__*/ S.Array(ByoipCidr);
export const ListByoipCidrsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ByoipCidrs: S.optional(ByoipCidrs),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListByoipCidrsResponse",
});
export const ListCrossAccountAttachmentsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCrossAccountAttachmentsRequest",
});
export const Attachments = /*@__PURE__*/ /*#__PURE__*/ S.Array(Attachment);
export const ListCrossAccountAttachmentsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossAccountAttachments: S.optional(Attachments),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCrossAccountAttachmentsResponse",
});
export const ListCrossAccountResourceAccountsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCrossAccountResourceAccountsRequest",
});
export const AwsAccountIds = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ListCrossAccountResourceAccountsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceOwnerAwsAccountIds: S.optional(AwsAccountIds) })).annotate({
    identifier: "ListCrossAccountResourceAccountsResponse",
});
export const ListCrossAccountResourcesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.optional(S.String),
    ResourceOwnerAwsAccountId: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCrossAccountResourcesRequest",
});
export const CrossAccountResource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(S.String),
    Cidr: S.optional(S.String),
    AttachmentArn: S.optional(S.String),
})).annotate({
    identifier: "CrossAccountResource",
});
export const CrossAccountResources = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CrossAccountResource);
export const ListCrossAccountResourcesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossAccountResources: S.optional(CrossAccountResources),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCrossAccountResourcesResponse",
});
export const ListCustomRoutingAcceleratorsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCustomRoutingAcceleratorsRequest",
});
export const CustomRoutingAccelerators = /*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingAccelerator);
export const ListCustomRoutingAcceleratorsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Accelerators: S.optional(CustomRoutingAccelerators),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCustomRoutingAcceleratorsResponse",
});
export const ListCustomRoutingEndpointGroupsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCustomRoutingEndpointGroupsRequest",
});
export const CustomRoutingEndpointGroups = /*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingEndpointGroup);
export const ListCustomRoutingEndpointGroupsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroups: S.optional(CustomRoutingEndpointGroups),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCustomRoutingEndpointGroupsResponse",
});
export const ListCustomRoutingListenersRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCustomRoutingListenersRequest",
});
export const CustomRoutingListeners = /*@__PURE__*/ /*#__PURE__*/ S.Array(CustomRoutingListener);
export const ListCustomRoutingListenersResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Listeners: S.optional(CustomRoutingListeners),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCustomRoutingListenersResponse",
});
export const ListCustomRoutingPortMappingsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    EndpointGroupArn: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCustomRoutingPortMappingsRequest",
});
export const SocketAddress = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ IpAddress: S.optional(S.String), Port: S.optional(S.Number) })).annotate({ identifier: "SocketAddress" });
export const CustomRoutingDestinationTrafficState = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const PortMapping = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorPort: S.optional(S.Number),
    EndpointGroupArn: S.optional(S.String),
    EndpointId: S.optional(S.String),
    DestinationSocketAddress: S.optional(SocketAddress),
    Protocols: S.optional(CustomRoutingProtocols),
    DestinationTrafficState: S.optional(CustomRoutingDestinationTrafficState),
})).annotate({ identifier: "PortMapping" });
export const PortMappings = /*@__PURE__*/ /*#__PURE__*/ S.Array(PortMapping);
export const ListCustomRoutingPortMappingsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PortMappings: S.optional(PortMappings),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCustomRoutingPortMappingsResponse",
});
export const ListCustomRoutingPortMappingsByDestinationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.String,
    DestinationAddress: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCustomRoutingPortMappingsByDestinationRequest",
});
export const SocketAddresses = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SocketAddress);
export const DestinationPortMapping = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.optional(S.String),
    AcceleratorSocketAddresses: S.optional(SocketAddresses),
    EndpointGroupArn: S.optional(S.String),
    EndpointId: S.optional(S.String),
    EndpointGroupRegion: S.optional(S.String),
    DestinationSocketAddress: S.optional(SocketAddress),
    IpAddressType: S.optional(IpAddressType),
    DestinationTrafficState: S.optional(CustomRoutingDestinationTrafficState),
})).annotate({
    identifier: "DestinationPortMapping",
});
export const DestinationPortMappings = /*@__PURE__*/ /*#__PURE__*/ S.Array(DestinationPortMapping);
export const ListCustomRoutingPortMappingsByDestinationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DestinationPortMappings: S.optional(DestinationPortMappings),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCustomRoutingPortMappingsByDestinationResponse",
});
export const ListEndpointGroupsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListEndpointGroupsRequest",
});
export const EndpointGroups = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EndpointGroup);
export const ListEndpointGroupsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroups: S.optional(EndpointGroups),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListEndpointGroupsResponse",
});
export const ListListenersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListListenersRequest",
});
export const Listeners = /*@__PURE__*/ /*#__PURE__*/ S.Array(Listener);
export const ListListenersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Listeners: S.optional(Listeners),
    NextToken: S.optional(S.String),
})).annotate({
    identifier: "ListListenersResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Tags: S.optional(Tags) })).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const CidrAuthorizationContext = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Message: S.String, Signature: S.String })).annotate({
    identifier: "CidrAuthorizationContext",
});
export const ProvisionByoipCidrRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Cidr: S.String,
    CidrAuthorizationContext: CidrAuthorizationContext,
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ProvisionByoipCidrRequest",
});
export const ProvisionByoipCidrResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ByoipCidr: S.optional(ByoipCidr) })).annotate({
    identifier: "ProvisionByoipCidrResponse",
});
export const EndpointIds = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const RemoveCustomRoutingEndpointsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointIds: EndpointIds, EndpointGroupArn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RemoveCustomRoutingEndpointsRequest",
});
export const RemoveCustomRoutingEndpointsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "RemoveCustomRoutingEndpointsResponse",
});
export const EndpointIdentifier = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.String,
    ClientIPPreservationEnabled: S.optional(S.Boolean),
})).annotate({
    identifier: "EndpointIdentifier",
});
export const EndpointIdentifiers = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EndpointIdentifier);
export const RemoveEndpointsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointIdentifiers: EndpointIdentifiers,
    EndpointGroupArn: S.String,
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RemoveEndpointsRequest",
});
export const RemoveEndpointsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "RemoveEndpointsResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String, Tags: Tags }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeys = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String, TagKeys: TagKeys }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateAcceleratorRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    Name: S.optional(S.String),
    IpAddressType: S.optional(IpAddressType),
    IpAddresses: S.optional(IpAddresses),
    Enabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateAcceleratorRequest",
});
export const UpdateAcceleratorResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(Accelerator) })).annotate({
    identifier: "UpdateAcceleratorResponse",
});
export const UpdateAcceleratorAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    FlowLogsEnabled: S.optional(S.Boolean),
    FlowLogsS3Bucket: S.optional(S.String),
    FlowLogsS3Prefix: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateAcceleratorAttributesRequest",
});
export const UpdateAcceleratorAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AcceleratorAttributes: S.optional(AcceleratorAttributes) })).annotate({
    identifier: "UpdateAcceleratorAttributesResponse",
});
export const UpdateCrossAccountAttachmentRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AttachmentArn: S.String,
    Name: S.optional(S.String),
    AddPrincipals: S.optional(Principals),
    RemovePrincipals: S.optional(Principals),
    AddResources: S.optional(Resources),
    RemoveResources: S.optional(Resources),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateCrossAccountAttachmentRequest",
});
export const UpdateCrossAccountAttachmentResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CrossAccountAttachment: S.optional(Attachment) })).annotate({
    identifier: "UpdateCrossAccountAttachmentResponse",
});
export const UpdateCustomRoutingAcceleratorRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    Name: S.optional(S.String),
    IpAddressType: S.optional(IpAddressType),
    IpAddresses: S.optional(IpAddresses),
    Enabled: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateCustomRoutingAcceleratorRequest",
});
export const UpdateCustomRoutingAcceleratorResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Accelerator: S.optional(CustomRoutingAccelerator) })).annotate({
    identifier: "UpdateCustomRoutingAcceleratorResponse",
});
export const UpdateCustomRoutingAcceleratorAttributesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorArn: S.String,
    FlowLogsEnabled: S.optional(S.Boolean),
    FlowLogsS3Bucket: S.optional(S.String),
    FlowLogsS3Prefix: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateCustomRoutingAcceleratorAttributesRequest",
});
export const UpdateCustomRoutingAcceleratorAttributesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AcceleratorAttributes: S.optional(CustomRoutingAcceleratorAttributes),
})).annotate({
    identifier: "UpdateCustomRoutingAcceleratorAttributesResponse",
});
export const UpdateCustomRoutingListenerRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ListenerArn: S.String, PortRanges: PortRanges }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateCustomRoutingListenerRequest",
});
export const UpdateCustomRoutingListenerResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(CustomRoutingListener) })).annotate({
    identifier: "UpdateCustomRoutingListenerResponse",
});
export const UpdateEndpointGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointGroupArn: S.String,
    EndpointConfigurations: S.optional(EndpointConfigurations),
    TrafficDialPercentage: S.optional(S.Number),
    HealthCheckPort: S.optional(S.Number),
    HealthCheckProtocol: S.optional(HealthCheckProtocol),
    HealthCheckPath: S.optional(S.String),
    HealthCheckIntervalSeconds: S.optional(S.Number),
    ThresholdCount: S.optional(S.Number),
    PortOverrides: S.optional(PortOverrides),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateEndpointGroupRequest",
});
export const UpdateEndpointGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ EndpointGroup: S.optional(EndpointGroup) })).annotate({
    identifier: "UpdateEndpointGroupResponse",
});
export const UpdateListenerRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ListenerArn: S.String,
    PortRanges: S.optional(PortRanges),
    Protocol: S.optional(Protocol),
    ClientAffinity: S.optional(ClientAffinity),
}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateListenerRequest",
});
export const UpdateListenerResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Listener: S.optional(Listener) })).annotate({
    identifier: "UpdateListenerResponse",
});
export const WithdrawByoipCidrRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cidr: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "WithdrawByoipCidrRequest",
});
export const WithdrawByoipCidrResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ByoipCidr: S.optional(ByoipCidr) })).annotate({
    identifier: "WithdrawByoipCidrResponse",
});
//# Errors
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", { Message: S.optional(S.String) }).pipe(C.withAuthError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { Message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class EndpointAlreadyExistsException extends S.TaggedErrorClass()("EndpointAlreadyExistsException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class EndpointGroupNotFoundException extends S.TaggedErrorClass()("EndpointGroupNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class InternalServiceErrorException extends S.TaggedErrorClass()("InternalServiceErrorException", { Message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class InvalidArgumentException extends S.TaggedErrorClass()("InvalidArgumentException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", { Message: S.optional(S.String) }).pipe(C.withAuthError) {
}
export class TransactionInProgressException extends S.TaggedErrorClass()("TransactionInProgressException", { Message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class ByoipCidrNotFoundException extends S.TaggedErrorClass()("ByoipCidrNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class IncorrectCidrStateException extends S.TaggedErrorClass()("IncorrectCidrStateException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AcceleratorNotFoundException extends S.TaggedErrorClass()("AcceleratorNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class EndpointGroupAlreadyExistsException extends S.TaggedErrorClass()("EndpointGroupAlreadyExistsException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class InvalidPortRangeException extends S.TaggedErrorClass()("InvalidPortRangeException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ListenerNotFoundException extends S.TaggedErrorClass()("ListenerNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AcceleratorNotDisabledException extends S.TaggedErrorClass()("AcceleratorNotDisabledException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AssociatedListenerFoundException extends S.TaggedErrorClass()("AssociatedListenerFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AttachmentNotFoundException extends S.TaggedErrorClass()("AttachmentNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AssociatedEndpointGroupFoundException extends S.TaggedErrorClass()("AssociatedEndpointGroupFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class InvalidNextTokenException extends S.TaggedErrorClass()("InvalidNextTokenException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class EndpointNotFoundException extends S.TaggedErrorClass()("EndpointNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * Associate a virtual private cloud (VPC) subnet endpoint with your custom routing accelerator.
 *
 * The listener port range must be large enough to support the number of IP addresses that can be
 * specified in your subnet. The number of ports required is: subnet size times the number
 * of ports per destination EC2 instances. For example, a subnet defined as /24 requires a listener
 * port range of at least 255 ports.
 *
 * Note: You must have enough remaining listener ports available to
 * map to the subnet ports, or the call will fail with a LimitExceededException.
 *
 * By default, all destinations in a subnet in a custom routing accelerator cannot receive traffic. To enable all
 * destinations to receive traffic, or to specify individual port mappings that can receive
 * traffic, see the
 * AllowCustomRoutingTraffic operation.
 */
export const addCustomRoutingEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AddCustomRoutingEndpointsRequest,
    output: AddCustomRoutingEndpointsResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        EndpointAlreadyExistsException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
    ],
}));
/**
 * Add endpoints to an endpoint group. The `AddEndpoints` API operation is the recommended option for adding endpoints. The
 * alternative options are to add endpoints when you create an endpoint group (with the
 * CreateEndpointGroup API)
 * or when you update an endpoint group (with the
 * UpdateEndpointGroup API).
 *
 * There are two advantages to using `AddEndpoints` to add endpoints in Global Accelerator:
 *
 * - It's faster, because Global Accelerator only has to resolve the new endpoints that
 * you're adding, rather than resolving new and existing endpoints.
 *
 * - It's more convenient, because you don't need to specify the current
 * endpoints that are already in the endpoint group, in addition to the new endpoints that
 * you want to add.
 *
 * For information about endpoint types and requirements for endpoints that you can add
 * to Global Accelerator, see
 * Endpoints for standard accelerators in the *Global Accelerator Developer Guide*.
 */
export const addEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AddEndpointsRequest,
    output: AddEndpointsResponse,
    errors: [
        AccessDeniedException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        TransactionInProgressException,
    ],
}));
/**
 * Advertises an IPv4 address range that is provisioned for use with your Amazon Web Services resources
 * through bring your own IP addresses (BYOIP). It can take a few minutes before traffic to
 * the specified addresses starts routing to Amazon Web Services because of propagation delays.
 *
 * To stop advertising the BYOIP address range, use
 * WithdrawByoipCidr.
 *
 * For more information, see Bring your own
 * IP addresses (BYOIP) in the *Global Accelerator Developer Guide*.
 */
export const advertiseByoipCidr = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AdvertiseByoipCidrRequest,
    output: AdvertiseByoipCidrResponse,
    errors: [
        AccessDeniedException,
        ByoipCidrNotFoundException,
        IncorrectCidrStateException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Specify the Amazon EC2 instance (destination) IP addresses and ports for a VPC subnet endpoint that can receive traffic
 * for a custom routing accelerator. You can allow traffic to all destinations in the subnet endpoint, or allow traffic to a
 * specified list of destination IP addresses and ports in the subnet. Note that you cannot specify IP addresses or ports
 * outside of the range that you configured for the endpoint group.
 *
 * After you make changes, you can verify that the updates are complete by checking the status of your
 * accelerator: the status changes from IN_PROGRESS to DEPLOYED.
 */
export const allowCustomRoutingTraffic = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AllowCustomRoutingTrafficRequest,
    output: AllowCustomRoutingTrafficResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Create an accelerator. An accelerator includes one or more listeners that process inbound connections and direct traffic
 * to one or more endpoint groups, each of which includes endpoints, such as Network Load Balancers.
 *
 * Global Accelerator is a global service that supports endpoints in multiple Amazon Web Services Regions but you must specify the
 * US West (Oregon) Region to create, update, or otherwise work with accelerators. That is, for example, specify `--region us-west-2`
 * on Amazon Web Services CLI commands.
 */
export const createAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateAcceleratorRequest,
    output: CreateAcceleratorResponse,
    errors: [
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        TransactionInProgressException,
    ],
}));
/**
 * Create a cross-account attachment in Global Accelerator. You create a cross-account attachment to
 * specify the *principals* who have permission to work with *resources*
 * in accelerators in their own account. You specify, in the same attachment, the resources that are shared.
 *
 * A principal can be an Amazon Web Services account number or the Amazon Resource Name (ARN) for an
 * accelerator. For account numbers that are listed as principals, to work with a resource listed in the attachment,
 * you must sign in to an account specified as a principal. Then, you can work with resources that are listed,
 * with any of your accelerators. If an accelerator ARN is listed in the cross-account attachment as a principal,
 * anyone with permission to make updates to the accelerator can work with resources that are listed in the
 * attachment.
 *
 * Specify each principal and resource separately. To specify two CIDR address pools, list
 * them individually under `Resources`, and so on. For a command line operation, for example,
 * you might use a statement like the following:
 *
 * ` "Resources": [{"Cidr": "169.254.60.0/24"},{"Cidr": "169.254.59.0/24"}]`
 *
 * For more information, see
 * Working with cross-account attachments and resources in Global Accelerator in the
 * Global Accelerator Developer Guide.
 */
export const createCrossAccountAttachment = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateCrossAccountAttachmentRequest,
    output: CreateCrossAccountAttachmentResponse,
    errors: [
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        TransactionInProgressException,
    ],
}));
/**
 * Create a custom routing accelerator. A custom routing accelerator directs traffic to one of possibly thousands
 * of Amazon EC2 instance destinations running in a single or multiple virtual private clouds (VPC) subnet endpoints.
 *
 * Be aware that, by default, all destination EC2 instances in a VPC subnet endpoint cannot receive
 * traffic. To enable all destinations to receive traffic, or to specify individual port
 * mappings that can receive traffic, see the
 * AllowCustomRoutingTraffic operation.
 *
 * Global Accelerator is a global service that supports endpoints in multiple Amazon Web Services Regions but you must specify the
 * US West (Oregon) Region to create, update, or otherwise work with accelerators. That is, for example, specify `--region us-west-2`
 * on Amazon Web Services CLI commands.
 */
export const createCustomRoutingAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateCustomRoutingAcceleratorRequest,
    output: CreateCustomRoutingAcceleratorResponse,
    errors: [
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        TransactionInProgressException,
    ],
}));
/**
 * Create an endpoint group for the specified listener for a custom routing accelerator.
 * An endpoint group is a collection of endpoints in one Amazon Web Services
 * Region.
 */
export const createCustomRoutingEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateCustomRoutingEndpointGroupRequest,
    output: CreateCustomRoutingEndpointGroupResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        EndpointGroupAlreadyExistsException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidPortRangeException,
        LimitExceededException,
        ListenerNotFoundException,
    ],
}));
/**
 * Create a listener to process inbound connections from clients to a custom routing accelerator.
 * Connections arrive to assigned static IP addresses on the port range that you specify.
 */
export const createCustomRoutingListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateCustomRoutingListenerRequest,
    output: CreateCustomRoutingListenerResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidPortRangeException,
        LimitExceededException,
    ],
}));
/**
 * Create an endpoint group for the specified listener. An endpoint group is a collection of endpoints in one Amazon Web Services
 * Region. A resource must be valid and active when you add it as an endpoint.
 *
 * For more information about endpoint types and requirements for endpoints that you can add
 * to Global Accelerator, see
 * Endpoints for standard accelerators in the *Global Accelerator Developer Guide*.
 */
export const createEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateEndpointGroupRequest,
    output: CreateEndpointGroupResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        EndpointGroupAlreadyExistsException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        ListenerNotFoundException,
    ],
}));
/**
 * Create a listener to process inbound connections from clients to an accelerator. Connections arrive to assigned static
 * IP addresses on a port, port range, or list of port ranges that you specify.
 */
export const createListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateListenerRequest,
    output: CreateListenerResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidPortRangeException,
        LimitExceededException,
    ],
}));
/**
 * Delete an accelerator. Before you can delete an accelerator, you must disable it and remove all dependent resources
 * (listeners and endpoint groups). To disable the accelerator, update the accelerator to set `Enabled` to false.
 *
 * When you create an accelerator, by default, Global Accelerator provides you with a set of two static IP addresses.
 * Alternatively, you can bring your own IP address ranges to Global Accelerator and assign IP addresses from those ranges.
 *
 * The IP addresses are assigned to your accelerator for as long as it exists, even if you disable the accelerator and
 * it no longer accepts or routes traffic. However, when you *delete* an accelerator, you lose the
 * static IP addresses that are assigned to the accelerator, so you can no longer route traffic by using them.
 * As a best practice, ensure that you have permissions in place to avoid inadvertently deleting accelerators. You
 * can use IAM policies with Global Accelerator to limit the users who have permissions to delete an accelerator. For more information,
 * see Identity and access management in
 * the *Global Accelerator Developer Guide*.
 */
export const deleteAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteAcceleratorRequest,
    output: DeleteAcceleratorResponse,
    errors: [
        AcceleratorNotDisabledException,
        AcceleratorNotFoundException,
        AssociatedListenerFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Delete a cross-account attachment. When you delete an attachment, Global Accelerator revokes the permission
 * to use the resources in the attachment from all principals in the list of principals. Global Accelerator
 * revokes the permission for specific resources.
 *
 * For more information, see
 * Working with cross-account attachments and resources in Global Accelerator in the
 * Global Accelerator Developer Guide.
 */
export const deleteCrossAccountAttachment = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteCrossAccountAttachmentRequest,
    output: DeleteCrossAccountAttachmentResponse,
    errors: [
        AccessDeniedException,
        AttachmentNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Delete a custom routing accelerator. Before you can delete an accelerator, you must disable it and remove all dependent resources
 * (listeners and endpoint groups). To disable the accelerator, update the accelerator to set `Enabled` to false.
 *
 * When you create a custom routing accelerator, by default, Global Accelerator provides you with a set of two static IP addresses.
 *
 * The IP
 * addresses are assigned to your accelerator for as long as it exists, even if you disable the accelerator and
 * it no longer accepts or routes traffic. However, when you *delete* an accelerator, you lose the
 * static IP addresses that are assigned to the accelerator, so you can no longer route traffic by using them.
 * As a best practice, ensure that you have permissions in place to avoid inadvertently deleting accelerators. You
 * can use IAM policies with Global Accelerator to limit the users who have permissions to delete an accelerator. For more information,
 * see Identity and access management in
 * the *Global Accelerator Developer Guide*.
 */
export const deleteCustomRoutingAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteCustomRoutingAcceleratorRequest,
    output: DeleteCustomRoutingAcceleratorResponse,
    errors: [
        AcceleratorNotDisabledException,
        AcceleratorNotFoundException,
        AssociatedListenerFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Delete an endpoint group from a listener for a custom routing accelerator.
 */
export const deleteCustomRoutingEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteCustomRoutingEndpointGroupRequest,
    output: DeleteCustomRoutingEndpointGroupResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Delete a listener for a custom routing accelerator.
 */
export const deleteCustomRoutingListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteCustomRoutingListenerRequest,
    output: DeleteCustomRoutingListenerResponse,
    errors: [
        AssociatedEndpointGroupFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        ListenerNotFoundException,
    ],
}));
/**
 * Delete an endpoint group from a listener.
 */
export const deleteEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteEndpointGroupRequest,
    output: DeleteEndpointGroupResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Delete a listener from an accelerator.
 */
export const deleteListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteListenerRequest,
    output: DeleteListenerResponse,
    errors: [
        AssociatedEndpointGroupFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        ListenerNotFoundException,
    ],
}));
/**
 * Specify the Amazon EC2 instance (destination) IP addresses and ports for a VPC subnet endpoint that cannot receive traffic
 * for a custom routing accelerator. You can deny traffic to all destinations in the VPC endpoint, or deny traffic to a
 * specified list of destination IP addresses and ports. Note that you cannot specify IP addresses
 * or ports outside of the range that you configured for the endpoint group.
 *
 * After you make changes, you can verify that the updates are complete by checking the status of your
 * accelerator: the status changes from IN_PROGRESS to DEPLOYED.
 */
export const denyCustomRoutingTraffic = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DenyCustomRoutingTrafficRequest,
    output: DenyCustomRoutingTrafficResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Releases the specified address range that you provisioned to use with your Amazon Web Services resources
 * through bring your own IP addresses (BYOIP) and deletes the corresponding address pool.
 *
 * Before you can release an address range, you must stop advertising it by using WithdrawByoipCidr and you must not have
 * any accelerators that are using static IP addresses allocated from its address range.
 *
 * For more information, see Bring
 * your own IP addresses (BYOIP) in the *Global Accelerator Developer Guide*.
 */
export const deprovisionByoipCidr = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeprovisionByoipCidrRequest,
    output: DeprovisionByoipCidrResponse,
    errors: [
        AccessDeniedException,
        ByoipCidrNotFoundException,
        IncorrectCidrStateException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe an accelerator.
 */
export const describeAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeAcceleratorRequest,
    output: DescribeAcceleratorResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe the attributes of an accelerator.
 */
export const describeAcceleratorAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeAcceleratorAttributesRequest,
    output: DescribeAcceleratorAttributesResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Gets configuration information about a cross-account attachment.
 */
export const describeCrossAccountAttachment = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeCrossAccountAttachmentRequest,
    output: DescribeCrossAccountAttachmentResponse,
    errors: [
        AccessDeniedException,
        AttachmentNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe a custom routing accelerator.
 */
export const describeCustomRoutingAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeCustomRoutingAcceleratorRequest,
    output: DescribeCustomRoutingAcceleratorResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe the attributes of a custom routing accelerator.
 */
export const describeCustomRoutingAcceleratorAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeCustomRoutingAcceleratorAttributesRequest,
    output: DescribeCustomRoutingAcceleratorAttributesResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe an endpoint group for a custom routing accelerator.
 */
export const describeCustomRoutingEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeCustomRoutingEndpointGroupRequest,
    output: DescribeCustomRoutingEndpointGroupResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * The description of a listener for a custom routing accelerator.
 */
export const describeCustomRoutingListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeCustomRoutingListenerRequest,
    output: DescribeCustomRoutingListenerResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        ListenerNotFoundException,
    ],
}));
/**
 * Describe an endpoint group.
 */
export const describeEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeEndpointGroupRequest,
    output: DescribeEndpointGroupResponse,
    errors: [
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Describe a listener.
 */
export const describeListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeListenerRequest,
    output: DescribeListenerResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        ListenerNotFoundException,
    ],
}));
/**
 * List the accelerators for an Amazon Web Services account.
 */
export const listAccelerators = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListAcceleratorsRequest,
    output: ListAcceleratorsResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Accelerators",
        pageSize: "MaxResults",
    },
}));
/**
 * Lists the IP address ranges that were specified in calls to ProvisionByoipCidr, including
 * the current state and a history of state changes.
 */
export const listByoipCidrs = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListByoipCidrsRequest,
    output: ListByoipCidrsResponse,
    errors: [
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ByoipCidrs",
        pageSize: "MaxResults",
    },
}));
/**
 * List the cross-account attachments that have been created in Global Accelerator.
 */
export const listCrossAccountAttachments = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCrossAccountAttachmentsRequest,
    output: ListCrossAccountAttachmentsResponse,
    errors: [
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "CrossAccountAttachments",
        pageSize: "MaxResults",
    },
}));
/**
 * List the accounts that have cross-account resources.
 *
 * For more information, see
 * Working with cross-account attachments and resources in Global Accelerator in the
 * Global Accelerator Developer Guide.
 */
export const listCrossAccountResourceAccounts = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListCrossAccountResourceAccountsRequest,
    output: ListCrossAccountResourceAccountsResponse,
    errors: [AccessDeniedException, InternalServiceErrorException],
}));
/**
 * List the cross-account resources available to work with.
 */
export const listCrossAccountResources = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCrossAccountResourcesRequest,
    output: ListCrossAccountResourcesResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "CrossAccountResources",
        pageSize: "MaxResults",
    },
}));
/**
 * List the custom routing accelerators for an Amazon Web Services account.
 */
export const listCustomRoutingAccelerators = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCustomRoutingAcceleratorsRequest,
    output: ListCustomRoutingAcceleratorsResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Accelerators",
        pageSize: "MaxResults",
    },
}));
/**
 * List the endpoint groups that are associated with a listener for a custom routing accelerator.
 */
export const listCustomRoutingEndpointGroups = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCustomRoutingEndpointGroupsRequest,
    output: ListCustomRoutingEndpointGroupsResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
        ListenerNotFoundException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "EndpointGroups",
        pageSize: "MaxResults",
    },
}));
/**
 * List the listeners for a custom routing accelerator.
 */
export const listCustomRoutingListeners = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCustomRoutingListenersRequest,
    output: ListCustomRoutingListenersResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Listeners",
        pageSize: "MaxResults",
    },
}));
/**
 * Provides a complete mapping from the public accelerator IP address and port to destination EC2 instance
 * IP addresses and ports in the virtual public cloud (VPC) subnet endpoint for a custom routing accelerator.
 * For each subnet endpoint that you add, Global Accelerator creates a new static port mapping for the accelerator. The port
 * mappings don't change after Global Accelerator generates them, so you can retrieve and cache the full mapping on your servers.
 *
 * If you remove a subnet from your accelerator, Global Accelerator removes (reclaims) the port mappings. If you add a subnet to
 * your accelerator, Global Accelerator creates new port mappings (the existing ones don't change). If you add or remove EC2 instances
 * in your subnet, the port mappings don't change, because the mappings are created when you add the subnet to Global Accelerator.
 *
 * The mappings also include a flag for each destination denoting which destination IP addresses and
 * ports are allowed or denied traffic.
 */
export const listCustomRoutingPortMappings = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCustomRoutingPortMappingsRequest,
    output: ListCustomRoutingPortMappingsResponse,
    errors: [
        AcceleratorNotFoundException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "PortMappings",
        pageSize: "MaxResults",
    },
}));
/**
 * List the port mappings for a specific EC2 instance (destination) in a VPC subnet endpoint. The
 * response is the mappings for one destination IP address. This is useful when your subnet endpoint has mappings that
 * span multiple custom routing accelerators in your account, or for scenarios where you only want to
 * list the port mappings for a specific destination instance.
 */
export const listCustomRoutingPortMappingsByDestination = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCustomRoutingPortMappingsByDestinationRequest,
    output: ListCustomRoutingPortMappingsByDestinationResponse,
    errors: [
        EndpointNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "DestinationPortMappings",
        pageSize: "MaxResults",
    },
}));
/**
 * List the endpoint groups that are associated with a listener.
 */
export const listEndpointGroups = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListEndpointGroupsRequest,
    output: ListEndpointGroupsResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
        ListenerNotFoundException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "EndpointGroups",
        pageSize: "MaxResults",
    },
}));
/**
 * List the listeners for an accelerator.
 */
export const listListeners = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListListenersRequest,
    output: ListListenersResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidNextTokenException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Listeners",
        pageSize: "MaxResults",
    },
}));
/**
 * List all tags for an accelerator.
 *
 * For more information, see Tagging
 * in Global Accelerator in the *Global Accelerator Developer Guide*.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [
        AcceleratorNotFoundException,
        AttachmentNotFoundException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        ListenerNotFoundException,
    ],
}));
/**
 * Provisions an IP address range to use with your Amazon Web Services resources through bring your own IP
 * addresses (BYOIP) and creates a corresponding address pool. After the address range is provisioned,
 * it is ready to be advertised using
 * AdvertiseByoipCidr.
 *
 * For more information, see Bring your own
 * IP addresses (BYOIP) in the *Global Accelerator Developer Guide*.
 */
export const provisionByoipCidr = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ProvisionByoipCidrRequest,
    output: ProvisionByoipCidrResponse,
    errors: [
        AccessDeniedException,
        IncorrectCidrStateException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
    ],
}));
/**
 * Remove endpoints from a custom routing accelerator.
 */
export const removeCustomRoutingEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RemoveCustomRoutingEndpointsRequest,
    output: RemoveCustomRoutingEndpointsResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        EndpointGroupNotFoundException,
        EndpointNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Remove endpoints from an endpoint group.
 *
 * The `RemoveEndpoints` API operation is the recommended option for removing endpoints. The alternative is to remove
 * endpoints by updating an endpoint group by using the
 * UpdateEndpointGroup
 * API operation. There are two advantages to using `AddEndpoints` to remove endpoints instead:
 *
 * - It's more convenient, because you only need to specify the endpoints that you want to remove. With the
 * `UpdateEndpointGroup` API operation, you must specify all of the endpoints in the
 * endpoint group except the ones that you want to remove from the group.
 *
 * - It's faster, because Global Accelerator doesn't need to resolve any endpoints. With the
 * `UpdateEndpointGroup` API operation, Global Accelerator must resolve all of the endpoints that
 * remain in the group.
 */
export const removeEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RemoveEndpointsRequest,
    output: RemoveEndpointsResponse,
    errors: [
        AccessDeniedException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Add tags to an accelerator resource.
 *
 * For more information, see Tagging
 * in Global Accelerator in the *Global Accelerator Developer Guide*.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Remove tags from a Global Accelerator resource. When you specify a tag key, the action removes both that key and its associated value.
 * The operation succeeds even if you attempt to remove tags from an accelerator that was already removed.
 *
 * For more information, see Tagging
 * in Global Accelerator in the *Global Accelerator Developer Guide*.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        AcceleratorNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
/**
 * Update an accelerator to make changes, such as the following:
 *
 * - Change the name of the accelerator.
 *
 * - Disable the accelerator so that it no longer accepts or routes traffic, or so that you can delete it.
 *
 * - Enable the accelerator, if it is disabled.
 *
 * - Change the IP address type to dual-stack if it is IPv4, or change the IP address type to IPv4 if it's dual-stack.
 *
 * Be aware that static IP addresses remain assigned to your accelerator for as long as it exists, even if you disable the accelerator and it no
 * longer accepts or routes traffic. However, when you delete the accelerator, you lose the static IP addresses that are assigned to it, so you
 * can no longer route traffic by using them.
 *
 * Global Accelerator is a global service that supports endpoints in multiple Amazon Web Services Regions but you must specify the
 * US West (Oregon) Region to create, update, or otherwise work with accelerators. That is, for example, specify `--region us-west-2`
 * on Amazon Web Services CLI commands.
 */
export const updateAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateAcceleratorRequest,
    output: UpdateAcceleratorResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        ConflictException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Update the attributes for an accelerator.
 */
export const updateAcceleratorAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateAcceleratorAttributesRequest,
    output: UpdateAcceleratorAttributesResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Update a cross-account attachment to add or remove principals or resources. When you update
 * an attachment to remove a principal (account ID or accelerator) or a resource, Global Accelerator
 * revokes the permission for specific resources.
 *
 * For more information, see
 * Working with cross-account attachments and resources in Global Accelerator in the
 * Global Accelerator Developer Guide.
 */
export const updateCrossAccountAttachment = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateCrossAccountAttachmentRequest,
    output: UpdateCrossAccountAttachmentResponse,
    errors: [
        AccessDeniedException,
        AttachmentNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
        TransactionInProgressException,
    ],
}));
/**
 * Update a custom routing accelerator.
 */
export const updateCustomRoutingAccelerator = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateCustomRoutingAcceleratorRequest,
    output: UpdateCustomRoutingAcceleratorResponse,
    errors: [
        AcceleratorNotFoundException,
        ConflictException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Update the attributes for a custom routing accelerator.
 */
export const updateCustomRoutingAcceleratorAttributes = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateCustomRoutingAcceleratorAttributesRequest,
    output: UpdateCustomRoutingAcceleratorAttributesResponse,
    errors: [
        AcceleratorNotFoundException,
        AccessDeniedException,
        InternalServiceErrorException,
        InvalidArgumentException,
        TransactionInProgressException,
    ],
}));
/**
 * Update a listener for a custom routing accelerator.
 */
export const updateCustomRoutingListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateCustomRoutingListenerRequest,
    output: UpdateCustomRoutingListenerResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidPortRangeException,
        LimitExceededException,
        ListenerNotFoundException,
    ],
}));
/**
 * Update an endpoint group. A resource must be valid and active when you add it as an endpoint.
 */
export const updateEndpointGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateEndpointGroupRequest,
    output: UpdateEndpointGroupResponse,
    errors: [
        AccessDeniedException,
        EndpointGroupNotFoundException,
        InternalServiceErrorException,
        InvalidArgumentException,
        LimitExceededException,
    ],
}));
/**
 * Update a listener.
 */
export const updateListener = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateListenerRequest,
    output: UpdateListenerResponse,
    errors: [
        InternalServiceErrorException,
        InvalidArgumentException,
        InvalidPortRangeException,
        LimitExceededException,
        ListenerNotFoundException,
    ],
}));
/**
 * Stops advertising an address range that is provisioned as an address pool.
 * You can perform this operation at most once every 10 seconds, even if you specify different address
 * ranges each time.
 *
 * It can take a few minutes before traffic to the specified addresses stops routing to Amazon Web Services because of
 * propagation delays.
 *
 * For more information, see Bring your own
 * IP addresses (BYOIP) in the *Global Accelerator Developer Guide*.
 */
export const withdrawByoipCidr = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: WithdrawByoipCidrRequest,
    output: WithdrawByoipCidrResponse,
    errors: [
        AccessDeniedException,
        ByoipCidrNotFoundException,
        IncorrectCidrStateException,
        InternalServiceErrorException,
        InvalidArgumentException,
    ],
}));
//# sourceMappingURL=global-accelerator.js.map