Add/update filtered-sum-bms benchmark

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/EC2ServiceException.js

@@ -0,0 +1,8 @@
+import { ServiceException as __ServiceException, } from "@smithy/smithy-client";
+export { __ServiceException };
+export class EC2ServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, EC2ServiceException.prototype);
+    }
+}

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/index.js

@@ -0,0 +1,9 @@
+export * from "./models_0";
+export * from "./models_1";
+export * from "./models_2";
+export * from "./models_3";
+export * from "./models_4";
+export * from "./models_5";
+export * from "./models_6";
+export * from "./models_7";
+export * from "./models_8";

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_0.js

@@ -0,0 +1,538 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+export const AcceleratorManufacturer = {
+    AMAZON_WEB_SERVICES: "amazon-web-services",
+    AMD: "amd",
+    HABANA: "habana",
+    NVIDIA: "nvidia",
+    XILINX: "xilinx",
+};
+export const AcceleratorName = {
+    A100: "a100",
+    A10G: "a10g",
+    H100: "h100",
+    INFERENTIA: "inferentia",
+    K520: "k520",
+    K80: "k80",
+    M60: "m60",
+    RADEON_PRO_V520: "radeon-pro-v520",
+    T4: "t4",
+    T4G: "t4g",
+    V100: "v100",
+    VU9P: "vu9p",
+};
+export const AcceleratorType = {
+    FPGA: "fpga",
+    GPU: "gpu",
+    INFERENCE: "inference",
+};
+export const ResourceType = {
+    capacity_reservation: "capacity-reservation",
+    capacity_reservation_fleet: "capacity-reservation-fleet",
+    carrier_gateway: "carrier-gateway",
+    client_vpn_endpoint: "client-vpn-endpoint",
+    coip_pool: "coip-pool",
+    customer_gateway: "customer-gateway",
+    declarative_policies_report: "declarative-policies-report",
+    dedicated_host: "dedicated-host",
+    dhcp_options: "dhcp-options",
+    egress_only_internet_gateway: "egress-only-internet-gateway",
+    elastic_gpu: "elastic-gpu",
+    elastic_ip: "elastic-ip",
+    export_image_task: "export-image-task",
+    export_instance_task: "export-instance-task",
+    fleet: "fleet",
+    fpga_image: "fpga-image",
+    host_reservation: "host-reservation",
+    image: "image",
+    import_image_task: "import-image-task",
+    import_snapshot_task: "import-snapshot-task",
+    instance: "instance",
+    instance_connect_endpoint: "instance-connect-endpoint",
+    instance_event_window: "instance-event-window",
+    internet_gateway: "internet-gateway",
+    ipam: "ipam",
+    ipam_external_resource_verification_token: "ipam-external-resource-verification-token",
+    ipam_pool: "ipam-pool",
+    ipam_resource_discovery: "ipam-resource-discovery",
+    ipam_resource_discovery_association: "ipam-resource-discovery-association",
+    ipam_scope: "ipam-scope",
+    ipv4pool_ec2: "ipv4pool-ec2",
+    ipv6pool_ec2: "ipv6pool-ec2",
+    key_pair: "key-pair",
+    launch_template: "launch-template",
+    local_gateway: "local-gateway",
+    local_gateway_route_table: "local-gateway-route-table",
+    local_gateway_route_table_virtual_interface_group_association: "local-gateway-route-table-virtual-interface-group-association",
+    local_gateway_route_table_vpc_association: "local-gateway-route-table-vpc-association",
+    local_gateway_virtual_interface: "local-gateway-virtual-interface",
+    local_gateway_virtual_interface_group: "local-gateway-virtual-interface-group",
+    natgateway: "natgateway",
+    network_acl: "network-acl",
+    network_insights_access_scope: "network-insights-access-scope",
+    network_insights_access_scope_analysis: "network-insights-access-scope-analysis",
+    network_insights_analysis: "network-insights-analysis",
+    network_insights_path: "network-insights-path",
+    network_interface: "network-interface",
+    outpost_lag: "outpost-lag",
+    placement_group: "placement-group",
+    prefix_list: "prefix-list",
+    replace_root_volume_task: "replace-root-volume-task",
+    reserved_instances: "reserved-instances",
+    route_server: "route-server",
+    route_server_endpoint: "route-server-endpoint",
+    route_server_peer: "route-server-peer",
+    route_table: "route-table",
+    security_group: "security-group",
+    security_group_rule: "security-group-rule",
+    service_link_virtual_interface: "service-link-virtual-interface",
+    snapshot: "snapshot",
+    spot_fleet_request: "spot-fleet-request",
+    spot_instances_request: "spot-instances-request",
+    subnet: "subnet",
+    subnet_cidr_reservation: "subnet-cidr-reservation",
+    traffic_mirror_filter: "traffic-mirror-filter",
+    traffic_mirror_filter_rule: "traffic-mirror-filter-rule",
+    traffic_mirror_session: "traffic-mirror-session",
+    traffic_mirror_target: "traffic-mirror-target",
+    transit_gateway: "transit-gateway",
+    transit_gateway_attachment: "transit-gateway-attachment",
+    transit_gateway_connect_peer: "transit-gateway-connect-peer",
+    transit_gateway_multicast_domain: "transit-gateway-multicast-domain",
+    transit_gateway_policy_table: "transit-gateway-policy-table",
+    transit_gateway_route_table: "transit-gateway-route-table",
+    transit_gateway_route_table_announcement: "transit-gateway-route-table-announcement",
+    verified_access_endpoint: "verified-access-endpoint",
+    verified_access_endpoint_target: "verified-access-endpoint-target",
+    verified_access_group: "verified-access-group",
+    verified_access_instance: "verified-access-instance",
+    verified_access_policy: "verified-access-policy",
+    verified_access_trust_provider: "verified-access-trust-provider",
+    volume: "volume",
+    vpc: "vpc",
+    vpc_block_public_access_exclusion: "vpc-block-public-access-exclusion",
+    vpc_endpoint: "vpc-endpoint",
+    vpc_endpoint_connection: "vpc-endpoint-connection",
+    vpc_endpoint_connection_device_type: "vpc-endpoint-connection-device-type",
+    vpc_endpoint_service: "vpc-endpoint-service",
+    vpc_endpoint_service_permission: "vpc-endpoint-service-permission",
+    vpc_flow_log: "vpc-flow-log",
+    vpc_peering_connection: "vpc-peering-connection",
+    vpn_connection: "vpn-connection",
+    vpn_connection_device_type: "vpn-connection-device-type",
+    vpn_gateway: "vpn-gateway",
+};
+export const AddressTransferStatus = {
+    accepted: "accepted",
+    disabled: "disabled",
+    pending: "pending",
+};
+export const TransitGatewayAttachmentResourceType = {
+    connect: "connect",
+    direct_connect_gateway: "direct-connect-gateway",
+    peering: "peering",
+    tgw_peering: "tgw-peering",
+    vpc: "vpc",
+    vpn: "vpn",
+};
+export const TransitGatewayMulitcastDomainAssociationState = {
+    associated: "associated",
+    associating: "associating",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+    failed: "failed",
+    pendingAcceptance: "pendingAcceptance",
+    rejected: "rejected",
+};
+export const DynamicRoutingValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const TransitGatewayAttachmentState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    failed: "failed",
+    failing: "failing",
+    initiating: "initiating",
+    initiatingRequest: "initiatingRequest",
+    modifying: "modifying",
+    pending: "pending",
+    pendingAcceptance: "pendingAcceptance",
+    rejected: "rejected",
+    rejecting: "rejecting",
+    rollingBack: "rollingBack",
+};
+export const ApplianceModeSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const DnsSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const Ipv6SupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const SecurityGroupReferencingSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const VpcPeeringConnectionStateReasonCode = {
+    active: "active",
+    deleted: "deleted",
+    deleting: "deleting",
+    expired: "expired",
+    failed: "failed",
+    initiating_request: "initiating-request",
+    pending_acceptance: "pending-acceptance",
+    provisioning: "provisioning",
+    rejected: "rejected",
+};
+export const Protocol = {
+    tcp: "tcp",
+    udp: "udp",
+};
+export const AccountAttributeName = {
+    default_vpc: "default-vpc",
+    supported_platforms: "supported-platforms",
+};
+export const InstanceHealthStatus = {
+    HEALTHY_STATUS: "healthy",
+    UNHEALTHY_STATUS: "unhealthy",
+};
+export const ActivityStatus = {
+    ERROR: "error",
+    FULFILLED: "fulfilled",
+    PENDING_FULFILLMENT: "pending_fulfillment",
+    PENDING_TERMINATION: "pending_termination",
+};
+export const PrincipalType = {
+    Account: "Account",
+    All: "All",
+    OrganizationUnit: "OrganizationUnit",
+    Role: "Role",
+    Service: "Service",
+    User: "User",
+};
+export const DomainType = {
+    standard: "standard",
+    vpc: "vpc",
+};
+export const ServiceManaged = {
+    alb: "alb",
+    nlb: "nlb",
+    rnat: "rnat",
+};
+export const AddressAttributeName = {
+    domain_name: "domain-name",
+};
+export const AddressFamily = {
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+};
+export const AsnAssociationState = {
+    associated: "associated",
+    disassociated: "disassociated",
+    failed_association: "failed-association",
+    failed_disassociation: "failed-disassociation",
+    pending_association: "pending-association",
+    pending_disassociation: "pending-disassociation",
+};
+export const ByoipCidrState = {
+    advertised: "advertised",
+    deprovisioned: "deprovisioned",
+    failed_deprovision: "failed-deprovision",
+    failed_provision: "failed-provision",
+    pending_deprovision: "pending-deprovision",
+    pending_provision: "pending-provision",
+    provisioned: "provisioned",
+    provisioned_not_publicly_advertisable: "provisioned-not-publicly-advertisable",
+};
+export const Affinity = {
+    default: "default",
+    host: "host",
+};
+export const AutoPlacement = {
+    off: "off",
+    on: "on",
+};
+export const HostMaintenance = {
+    off: "off",
+    on: "on",
+};
+export const HostRecovery = {
+    off: "off",
+    on: "on",
+};
+export const IpamPoolAllocationResourceType = {
+    custom: "custom",
+    ec2_public_ipv4_pool: "ec2-public-ipv4-pool",
+    eip: "eip",
+    ipam_pool: "ipam-pool",
+    subnet: "subnet",
+    vpc: "vpc",
+};
+export const AllocationState = {
+    available: "available",
+    pending: "pending",
+    permanent_failure: "permanent-failure",
+    released: "released",
+    released_permanent_failure: "released-permanent-failure",
+    under_assessment: "under-assessment",
+};
+export const AllocationStrategy = {
+    CAPACITY_OPTIMIZED: "capacityOptimized",
+    CAPACITY_OPTIMIZED_PRIORITIZED: "capacityOptimizedPrioritized",
+    DIVERSIFIED: "diversified",
+    LOWEST_PRICE: "lowestPrice",
+    PRICE_CAPACITY_OPTIMIZED: "priceCapacityOptimized",
+};
+export const AllocationType = {
+    future: "future",
+    used: "used",
+};
+export const AllowedImagesSettingsDisabledState = {
+    disabled: "disabled",
+};
+export const AllowedImagesSettingsEnabledState = {
+    audit_mode: "audit-mode",
+    enabled: "enabled",
+};
+export const AllowsMultipleInstanceTypes = {
+    off: "off",
+    on: "on",
+};
+export const NatGatewayAddressStatus = {
+    ASSIGNING: "assigning",
+    ASSOCIATING: "associating",
+    DISASSOCIATING: "disassociating",
+    FAILED: "failed",
+    SUCCEEDED: "succeeded",
+    UNASSIGNING: "unassigning",
+};
+export const AssociationStatusCode = {
+    associated: "associated",
+    associating: "associating",
+    association_failed: "association-failed",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+};
+export const IamInstanceProfileAssociationState = {
+    ASSOCIATED: "associated",
+    ASSOCIATING: "associating",
+    DISASSOCIATED: "disassociated",
+    DISASSOCIATING: "disassociating",
+};
+export const InstanceEventWindowState = {
+    active: "active",
+    creating: "creating",
+    deleted: "deleted",
+    deleting: "deleting",
+};
+export const WeekDay = {
+    friday: "friday",
+    monday: "monday",
+    saturday: "saturday",
+    sunday: "sunday",
+    thursday: "thursday",
+    tuesday: "tuesday",
+    wednesday: "wednesday",
+};
+export const IpamAssociatedResourceDiscoveryStatus = {
+    ACTIVE: "active",
+    NOT_FOUND: "not-found",
+};
+export const IpamResourceDiscoveryAssociationState = {
+    ASSOCIATE_COMPLETE: "associate-complete",
+    ASSOCIATE_FAILED: "associate-failed",
+    ASSOCIATE_IN_PROGRESS: "associate-in-progress",
+    DISASSOCIATE_COMPLETE: "disassociate-complete",
+    DISASSOCIATE_FAILED: "disassociate-failed",
+    DISASSOCIATE_IN_PROGRESS: "disassociate-in-progress",
+    ISOLATE_COMPLETE: "isolate-complete",
+    ISOLATE_IN_PROGRESS: "isolate-in-progress",
+    RESTORE_IN_PROGRESS: "restore-in-progress",
+};
+export const RouteServerAssociationState = {
+    ASSOCIATED: "associated",
+    ASSOCIATING: "associating",
+    DISASSOCIATING: "disassociating",
+};
+export const RouteTableAssociationStateCode = {
+    associated: "associated",
+    associating: "associating",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+    failed: "failed",
+};
+export const SecurityGroupVpcAssociationState = {
+    associated: "associated",
+    associating: "associating",
+    association_failed: "association-failed",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+    disassociation_failed: "disassociation-failed",
+};
+export const IpSource = {
+    amazon: "amazon",
+    byoip: "byoip",
+    none: "none",
+};
+export const Ipv6AddressAttribute = {
+    private: "private",
+    public: "public",
+};
+export const SubnetCidrBlockStateCode = {
+    associated: "associated",
+    associating: "associating",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+    failed: "failed",
+    failing: "failing",
+};
+export const TransitGatewayAssociationState = {
+    associated: "associated",
+    associating: "associating",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+};
+export const InterfaceProtocolType = {
+    GRE: "GRE",
+    VLAN: "VLAN",
+};
+export const VpcCidrBlockStateCode = {
+    associated: "associated",
+    associating: "associating",
+    disassociated: "disassociated",
+    disassociating: "disassociating",
+    failed: "failed",
+    failing: "failing",
+};
+export const DeviceTrustProviderType = {
+    crowdstrike: "crowdstrike",
+    jamf: "jamf",
+    jumpcloud: "jumpcloud",
+};
+export const TrustProviderType = {
+    device: "device",
+    user: "user",
+};
+export const UserTrustProviderType = {
+    iam_identity_center: "iam-identity-center",
+    oidc: "oidc",
+};
+export const VolumeAttachmentState = {
+    attached: "attached",
+    attaching: "attaching",
+    busy: "busy",
+    detached: "detached",
+    detaching: "detaching",
+};
+export const AttachmentStatus = {
+    attached: "attached",
+    attaching: "attaching",
+    detached: "detached",
+    detaching: "detaching",
+};
+export const ClientVpnAuthorizationRuleStatusCode = {
+    active: "active",
+    authorizing: "authorizing",
+    failed: "failed",
+    revoking: "revoking",
+};
+export const BundleTaskState = {
+    bundling: "bundling",
+    cancelling: "cancelling",
+    complete: "complete",
+    failed: "failed",
+    pending: "pending",
+    storing: "storing",
+    waiting_for_shutdown: "waiting-for-shutdown",
+};
+export const CapacityReservationFleetState = {
+    ACTIVE: "active",
+    CANCELLED: "cancelled",
+    CANCELLING: "cancelling",
+    EXPIRED: "expired",
+    EXPIRING: "expiring",
+    FAILED: "failed",
+    MODIFYING: "modifying",
+    PARTIALLY_FULFILLED: "partially_fulfilled",
+    SUBMITTED: "submitted",
+};
+export const ListingState = {
+    available: "available",
+    cancelled: "cancelled",
+    pending: "pending",
+    sold: "sold",
+};
+export const CurrencyCodeValues = {
+    USD: "USD",
+};
+export const ListingStatus = {
+    active: "active",
+    cancelled: "cancelled",
+    closed: "closed",
+    pending: "pending",
+};
+export const BatchState = {
+    ACTIVE: "active",
+    CANCELLED: "cancelled",
+    CANCELLED_RUNNING: "cancelled_running",
+    CANCELLED_TERMINATING_INSTANCES: "cancelled_terminating",
+    FAILED: "failed",
+    MODIFYING: "modifying",
+    SUBMITTED: "submitted",
+};
+export const CancelBatchErrorCode = {
+    FLEET_REQUEST_ID_DOES_NOT_EXIST: "fleetRequestIdDoesNotExist",
+    FLEET_REQUEST_ID_MALFORMED: "fleetRequestIdMalformed",
+    FLEET_REQUEST_NOT_IN_CANCELLABLE_STATE: "fleetRequestNotInCancellableState",
+    UNEXPECTED_ERROR: "unexpectedError",
+};
+export const CancelSpotInstanceRequestState = {
+    active: "active",
+    cancelled: "cancelled",
+    closed: "closed",
+    completed: "completed",
+    open: "open",
+};
+export const OidcOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const VerifiedAccessTrustProviderFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OidcOptions && { OidcOptions: OidcOptionsFilterSensitiveLog(obj.OidcOptions) }),
+});
+export const AttachVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProvider && {
+        VerifiedAccessTrustProvider: VerifiedAccessTrustProviderFilterSensitiveLog(obj.VerifiedAccessTrustProvider),
+    }),
+});
+export const S3StorageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UploadPolicySignature && { UploadPolicySignature: SENSITIVE_STRING }),
+});
+export const StorageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.S3 && { S3: S3StorageFilterSensitiveLog(obj.S3) }),
+});
+export const BundleInstanceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Storage && { Storage: StorageFilterSensitiveLog(obj.Storage) }),
+});
+export const BundleTaskFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Storage && { Storage: StorageFilterSensitiveLog(obj.Storage) }),
+});
+export const BundleInstanceResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BundleTask && { BundleTask: BundleTaskFilterSensitiveLog(obj.BundleTask) }),
+});
+export const CancelBundleTaskResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BundleTask && { BundleTask: BundleTaskFilterSensitiveLog(obj.BundleTask) }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_2.js

@@ -0,0 +1,470 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { VerifiedAccessTrustProviderFilterSensitiveLog, } from "./models_0";
+import { ResponseLaunchTemplateDataFilterSensitiveLog, } from "./models_1";
+export const LocalGatewayRouteState = {
+    active: "active",
+    blackhole: "blackhole",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const LocalGatewayRouteType = {
+    propagated: "propagated",
+    static: "static",
+};
+export const LocalGatewayRouteTableMode = {
+    coip: "coip",
+    direct_vpc_routing: "direct-vpc-routing",
+};
+export const LocalGatewayVirtualInterfaceConfigurationState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const LocalGatewayVirtualInterfaceGroupConfigurationState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    incomplete: "incomplete",
+    pending: "pending",
+};
+export const PrefixListState = {
+    create_complete: "create-complete",
+    create_failed: "create-failed",
+    create_in_progress: "create-in-progress",
+    delete_complete: "delete-complete",
+    delete_failed: "delete-failed",
+    delete_in_progress: "delete-in-progress",
+    modify_complete: "modify-complete",
+    modify_failed: "modify-failed",
+    modify_in_progress: "modify-in-progress",
+    restore_complete: "restore-complete",
+    restore_failed: "restore-failed",
+    restore_in_progress: "restore-in-progress",
+};
+export const ConnectivityType = {
+    PRIVATE: "private",
+    PUBLIC: "public",
+};
+export const NatGatewayState = {
+    AVAILABLE: "available",
+    DELETED: "deleted",
+    DELETING: "deleting",
+    FAILED: "failed",
+    PENDING: "pending",
+};
+export const RuleAction = {
+    allow: "allow",
+    deny: "deny",
+};
+export const NetworkInterfaceCreationType = {
+    branch: "branch",
+    efa: "efa",
+    efa_only: "efa-only",
+    trunk: "trunk",
+};
+export const NetworkInterfaceType = {
+    api_gateway_managed: "api_gateway_managed",
+    aws_codestar_connections_managed: "aws_codestar_connections_managed",
+    branch: "branch",
+    efa: "efa",
+    efa_only: "efa-only",
+    gateway_load_balancer: "gateway_load_balancer",
+    gateway_load_balancer_endpoint: "gateway_load_balancer_endpoint",
+    global_accelerator_managed: "global_accelerator_managed",
+    interface: "interface",
+    iot_rules_managed: "iot_rules_managed",
+    lambda: "lambda",
+    load_balancer: "load_balancer",
+    natGateway: "natGateway",
+    network_load_balancer: "network_load_balancer",
+    quicksight: "quicksight",
+    transit_gateway: "transit_gateway",
+    trunk: "trunk",
+    vpc_endpoint: "vpc_endpoint",
+};
+export const NetworkInterfaceStatus = {
+    associated: "associated",
+    attaching: "attaching",
+    available: "available",
+    detaching: "detaching",
+    in_use: "in-use",
+};
+export const InterfacePermissionType = {
+    EIP_ASSOCIATE: "EIP-ASSOCIATE",
+    INSTANCE_ATTACH: "INSTANCE-ATTACH",
+};
+export const NetworkInterfacePermissionStateCode = {
+    granted: "granted",
+    pending: "pending",
+    revoked: "revoked",
+    revoking: "revoking",
+};
+export const SpreadLevel = {
+    host: "host",
+    rack: "rack",
+};
+export const PlacementStrategy = {
+    cluster: "cluster",
+    partition: "partition",
+    spread: "spread",
+};
+export const PlacementGroupState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const ReplaceRootVolumeTaskState = {
+    failed: "failed",
+    failed_detached: "failed-detached",
+    failing: "failing",
+    in_progress: "in-progress",
+    pending: "pending",
+    succeeded: "succeeded",
+};
+export const RouteServerPersistRoutesAction = {
+    DISABLE: "disable",
+    ENABLE: "enable",
+    RESET: "reset",
+};
+export const RouteServerPersistRoutesState = {
+    DISABLED: "disabled",
+    DISABLING: "disabling",
+    ENABLED: "enabled",
+    ENABLING: "enabling",
+    MODIFYING: "modifying",
+    RESETTING: "resetting",
+};
+export const RouteServerState = {
+    AVAILABLE: "available",
+    DELETED: "deleted",
+    DELETING: "deleting",
+    MODIFYING: "modifying",
+    PENDING: "pending",
+};
+export const RouteServerEndpointState = {
+    AVAILABLE: "available",
+    DELETED: "deleted",
+    DELETE_FAILED: "delete-failed",
+    DELETING: "deleting",
+    FAILED: "failed",
+    FAILING: "failing",
+    PENDING: "pending",
+};
+export const RouteServerPeerLivenessMode = {
+    BFD: "bfd",
+    BGP_KEEPALIVE: "bgp-keepalive",
+};
+export const RouteServerBfdState = {
+    DOWN: "down",
+    UP: "up",
+};
+export const RouteServerBgpState = {
+    DOWN: "down",
+    UP: "up",
+};
+export const RouteServerPeerState = {
+    AVAILABLE: "available",
+    DELETED: "deleted",
+    DELETING: "deleting",
+    FAILED: "failed",
+    FAILING: "failing",
+    PENDING: "pending",
+};
+export const RouteOrigin = {
+    CreateRoute: "CreateRoute",
+    CreateRouteTable: "CreateRouteTable",
+    EnableVgwRoutePropagation: "EnableVgwRoutePropagation",
+};
+export const RouteState = {
+    active: "active",
+    blackhole: "blackhole",
+};
+export const SnapshotLocationEnum = {
+    LOCAL: "local",
+    REGIONAL: "regional",
+};
+export const SSEType = {
+    none: "none",
+    sse_ebs: "sse-ebs",
+    sse_kms: "sse-kms",
+};
+export const SnapshotState = {
+    completed: "completed",
+    error: "error",
+    pending: "pending",
+    recoverable: "recoverable",
+    recovering: "recovering",
+};
+export const StorageTier = {
+    archive: "archive",
+    standard: "standard",
+};
+export const TransferType = {
+    standard: "standard",
+    time_based: "time-based",
+};
+export const CopyTagsFromSource = {
+    volume: "volume",
+};
+export const DatafeedSubscriptionState = {
+    Active: "Active",
+    Inactive: "Inactive",
+};
+export const SubnetCidrReservationType = {
+    explicit: "explicit",
+    prefix: "prefix",
+};
+export const TrafficMirrorRuleAction = {
+    accept: "accept",
+    reject: "reject",
+};
+export const TrafficDirection = {
+    egress: "egress",
+    ingress: "ingress",
+};
+export const TrafficMirrorNetworkService = {
+    amazon_dns: "amazon-dns",
+};
+export const TrafficMirrorTargetType = {
+    gateway_load_balancer_endpoint: "gateway-load-balancer-endpoint",
+    network_interface: "network-interface",
+    network_load_balancer: "network-load-balancer",
+};
+export const AutoAcceptSharedAttachmentsValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const DefaultRouteTableAssociationValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const DefaultRouteTablePropagationValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const MulticastSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const VpnEcmpSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const TransitGatewayState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    modifying: "modifying",
+    pending: "pending",
+};
+export const ProtocolValue = {
+    gre: "gre",
+};
+export const BgpStatus = {
+    down: "down",
+    up: "up",
+};
+export const TransitGatewayConnectPeerState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const AutoAcceptSharedAssociationsValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const Igmpv2SupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const StaticSourcesSupportValue = {
+    disable: "disable",
+    enable: "enable",
+};
+export const TransitGatewayMulticastDomainState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const TransitGatewayPolicyTableState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const TransitGatewayPrefixListReferenceState = {
+    available: "available",
+    deleting: "deleting",
+    modifying: "modifying",
+    pending: "pending",
+};
+export const TransitGatewayRouteState = {
+    active: "active",
+    blackhole: "blackhole",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const TransitGatewayRouteType = {
+    propagated: "propagated",
+    static: "static",
+};
+export const TransitGatewayRouteTableState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const TransitGatewayRouteTableAnnouncementDirection = {
+    incoming: "incoming",
+    outgoing: "outgoing",
+};
+export const TransitGatewayRouteTableAnnouncementState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    failed: "failed",
+    failing: "failing",
+    pending: "pending",
+};
+export const VerifiedAccessEndpointAttachmentType = {
+    vpc: "vpc",
+};
+export const VerifiedAccessEndpointProtocol = {
+    http: "http",
+    https: "https",
+    tcp: "tcp",
+};
+export const VerifiedAccessEndpointType = {
+    cidr: "cidr",
+    load_balancer: "load-balancer",
+    network_interface: "network-interface",
+    rds: "rds",
+};
+export const VerifiedAccessEndpointStatusCode = {
+    active: "active",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+    updating: "updating",
+};
+export const VolumeState = {
+    available: "available",
+    creating: "creating",
+    deleted: "deleted",
+    deleting: "deleting",
+    error: "error",
+    in_use: "in-use",
+};
+export const InternetGatewayExclusionMode = {
+    allow_bidirectional: "allow-bidirectional",
+    allow_egress: "allow-egress",
+};
+export const VpcBlockPublicAccessExclusionState = {
+    create_complete: "create-complete",
+    create_failed: "create-failed",
+    create_in_progress: "create-in-progress",
+    delete_complete: "delete-complete",
+    delete_in_progress: "delete-in-progress",
+    disable_complete: "disable-complete",
+    disable_in_progress: "disable-in-progress",
+    update_complete: "update-complete",
+    update_failed: "update-failed",
+    update_in_progress: "update-in-progress",
+};
+export const DnsRecordIpType = {
+    dualstack: "dualstack",
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+    service_defined: "service-defined",
+};
+export const IpAddressType = {
+    dualstack: "dualstack",
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+};
+export const VpcEndpointType = {
+    Gateway: "Gateway",
+    GatewayLoadBalancer: "GatewayLoadBalancer",
+    Interface: "Interface",
+    Resource: "Resource",
+    ServiceNetwork: "ServiceNetwork",
+};
+export const State = {
+    Available: "Available",
+    Deleted: "Deleted",
+    Deleting: "Deleting",
+    Expired: "Expired",
+    Failed: "Failed",
+    Partial: "Partial",
+    Pending: "Pending",
+    PendingAcceptance: "PendingAcceptance",
+    Rejected: "Rejected",
+};
+export const ConnectionNotificationState = {
+    Disabled: "Disabled",
+    Enabled: "Enabled",
+};
+export const ConnectionNotificationType = {
+    Topic: "Topic",
+};
+export const PayerResponsibility = {
+    ServiceOwner: "ServiceOwner",
+};
+export const DnsNameState = {
+    Failed: "failed",
+    PendingVerification: "pendingVerification",
+    Verified: "verified",
+};
+export const ServiceState = {
+    Available: "Available",
+    Deleted: "Deleted",
+    Deleting: "Deleting",
+    Failed: "Failed",
+    Pending: "Pending",
+};
+export const ServiceType = {
+    Gateway: "Gateway",
+    GatewayLoadBalancer: "GatewayLoadBalancer",
+    Interface: "Interface",
+};
+export const LaunchTemplateVersionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchTemplateData && {
+        LaunchTemplateData: ResponseLaunchTemplateDataFilterSensitiveLog(obj.LaunchTemplateData),
+    }),
+});
+export const CreateLaunchTemplateVersionResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchTemplateVersion && {
+        LaunchTemplateVersion: LaunchTemplateVersionFilterSensitiveLog(obj.LaunchTemplateVersion),
+    }),
+});
+export const CreateVerifiedAccessNativeApplicationOidcOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const CreateVerifiedAccessTrustProviderOidcOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const CreateVerifiedAccessTrustProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OidcOptions && {
+        OidcOptions: CreateVerifiedAccessTrustProviderOidcOptionsFilterSensitiveLog(obj.OidcOptions),
+    }),
+    ...(obj.NativeApplicationOidcOptions && {
+        NativeApplicationOidcOptions: CreateVerifiedAccessNativeApplicationOidcOptionsFilterSensitiveLog(obj.NativeApplicationOidcOptions),
+    }),
+});
+export const CreateVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProvider && {
+        VerifiedAccessTrustProvider: VerifiedAccessTrustProviderFilterSensitiveLog(obj.VerifiedAccessTrustProvider),
+    }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_3.js

@@ -0,0 +1,176 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { BundleTaskFilterSensitiveLog, VerifiedAccessTrustProviderFilterSensitiveLog, } from "./models_0";
+export const ServiceConnectivityType = {
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+};
+export const TunnelInsideIpVersion = {
+    ipv4: "ipv4",
+    ipv6: "ipv6",
+};
+export const GatewayAssociationState = {
+    associated: "associated",
+    associating: "associating",
+    disassociating: "disassociating",
+    not_associated: "not-associated",
+};
+export const VpnStaticRouteSource = {
+    Static: "Static",
+};
+export const VpnState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const TelemetryStatus = {
+    DOWN: "DOWN",
+    UP: "UP",
+};
+export const FleetStateCode = {
+    ACTIVE: "active",
+    DELETED: "deleted",
+    DELETED_RUNNING: "deleted_running",
+    DELETED_TERMINATING_INSTANCES: "deleted_terminating",
+    FAILED: "failed",
+    MODIFYING: "modifying",
+    SUBMITTED: "submitted",
+};
+export const DeleteFleetErrorCode = {
+    FLEET_ID_DOES_NOT_EXIST: "fleetIdDoesNotExist",
+    FLEET_ID_MALFORMED: "fleetIdMalformed",
+    FLEET_NOT_IN_DELETABLE_STATE: "fleetNotInDeletableState",
+    UNEXPECTED_ERROR: "unexpectedError",
+};
+export const LaunchTemplateErrorCode = {
+    LAUNCH_TEMPLATE_ID_DOES_NOT_EXIST: "launchTemplateIdDoesNotExist",
+    LAUNCH_TEMPLATE_ID_MALFORMED: "launchTemplateIdMalformed",
+    LAUNCH_TEMPLATE_NAME_DOES_NOT_EXIST: "launchTemplateNameDoesNotExist",
+    LAUNCH_TEMPLATE_NAME_MALFORMED: "launchTemplateNameMalformed",
+    LAUNCH_TEMPLATE_VERSION_DOES_NOT_EXIST: "launchTemplateVersionDoesNotExist",
+    UNEXPECTED_ERROR: "unexpectedError",
+};
+export const DeleteQueuedReservedInstancesErrorCode = {
+    RESERVED_INSTANCES_ID_INVALID: "reserved-instances-id-invalid",
+    RESERVED_INSTANCES_NOT_IN_QUEUED_STATE: "reserved-instances-not-in-queued-state",
+    UNEXPECTED_ERROR: "unexpected-error",
+};
+export const AsnState = {
+    deprovisioned: "deprovisioned",
+    failed_deprovision: "failed-deprovision",
+    failed_provision: "failed-provision",
+    pending_deprovision: "pending-deprovision",
+    pending_provision: "pending-provision",
+    provisioned: "provisioned",
+};
+export const IpamPoolCidrFailureCode = {
+    cidr_not_available: "cidr-not-available",
+    limit_exceeded: "limit-exceeded",
+};
+export const IpamPoolCidrState = {
+    deprovisioned: "deprovisioned",
+    failed_deprovision: "failed-deprovision",
+    failed_import: "failed-import",
+    failed_provision: "failed-provision",
+    pending_deprovision: "pending-deprovision",
+    pending_import: "pending-import",
+    pending_provision: "pending-provision",
+    provisioned: "provisioned",
+};
+export const AvailabilityZoneOptInStatus = {
+    not_opted_in: "not-opted-in",
+    opt_in_not_required: "opt-in-not-required",
+    opted_in: "opted-in",
+};
+export const AvailabilityZoneState = {
+    available: "available",
+    constrained: "constrained",
+    impaired: "impaired",
+    information: "information",
+    unavailable: "unavailable",
+};
+export const MetricType = {
+    aggregate_latency: "aggregate-latency",
+};
+export const PeriodType = {
+    fifteen_minutes: "fifteen-minutes",
+    five_minutes: "five-minutes",
+    one_day: "one-day",
+    one_hour: "one-hour",
+    one_week: "one-week",
+    three_hours: "three-hours",
+};
+export const StatisticType = {
+    p50: "p50",
+};
+export const CapacityBlockExtensionStatus = {
+    PAYMENT_FAILED: "payment-failed",
+    PAYMENT_PENDING: "payment-pending",
+    PAYMENT_SUCCEEDED: "payment-succeeded",
+};
+export const CallerRole = {
+    odcr_owner: "odcr-owner",
+    unused_reservation_billing_owner: "unused-reservation-billing-owner",
+};
+export const CapacityReservationBillingRequestStatus = {
+    accepted: "accepted",
+    cancelled: "cancelled",
+    expired: "expired",
+    pending: "pending",
+    rejected: "rejected",
+    revoked: "revoked",
+};
+export const ClientVpnConnectionStatusCode = {
+    active: "active",
+    failed_to_terminate: "failed-to-terminate",
+    terminated: "terminated",
+    terminating: "terminating",
+};
+export const AssociatedNetworkType = {
+    vpc: "vpc",
+};
+export const ClientVpnEndpointAttributeStatusCode = {
+    applied: "applied",
+    applying: "applying",
+};
+export const VpnTunnelOptionsSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PreSharedKey && { PreSharedKey: SENSITIVE_STRING }),
+});
+export const VpnConnectionOptionsSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TunnelOptions && {
+        TunnelOptions: obj.TunnelOptions.map((item) => VpnTunnelOptionsSpecificationFilterSensitiveLog(item)),
+    }),
+});
+export const CreateVpnConnectionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Options && { Options: VpnConnectionOptionsSpecificationFilterSensitiveLog(obj.Options) }),
+});
+export const TunnelOptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PreSharedKey && { PreSharedKey: SENSITIVE_STRING }),
+});
+export const VpnConnectionOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TunnelOptions && { TunnelOptions: obj.TunnelOptions.map((item) => TunnelOptionFilterSensitiveLog(item)) }),
+});
+export const VpnConnectionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Options && { Options: VpnConnectionOptionsFilterSensitiveLog(obj.Options) }),
+    ...(obj.CustomerGatewayConfiguration && { CustomerGatewayConfiguration: SENSITIVE_STRING }),
+});
+export const CreateVpnConnectionResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnection && { VpnConnection: VpnConnectionFilterSensitiveLog(obj.VpnConnection) }),
+});
+export const DeleteVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProvider && {
+        VerifiedAccessTrustProvider: VerifiedAccessTrustProviderFilterSensitiveLog(obj.VerifiedAccessTrustProvider),
+    }),
+});
+export const DescribeBundleTasksResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BundleTasks && { BundleTasks: obj.BundleTasks.map((item) => BundleTaskFilterSensitiveLog(item)) }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_4.js

@@ -0,0 +1,382 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { LaunchTemplateVersionFilterSensitiveLog, } from "./models_2";
+export const VpnProtocol = {
+    openvpn: "openvpn",
+};
+export const ConversionTaskState = {
+    active: "active",
+    cancelled: "cancelled",
+    cancelling: "cancelling",
+    completed: "completed",
+};
+export const ReportState = {
+    cancelled: "cancelled",
+    complete: "complete",
+    error: "error",
+    running: "running",
+};
+export const ElasticGpuStatus = {
+    Impaired: "IMPAIRED",
+    Ok: "OK",
+};
+export const ElasticGpuState = {
+    Attached: "ATTACHED",
+};
+export const FastLaunchResourceType = {
+    SNAPSHOT: "snapshot",
+};
+export const FastLaunchStateCode = {
+    disabling: "disabling",
+    disabling_failed: "disabling-failed",
+    enabled: "enabled",
+    enabled_failed: "enabled-failed",
+    enabling: "enabling",
+    enabling_failed: "enabling-failed",
+};
+export const FastSnapshotRestoreStateCode = {
+    disabled: "disabled",
+    disabling: "disabling",
+    enabled: "enabled",
+    enabling: "enabling",
+    optimizing: "optimizing",
+};
+export const FleetEventType = {
+    FLEET_CHANGE: "fleet-change",
+    INSTANCE_CHANGE: "instance-change",
+    SERVICE_ERROR: "service-error",
+};
+export const FleetActivityStatus = {
+    ERROR: "error",
+    FULFILLED: "fulfilled",
+    PENDING_FULFILLMENT: "pending_fulfillment",
+    PENDING_TERMINATION: "pending_termination",
+};
+export const FpgaImageAttributeName = {
+    description: "description",
+    loadPermission: "loadPermission",
+    name: "name",
+    productCodes: "productCodes",
+};
+export const PermissionGroup = {
+    all: "all",
+};
+export const ProductCodeValues = {
+    devpay: "devpay",
+    marketplace: "marketplace",
+};
+export const FpgaImageStateCode = {
+    available: "available",
+    failed: "failed",
+    pending: "pending",
+    unavailable: "unavailable",
+};
+export const PaymentOption = {
+    ALL_UPFRONT: "AllUpfront",
+    NO_UPFRONT: "NoUpfront",
+    PARTIAL_UPFRONT: "PartialUpfront",
+};
+export const ReservationState = {
+    ACTIVE: "active",
+    PAYMENT_FAILED: "payment-failed",
+    PAYMENT_PENDING: "payment-pending",
+    RETIRED: "retired",
+};
+export const ImageAttributeName = {
+    blockDeviceMapping: "blockDeviceMapping",
+    bootMode: "bootMode",
+    deregistrationProtection: "deregistrationProtection",
+    description: "description",
+    imdsSupport: "imdsSupport",
+    kernel: "kernel",
+    lastLaunchedTime: "lastLaunchedTime",
+    launchPermission: "launchPermission",
+    productCodes: "productCodes",
+    ramdisk: "ramdisk",
+    sriovNetSupport: "sriovNetSupport",
+    tpmSupport: "tpmSupport",
+    uefiData: "uefiData",
+};
+export const ArchitectureValues = {
+    arm64: "arm64",
+    arm64_mac: "arm64_mac",
+    i386: "i386",
+    x86_64: "x86_64",
+    x86_64_mac: "x86_64_mac",
+};
+export const BootModeValues = {
+    legacy_bios: "legacy-bios",
+    uefi: "uefi",
+    uefi_preferred: "uefi-preferred",
+};
+export const HypervisorType = {
+    ovm: "ovm",
+    xen: "xen",
+};
+export const ImageTypeValues = {
+    kernel: "kernel",
+    machine: "machine",
+    ramdisk: "ramdisk",
+};
+export const ImdsSupportValues = {
+    v2_0: "v2.0",
+};
+export const DeviceType = {
+    ebs: "ebs",
+    instance_store: "instance-store",
+};
+export const ImageState = {
+    available: "available",
+    deregistered: "deregistered",
+    disabled: "disabled",
+    error: "error",
+    failed: "failed",
+    invalid: "invalid",
+    pending: "pending",
+    transient: "transient",
+};
+export const TpmSupportValues = {
+    v2_0: "v2.0",
+};
+export const VirtualizationType = {
+    hvm: "hvm",
+    paravirtual: "paravirtual",
+};
+export const InstanceAttributeName = {
+    blockDeviceMapping: "blockDeviceMapping",
+    disableApiStop: "disableApiStop",
+    disableApiTermination: "disableApiTermination",
+    ebsOptimized: "ebsOptimized",
+    enaSupport: "enaSupport",
+    enclaveOptions: "enclaveOptions",
+    groupSet: "groupSet",
+    instanceInitiatedShutdownBehavior: "instanceInitiatedShutdownBehavior",
+    instanceType: "instanceType",
+    kernel: "kernel",
+    productCodes: "productCodes",
+    ramdisk: "ramdisk",
+    rootDeviceName: "rootDeviceName",
+    sourceDestCheck: "sourceDestCheck",
+    sriovNetSupport: "sriovNetSupport",
+    userData: "userData",
+};
+export const InstanceStateName = {
+    pending: "pending",
+    running: "running",
+    shutting_down: "shutting-down",
+    stopped: "stopped",
+    stopping: "stopping",
+    terminated: "terminated",
+};
+export const InstanceBootModeValues = {
+    legacy_bios: "legacy-bios",
+    uefi: "uefi",
+};
+export const InstanceLifecycleType = {
+    capacity_block: "capacity-block",
+    scheduled: "scheduled",
+    spot: "spot",
+};
+export const InstanceAutoRecoveryState = {
+    default: "default",
+    disabled: "disabled",
+};
+export const InstanceMetadataEndpointState = {
+    disabled: "disabled",
+    enabled: "enabled",
+};
+export const InstanceMetadataProtocolState = {
+    disabled: "disabled",
+    enabled: "enabled",
+};
+export const HttpTokensState = {
+    optional: "optional",
+    required: "required",
+};
+export const InstanceMetadataTagsState = {
+    disabled: "disabled",
+    enabled: "enabled",
+};
+export const InstanceMetadataOptionsState = {
+    applied: "applied",
+    pending: "pending",
+};
+export const MonitoringState = {
+    disabled: "disabled",
+    disabling: "disabling",
+    enabled: "enabled",
+    pending: "pending",
+};
+export const StatusName = {
+    reachability: "reachability",
+};
+export const StatusType = {
+    failed: "failed",
+    initializing: "initializing",
+    insufficient_data: "insufficient-data",
+    passed: "passed",
+};
+export const SummaryStatus = {
+    impaired: "impaired",
+    initializing: "initializing",
+    insufficient_data: "insufficient-data",
+    not_applicable: "not-applicable",
+    ok: "ok",
+};
+export const EventCode = {
+    instance_reboot: "instance-reboot",
+    instance_retirement: "instance-retirement",
+    instance_stop: "instance-stop",
+    system_maintenance: "system-maintenance",
+    system_reboot: "system-reboot",
+};
+export const LocationType = {
+    availability_zone: "availability-zone",
+    availability_zone_id: "availability-zone-id",
+    outpost: "outpost",
+    region: "region",
+};
+export const EbsOptimizedSupport = {
+    default: "default",
+    supported: "supported",
+    unsupported: "unsupported",
+};
+export const EbsEncryptionSupport = {
+    supported: "supported",
+    unsupported: "unsupported",
+};
+export const EbsNvmeSupport = {
+    REQUIRED: "required",
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const InstanceTypeHypervisor = {
+    NITRO: "nitro",
+    XEN: "xen",
+};
+export const DiskType = {
+    hdd: "hdd",
+    ssd: "ssd",
+};
+export const InstanceStorageEncryptionSupport = {
+    required: "required",
+    unsupported: "unsupported",
+};
+export const EphemeralNvmeSupport = {
+    REQUIRED: "required",
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const BandwidthWeightingType = {
+    DEFAULT: "default",
+    EBS_1: "ebs-1",
+    VPC_1: "vpc-1",
+};
+export const EnaSupport = {
+    required: "required",
+    supported: "supported",
+    unsupported: "unsupported",
+};
+export const FlexibleEnaQueuesSupport = {
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const NitroEnclavesSupport = {
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const NitroTpmSupport = {
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const PhcSupport = {
+    SUPPORTED: "supported",
+    UNSUPPORTED: "unsupported",
+};
+export const PlacementGroupStrategy = {
+    cluster: "cluster",
+    partition: "partition",
+    spread: "spread",
+};
+export const ArchitectureType = {
+    arm64: "arm64",
+    arm64_mac: "arm64_mac",
+    i386: "i386",
+    x86_64: "x86_64",
+    x86_64_mac: "x86_64_mac",
+};
+export const SupportedAdditionalProcessorFeature = {
+    AMD_SEV_SNP: "amd-sev-snp",
+};
+export const BootModeType = {
+    legacy_bios: "legacy-bios",
+    uefi: "uefi",
+};
+export const RootDeviceType = {
+    ebs: "ebs",
+    instance_store: "instance-store",
+};
+export const UsageClassType = {
+    capacity_block: "capacity-block",
+    on_demand: "on-demand",
+    spot: "spot",
+};
+export const DiskImageDescriptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ImportManifestUrl && { ImportManifestUrl: SENSITIVE_STRING }),
+});
+export const ImportInstanceVolumeDetailItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Image && { Image: DiskImageDescriptionFilterSensitiveLog(obj.Image) }),
+});
+export const ImportInstanceTaskDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Volumes && { Volumes: obj.Volumes.map((item) => ImportInstanceVolumeDetailItemFilterSensitiveLog(item)) }),
+});
+export const ImportVolumeTaskDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Image && { Image: DiskImageDescriptionFilterSensitiveLog(obj.Image) }),
+});
+export const ConversionTaskFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ImportInstance && { ImportInstance: ImportInstanceTaskDetailsFilterSensitiveLog(obj.ImportInstance) }),
+    ...(obj.ImportVolume && { ImportVolume: ImportVolumeTaskDetailsFilterSensitiveLog(obj.ImportVolume) }),
+});
+export const DescribeConversionTasksResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ConversionTasks && {
+        ConversionTasks: obj.ConversionTasks.map((item) => ConversionTaskFilterSensitiveLog(item)),
+    }),
+});
+export const SnapshotDetailFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Url && { Url: SENSITIVE_STRING }),
+});
+export const ImportImageTaskFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnapshotDetails && {
+        SnapshotDetails: obj.SnapshotDetails.map((item) => SnapshotDetailFilterSensitiveLog(item)),
+    }),
+});
+export const DescribeImportImageTasksResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SnapshotTaskDetailFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Url && { Url: SENSITIVE_STRING }),
+});
+export const ImportSnapshotTaskFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnapshotTaskDetail && { SnapshotTaskDetail: SnapshotTaskDetailFilterSensitiveLog(obj.SnapshotTaskDetail) }),
+});
+export const DescribeImportSnapshotTasksResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ImportSnapshotTasks && {
+        ImportSnapshotTasks: obj.ImportSnapshotTasks.map((item) => ImportSnapshotTaskFilterSensitiveLog(item)),
+    }),
+});
+export const DescribeLaunchTemplateVersionsResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchTemplateVersions && {
+        LaunchTemplateVersions: obj.LaunchTemplateVersions.map((item) => LaunchTemplateVersionFilterSensitiveLog(item)),
+    }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_5.js

@@ -0,0 +1,209 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { VerifiedAccessTrustProviderFilterSensitiveLog, } from "./models_0";
+import { VpnConnectionFilterSensitiveLog, } from "./models_3";
+export const LockState = {
+    compliance: "compliance",
+    compliance_cooloff: "compliance-cooloff",
+    expired: "expired",
+    governance: "governance",
+};
+export const MoveStatus = {
+    movingToVpc: "movingToVpc",
+    restoringToClassic: "restoringToClassic",
+};
+export const FindingsFound = {
+    false: "false",
+    true: "true",
+    unknown: "unknown",
+};
+export const AnalysisStatus = {
+    failed: "failed",
+    running: "running",
+    succeeded: "succeeded",
+};
+export const NetworkInterfaceAttribute = {
+    associatePublicIpAddress: "associatePublicIpAddress",
+    attachment: "attachment",
+    description: "description",
+    groupSet: "groupSet",
+    sourceDestCheck: "sourceDestCheck",
+};
+export const OfferingClassType = {
+    CONVERTIBLE: "convertible",
+    STANDARD: "standard",
+};
+export const OfferingTypeValues = {
+    All_Upfront: "All Upfront",
+    Heavy_Utilization: "Heavy Utilization",
+    Light_Utilization: "Light Utilization",
+    Medium_Utilization: "Medium Utilization",
+    No_Upfront: "No Upfront",
+    Partial_Upfront: "Partial Upfront",
+};
+export const RIProductDescription = {
+    Linux_UNIX: "Linux/UNIX",
+    Linux_UNIX_Amazon_VPC_: "Linux/UNIX (Amazon VPC)",
+    Windows: "Windows",
+    Windows_Amazon_VPC_: "Windows (Amazon VPC)",
+};
+export const RecurringChargeFrequency = {
+    Hourly: "Hourly",
+};
+export const Scope = {
+    AVAILABILITY_ZONE: "Availability Zone",
+    REGIONAL: "Region",
+};
+export const ReservedInstanceState = {
+    active: "active",
+    payment_failed: "payment-failed",
+    payment_pending: "payment-pending",
+    queued: "queued",
+    queued_deleted: "queued-deleted",
+    retired: "retired",
+};
+export const ServiceLinkVirtualInterfaceConfigurationState = {
+    available: "available",
+    deleted: "deleted",
+    deleting: "deleting",
+    pending: "pending",
+};
+export const SnapshotAttributeName = {
+    createVolumePermission: "createVolumePermission",
+    productCodes: "productCodes",
+};
+export const TieringOperationStatus = {
+    archival_completed: "archival-completed",
+    archival_failed: "archival-failed",
+    archival_in_progress: "archival-in-progress",
+    permanent_restore_completed: "permanent-restore-completed",
+    permanent_restore_failed: "permanent-restore-failed",
+    permanent_restore_in_progress: "permanent-restore-in-progress",
+    temporary_restore_completed: "temporary-restore-completed",
+    temporary_restore_failed: "temporary-restore-failed",
+    temporary_restore_in_progress: "temporary-restore-in-progress",
+};
+export const EventType = {
+    BATCH_CHANGE: "fleetRequestChange",
+    ERROR: "error",
+    INFORMATION: "information",
+    INSTANCE_CHANGE: "instanceChange",
+};
+export const ExcessCapacityTerminationPolicy = {
+    DEFAULT: "default",
+    NO_TERMINATION: "noTermination",
+};
+export const OnDemandAllocationStrategy = {
+    LOWEST_PRICE: "lowestPrice",
+    PRIORITIZED: "prioritized",
+};
+export const ReplacementStrategy = {
+    LAUNCH: "launch",
+    LAUNCH_BEFORE_TERMINATE: "launch-before-terminate",
+};
+export const SpotInstanceState = {
+    active: "active",
+    cancelled: "cancelled",
+    closed: "closed",
+    disabled: "disabled",
+    failed: "failed",
+    open: "open",
+};
+export const VerifiedAccessLogDeliveryStatusCode = {
+    FAILED: "failed",
+    SUCCESS: "success",
+};
+export const VolumeAttributeName = {
+    autoEnableIO: "autoEnableIO",
+    productCodes: "productCodes",
+};
+export const VolumeModificationState = {
+    completed: "completed",
+    failed: "failed",
+    modifying: "modifying",
+    optimizing: "optimizing",
+};
+export const VolumeStatusName = {
+    io_enabled: "io-enabled",
+    io_performance: "io-performance",
+};
+export const VolumeStatusInfoStatus = {
+    impaired: "impaired",
+    insufficient_data: "insufficient-data",
+    ok: "ok",
+};
+export const VpcAttributeName = {
+    enableDnsHostnames: "enableDnsHostnames",
+    enableDnsSupport: "enableDnsSupport",
+    enableNetworkAddressUsageMetrics: "enableNetworkAddressUsageMetrics",
+};
+export const VpcBlockPublicAccessExclusionsAllowed = {
+    allowed: "allowed",
+    not_allowed: "not-allowed",
+};
+export const InternetGatewayBlockMode = {
+    block_bidirectional: "block-bidirectional",
+    block_ingress: "block-ingress",
+    off: "off",
+};
+export const ManagedBy = {
+    account: "account",
+    declarative_policy: "declarative-policy",
+};
+export const VpcBlockPublicAccessState = {
+    default_state: "default-state",
+    update_complete: "update-complete",
+    update_in_progress: "update-in-progress",
+};
+export const SpotFleetLaunchSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserData && { UserData: SENSITIVE_STRING }),
+});
+export const SpotFleetRequestConfigDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchSpecifications && {
+        LaunchSpecifications: obj.LaunchSpecifications.map((item) => SpotFleetLaunchSpecificationFilterSensitiveLog(item)),
+    }),
+});
+export const SpotFleetRequestConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SpotFleetRequestConfig && {
+        SpotFleetRequestConfig: SpotFleetRequestConfigDataFilterSensitiveLog(obj.SpotFleetRequestConfig),
+    }),
+});
+export const DescribeSpotFleetRequestsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LaunchSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserData && { UserData: SENSITIVE_STRING }),
+});
+export const SpotInstanceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchSpecification && {
+        LaunchSpecification: LaunchSpecificationFilterSensitiveLog(obj.LaunchSpecification),
+    }),
+});
+export const DescribeSpotInstanceRequestsResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SpotInstanceRequests && {
+        SpotInstanceRequests: obj.SpotInstanceRequests.map((item) => SpotInstanceRequestFilterSensitiveLog(item)),
+    }),
+});
+export const DescribeVerifiedAccessTrustProvidersResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProviders && {
+        VerifiedAccessTrustProviders: obj.VerifiedAccessTrustProviders.map((item) => VerifiedAccessTrustProviderFilterSensitiveLog(item)),
+    }),
+});
+export const DescribeVpnConnectionsResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnections && {
+        VpnConnections: obj.VpnConnections.map((item) => VpnConnectionFilterSensitiveLog(item)),
+    }),
+});
+export const DetachVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProvider && {
+        VerifiedAccessTrustProvider: VerifiedAccessTrustProviderFilterSensitiveLog(obj.VerifiedAccessTrustProvider),
+    }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_6.js

@@ -0,0 +1,148 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { ResponseLaunchTemplateDataFilterSensitiveLog, } from "./models_1";
+export const ImageBlockPublicAccessDisabledState = {
+    unblocked: "unblocked",
+};
+export const RouteServerPropagationState = {
+    AVAILABLE: "available",
+    DELETING: "deleting",
+    PENDING: "pending",
+};
+export const SnapshotBlockPublicAccessState = {
+    block_all_sharing: "block-all-sharing",
+    block_new_sharing: "block-new-sharing",
+    unblocked: "unblocked",
+};
+export const TransitGatewayPropagationState = {
+    disabled: "disabled",
+    disabling: "disabling",
+    enabled: "enabled",
+    enabling: "enabling",
+};
+export const ImageBlockPublicAccessEnabledState = {
+    block_new_sharing: "block-new-sharing",
+};
+export const ClientCertificateRevocationListStatusCode = {
+    active: "active",
+    pending: "pending",
+};
+export const UnlimitedSupportedInstanceFamily = {
+    t2: "t2",
+    t3: "t3",
+    t3a: "t3a",
+    t4g: "t4g",
+};
+export const PartitionLoadFrequency = {
+    DAILY: "daily",
+    MONTHLY: "monthly",
+    NONE: "none",
+    WEEKLY: "weekly",
+};
+export const EkPubKeyFormat = {
+    der: "der",
+    tpmt: "tpmt",
+};
+export const EkPubKeyType = {
+    ECC_SEC_P384: "ecc-sec-p384",
+    RSA_2048: "rsa-2048",
+};
+export const IpamComplianceStatus = {
+    compliant: "compliant",
+    ignored: "ignored",
+    noncompliant: "noncompliant",
+    unmanaged: "unmanaged",
+};
+export const IpamOverlapStatus = {
+    ignored: "ignored",
+    nonoverlapping: "nonoverlapping",
+    overlapping: "overlapping",
+};
+export const IpamAddressHistoryResourceType = {
+    eip: "eip",
+    instance: "instance",
+    network_interface: "network-interface",
+    subnet: "subnet",
+    vpc: "vpc",
+};
+export const IpamDiscoveryFailureCode = {
+    assume_role_failure: "assume-role-failure",
+    throttling_failure: "throttling-failure",
+    unauthorized_failure: "unauthorized-failure",
+};
+export const IpamPublicAddressType = {
+    AMAZON_OWNED_CONTIG: "amazon-owned-contig",
+    AMAZON_OWNED_EIP: "amazon-owned-eip",
+    BYOIP: "byoip",
+    EC2_PUBLIC_IP: "ec2-public-ip",
+    SERVICE_MANAGED_BYOIP: "service-managed-byoip",
+    SERVICE_MANAGED_IP: "service-managed-ip",
+};
+export const IpamPublicAddressAssociationStatus = {
+    ASSOCIATED: "associated",
+    DISASSOCIATED: "disassociated",
+};
+export const IpamPublicAddressAwsService = {
+    AGA: "global-accelerator",
+    DMS: "database-migration-service",
+    EC2_LB: "load-balancer",
+    ECS: "elastic-container-service",
+    NAT_GATEWAY: "nat-gateway",
+    OTHER: "other",
+    RDS: "relational-database-service",
+    REDSHIFT: "redshift",
+    S2S_VPN: "site-to-site-vpn",
+};
+export const IpamResourceCidrIpSource = {
+    amazon: "amazon",
+    byoip: "byoip",
+    none: "none",
+};
+export const IpamNetworkInterfaceAttachmentStatus = {
+    available: "available",
+    in_use: "in-use",
+};
+export const IpamResourceType = {
+    eip: "eip",
+    eni: "eni",
+    ipv6_pool: "ipv6-pool",
+    public_ipv4_pool: "public-ipv4-pool",
+    subnet: "subnet",
+    vpc: "vpc",
+};
+export const IpamManagementState = {
+    ignored: "ignored",
+    managed: "managed",
+    unmanaged: "unmanaged",
+};
+export const RouteServerRouteInstallationStatus = {
+    INSTALLED: "installed",
+    REJECTED: "rejected",
+};
+export const RouteServerRouteStatus = {
+    IN_FIB: "in-fib",
+    IN_RIB: "in-rib",
+};
+export const VerifiedAccessInstanceUserTrustProviderClientConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const ExportVerifiedAccessInstanceClientConfigurationResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserTrustProvider && {
+        UserTrustProvider: VerifiedAccessInstanceUserTrustProviderClientConfigurationFilterSensitiveLog(obj.UserTrustProvider),
+    }),
+});
+export const GetInstanceTpmEkPubResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.KeyValue && { KeyValue: SENSITIVE_STRING }),
+});
+export const GetLaunchTemplateDataResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchTemplateData && {
+        LaunchTemplateData: ResponseLaunchTemplateDataFilterSensitiveLog(obj.LaunchTemplateData),
+    }),
+});
+export const GetPasswordDataResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PasswordData && { PasswordData: SENSITIVE_STRING }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_7.js

@@ -0,0 +1,200 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { VerifiedAccessTrustProviderFilterSensitiveLog, } from "./models_0";
+import { VpnConnectionFilterSensitiveLog, } from "./models_3";
+import { ConversionTaskFilterSensitiveLog, SnapshotDetailFilterSensitiveLog, SnapshotTaskDetailFilterSensitiveLog, } from "./models_4";
+export const LockMode = {
+    compliance: "compliance",
+    governance: "governance",
+};
+export const ModifyAvailabilityZoneOptInStatus = {
+    not_opted_in: "not-opted-in",
+    opted_in: "opted-in",
+};
+export const OperationType = {
+    add: "add",
+    remove: "remove",
+};
+export const UnsuccessfulInstanceCreditSpecificationErrorCode = {
+    INCORRECT_INSTANCE_STATE: "IncorrectInstanceState",
+    INSTANCE_CREDIT_SPECIFICATION_NOT_SUPPORTED: "InstanceCreditSpecification.NotSupported",
+    INSTANCE_NOT_FOUND: "InvalidInstanceID.NotFound",
+    INVALID_INSTANCE_ID: "InvalidInstanceID.Malformed",
+};
+export const DefaultInstanceMetadataEndpointState = {
+    disabled: "disabled",
+    enabled: "enabled",
+    no_preference: "no-preference",
+};
+export const MetadataDefaultHttpTokensState = {
+    no_preference: "no-preference",
+    optional: "optional",
+    required: "required",
+};
+export const DefaultInstanceMetadataTagsState = {
+    disabled: "disabled",
+    enabled: "enabled",
+    no_preference: "no-preference",
+};
+export const HostTenancy = {
+    dedicated: "dedicated",
+    default: "default",
+    host: "host",
+};
+export const TargetStorageTier = {
+    archive: "archive",
+};
+export const TrafficMirrorFilterRuleField = {
+    description: "description",
+    destination_port_range: "destination-port-range",
+    protocol: "protocol",
+    source_port_range: "source-port-range",
+};
+export const TrafficMirrorSessionField = {
+    description: "description",
+    packet_length: "packet-length",
+    virtual_network_id: "virtual-network-id",
+};
+export const VpcTenancy = {
+    default: "default",
+};
+export const Status = {
+    inClassic: "InClassic",
+    inVpc: "InVpc",
+    moveInProgress: "MoveInProgress",
+};
+export const VerificationMethod = {
+    dns_token: "dns-token",
+    remarks_x509: "remarks-x509",
+};
+export const ReportInstanceReasonCodes = {
+    instance_stuck_in_state: "instance-stuck-in-state",
+    not_accepting_credentials: "not-accepting-credentials",
+    other: "other",
+    password_not_available: "password-not-available",
+    performance_ebs_volume: "performance-ebs-volume",
+    performance_instance_store: "performance-instance-store",
+    performance_network: "performance-network",
+    performance_other: "performance-other",
+    unresponsive: "unresponsive",
+};
+export const ReportStatusType = {
+    impaired: "impaired",
+    ok: "ok",
+};
+export const GetVpnConnectionDeviceSampleConfigurationResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnectionDeviceSampleConfiguration && { VpnConnectionDeviceSampleConfiguration: SENSITIVE_STRING }),
+});
+export const ImageDiskContainerFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Url && { Url: SENSITIVE_STRING }),
+});
+export const ImportImageRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DiskContainers && {
+        DiskContainers: obj.DiskContainers.map((item) => ImageDiskContainerFilterSensitiveLog(item)),
+    }),
+});
+export const ImportImageResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnapshotDetails && {
+        SnapshotDetails: obj.SnapshotDetails.map((item) => SnapshotDetailFilterSensitiveLog(item)),
+    }),
+});
+export const DiskImageDetailFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ImportManifestUrl && { ImportManifestUrl: SENSITIVE_STRING }),
+});
+export const DiskImageFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Image && { Image: DiskImageDetailFilterSensitiveLog(obj.Image) }),
+});
+export const UserDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ImportInstanceLaunchSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserData && { UserData: SENSITIVE_STRING }),
+});
+export const ImportInstanceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchSpecification && {
+        LaunchSpecification: ImportInstanceLaunchSpecificationFilterSensitiveLog(obj.LaunchSpecification),
+    }),
+    ...(obj.DiskImages && { DiskImages: obj.DiskImages.map((item) => DiskImageFilterSensitiveLog(item)) }),
+});
+export const ImportInstanceResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ConversionTask && { ConversionTask: ConversionTaskFilterSensitiveLog(obj.ConversionTask) }),
+});
+export const SnapshotDiskContainerFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Url && { Url: SENSITIVE_STRING }),
+});
+export const ImportSnapshotRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DiskContainer && { DiskContainer: SnapshotDiskContainerFilterSensitiveLog(obj.DiskContainer) }),
+});
+export const ImportSnapshotResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnapshotTaskDetail && { SnapshotTaskDetail: SnapshotTaskDetailFilterSensitiveLog(obj.SnapshotTaskDetail) }),
+});
+export const ImportVolumeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Image && { Image: DiskImageDetailFilterSensitiveLog(obj.Image) }),
+});
+export const ImportVolumeResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ConversionTask && { ConversionTask: ConversionTaskFilterSensitiveLog(obj.ConversionTask) }),
+});
+export const ModifyVerifiedAccessNativeApplicationOidcOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const ModifyVerifiedAccessTrustProviderOidcOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientSecret && { ClientSecret: SENSITIVE_STRING }),
+});
+export const ModifyVerifiedAccessTrustProviderRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OidcOptions && {
+        OidcOptions: ModifyVerifiedAccessTrustProviderOidcOptionsFilterSensitiveLog(obj.OidcOptions),
+    }),
+    ...(obj.NativeApplicationOidcOptions && {
+        NativeApplicationOidcOptions: ModifyVerifiedAccessNativeApplicationOidcOptionsFilterSensitiveLog(obj.NativeApplicationOidcOptions),
+    }),
+});
+export const ModifyVerifiedAccessTrustProviderResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VerifiedAccessTrustProvider && {
+        VerifiedAccessTrustProvider: VerifiedAccessTrustProviderFilterSensitiveLog(obj.VerifiedAccessTrustProvider),
+    }),
+});
+export const ModifyVpnConnectionResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnection && { VpnConnection: VpnConnectionFilterSensitiveLog(obj.VpnConnection) }),
+});
+export const ModifyVpnConnectionOptionsResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnection && { VpnConnection: VpnConnectionFilterSensitiveLog(obj.VpnConnection) }),
+});
+export const ModifyVpnTunnelCertificateResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnection && { VpnConnection: VpnConnectionFilterSensitiveLog(obj.VpnConnection) }),
+});
+export const ModifyVpnTunnelOptionsSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PreSharedKey && { PreSharedKey: SENSITIVE_STRING }),
+});
+export const ModifyVpnTunnelOptionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TunnelOptions && { TunnelOptions: SENSITIVE_STRING }),
+});
+export const ModifyVpnTunnelOptionsResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.VpnConnection && { VpnConnection: VpnConnectionFilterSensitiveLog(obj.VpnConnection) }),
+});
+export const ReportInstanceStatusRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Description && { Description: SENSITIVE_STRING }),
+});

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/models/models_8.js

@@ -0,0 +1,45 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { SpotFleetRequestConfigDataFilterSensitiveLog, SpotInstanceRequestFilterSensitiveLog, } from "./models_5";
+export const ResetFpgaImageAttributeName = {
+    loadPermission: "loadPermission",
+};
+export const ResetImageAttributeName = {
+    launchPermission: "launchPermission",
+};
+export const MembershipType = {
+    igmp: "igmp",
+    static: "static",
+};
+export const RequestSpotFleetRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SpotFleetRequestConfig && {
+        SpotFleetRequestConfig: SpotFleetRequestConfigDataFilterSensitiveLog(obj.SpotFleetRequestConfig),
+    }),
+});
+export const RequestSpotLaunchSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserData && { UserData: SENSITIVE_STRING }),
+});
+export const RequestSpotInstancesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchSpecification && {
+        LaunchSpecification: RequestSpotLaunchSpecificationFilterSensitiveLog(obj.LaunchSpecification),
+    }),
+});
+export const RequestSpotInstancesResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SpotInstanceRequests && {
+        SpotInstanceRequests: obj.SpotInstanceRequests.map((item) => SpotInstanceRequestFilterSensitiveLog(item)),
+    }),
+});
+export const RunInstancesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.UserData && { UserData: SENSITIVE_STRING }),
+});
+export const ScheduledInstancesLaunchSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RunScheduledInstancesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LaunchSpecification && { LaunchSpecification: SENSITIVE_STRING }),
+});