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.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type CapacityTaskId = string;
export type OutpostIdentifier = string;
export type ErrorMessage = string;
export type OrderId = string;
export type SkuCode = string;
export type LineItemQuantity = number;
export type OutpostIdOnly = string;
export type LineItemId = string;
export type TrackingId = string;
export type AssetId = string;
export type MacAddress = string;
export type ISO8601Timestamp = Date;
export type OutpostName = string;
export type OutpostDescription = string;
export type SiteId = string;
export type AvailabilityZone = string;
export type AvailabilityZoneId = string;
export type TagKey = string;
export type TagValue = string;
export type OutpostId = string;
export type OwnerId = string;
export type OutpostArn = string;
export type LifeCycleStatus = string;
export type SiteArn = string;
export type AutoFillIdempotencyToken = string;
export type SiteName = string;
export type SiteDescription = string;
export type SiteNotes = string;
export type ContactName = string;
export type ContactPhoneNumber = string;
export type AddressLine1 = string;
export type AddressLine2 = string;
export type AddressLine3 = string;
export type City = string;
export type StateOrRegion = string;
export type DistrictOrCounty = string;
export type PostalCode = string;
export type CountryCode = string;
export type Municipality = string;
export type AccountId = string;
export type InstanceTypeName = string;
export type InstanceTypeCount = number;
export type InstanceId = string;
export type DryRun = boolean;
export type CapacityTaskStatusReason = string;
export type Family = string;
export type MaxSize = string;
export type Quantity = string;
export type CatalogItemPowerKva = number;
export type CatalogItemWeightLbs = number;
export type SupportedUplinkGbps = number;
export type ConnectionId = string;
export type WireGuardPublicKey = string;
export type ServerEndpoint = string;
export type CIDR = string;
export type Token = string;
export type MaxResults1000 = number;
export type InstanceType = string;
export type VCPUCount = number;
export type AssetIdInput = string;
export type OutpostInstanceType = string;
export type HostId = string;
export type RackId = string;
export type InstanceFamilyName = string;
export type RackElevation = number;
export type Arn = string;
export type DeviceSerialNumber = string;
export type NetworkInterfaceDeviceIndex = number;
export type UnderlayIpAddress = string;
export type ValidateOnly = boolean;
export interface CancelCapacityTaskInput {
    CapacityTaskId: string;
    OutpostIdentifier: string;
}
export declare const CancelCapacityTaskInput: S.Schema<CancelCapacityTaskInput>;
export interface CancelCapacityTaskOutput {
}
export declare const CancelCapacityTaskOutput: S.Schema<CancelCapacityTaskOutput>;
export type ResourceType = "OUTPOST" | "ORDER" | (string & {});
export declare const ResourceType: S.String;
export interface CancelOrderInput {
    OrderId: string;
}
export declare const CancelOrderInput: S.Schema<CancelOrderInput>;
export interface CancelOrderOutput {
}
export declare const CancelOrderOutput: S.Schema<CancelOrderOutput>;
export interface LineItemRequest {
    CatalogItemId?: string;
    Quantity?: number;
}
export declare const LineItemRequest: S.Schema<LineItemRequest>;
export type LineItemRequestListDefinition = LineItemRequest[];
export declare const LineItemRequestListDefinition: S.$Array<S.Schema<LineItemRequest>>;
export type PaymentOption = "ALL_UPFRONT" | "NO_UPFRONT" | "PARTIAL_UPFRONT" | (string & {});
export declare const PaymentOption: S.String;
export type PaymentTerm = "THREE_YEARS" | "ONE_YEAR" | "FIVE_YEARS" | (string & {});
export declare const PaymentTerm: S.String;
export interface CreateOrderInput {
    OutpostIdentifier: string;
    LineItems?: LineItemRequest[];
    PaymentOption: PaymentOption;
    PaymentTerm?: PaymentTerm;
}
export declare const CreateOrderInput: S.Schema<CreateOrderInput>;
export type OrderStatus = "RECEIVED" | "PENDING" | "PROCESSING" | "INSTALLING" | "FULFILLED" | "CANCELLED" | "PREPARING" | "IN_PROGRESS" | "DELIVERED" | "COMPLETED" | "ERROR" | (string & {});
export declare const OrderStatus: S.String;
export type LineItemStatus = "PREPARING" | "BUILDING" | "SHIPPED" | "DELIVERED" | "INSTALLING" | "INSTALLED" | "ERROR" | "CANCELLED" | "REPLACED" | (string & {});
export declare const LineItemStatus: S.String;
export type ShipmentCarrier = "DHL" | "DBS" | "FEDEX" | "UPS" | "EXPEDITORS" | (string & {});
export declare const ShipmentCarrier: S.String;
export interface ShipmentInformation {
    ShipmentTrackingNumber?: string;
    ShipmentCarrier?: ShipmentCarrier;
}
export declare const ShipmentInformation: S.Schema<ShipmentInformation>;
export type MacAddressList = string[];
export declare const MacAddressList: S.$Array<S.String>;
export interface LineItemAssetInformation {
    AssetId?: string;
    MacAddressList?: string[];
}
export declare const LineItemAssetInformation: S.Schema<LineItemAssetInformation>;
export type LineItemAssetInformationList = LineItemAssetInformation[];
export declare const LineItemAssetInformationList: S.$Array<S.Schema<LineItemAssetInformation>>;
export interface LineItem {
    CatalogItemId?: string;
    LineItemId?: string;
    Quantity?: number;
    Status?: LineItemStatus;
    ShipmentInformation?: ShipmentInformation;
    AssetInformationList?: LineItemAssetInformation[];
    PreviousLineItemId?: string;
    PreviousOrderId?: string;
}
export declare const LineItem: S.Schema<LineItem>;
export type LineItemListDefinition = LineItem[];
export declare const LineItemListDefinition: S.$Array<S.Schema<LineItem>>;
export type OrderType = "OUTPOST" | "REPLACEMENT" | (string & {});
export declare const OrderType: S.String;
export interface Order {
    OutpostId?: string;
    OrderId?: string;
    Status?: OrderStatus;
    LineItems?: LineItem[];
    PaymentOption?: PaymentOption;
    OrderSubmissionDate?: Date;
    OrderFulfilledDate?: Date;
    PaymentTerm?: PaymentTerm;
    OrderType?: OrderType;
}
export declare const Order: S.Schema<Order>;
export interface CreateOrderOutput {
    Order?: Order;
}
export declare const CreateOrderOutput: S.Schema<CreateOrderOutput>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export type SupportedHardwareType = "RACK" | "SERVER" | (string & {});
export declare const SupportedHardwareType: S.String;
export interface CreateOutpostInput {
    Name: string;
    Description?: string;
    SiteId: string;
    AvailabilityZone?: string;
    AvailabilityZoneId?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    SupportedHardwareType?: SupportedHardwareType;
}
export declare const CreateOutpostInput: S.Schema<CreateOutpostInput>;
export interface Outpost {
    OutpostId?: string;
    OwnerId?: string;
    OutpostArn?: string;
    SiteId?: string;
    Name?: string;
    Description?: string;
    LifeCycleStatus?: string;
    AvailabilityZone?: string;
    AvailabilityZoneId?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    SiteArn?: string;
    SupportedHardwareType?: SupportedHardwareType;
}
export declare const Outpost: S.Schema<Outpost>;
export interface CreateOutpostOutput {
    Outpost?: Outpost;
}
export declare const CreateOutpostOutput: S.Schema<CreateOutpostOutput>;
export interface CreateRenewalInput {
    PaymentOption: PaymentOption;
    PaymentTerm: PaymentTerm;
    OutpostIdentifier: string;
    ClientToken?: string;
}
export declare const CreateRenewalInput: S.Schema<CreateRenewalInput>;
export interface CreateRenewalOutput {
    PaymentOption?: PaymentOption;
    PaymentTerm?: PaymentTerm;
    OutpostId?: string;
    UpfrontPrice?: number;
    MonthlyRecurringPrice?: number;
}
export declare const CreateRenewalOutput: S.Schema<CreateRenewalOutput>;
export interface Address {
    ContactName: string;
    ContactPhoneNumber: string;
    AddressLine1: string;
    AddressLine2?: string;
    AddressLine3?: string;
    City: string;
    StateOrRegion: string;
    DistrictOrCounty?: string;
    PostalCode: string;
    CountryCode: string;
    Municipality?: string;
}
export declare const Address: S.Schema<Address>;
export type PowerDrawKva = "POWER_5_KVA" | "POWER_10_KVA" | "POWER_15_KVA" | "POWER_30_KVA" | (string & {});
export declare const PowerDrawKva: S.String;
export type PowerPhase = "SINGLE_PHASE" | "THREE_PHASE" | (string & {});
export declare const PowerPhase: S.String;
export type PowerConnector = "L6_30P" | "IEC309" | "AH530P7W" | "AH532P6W" | "CS8365C" | (string & {});
export declare const PowerConnector: S.String;
export type PowerFeedDrop = "ABOVE_RACK" | "BELOW_RACK" | (string & {});
export declare const PowerFeedDrop: S.String;
export type UplinkGbps = "UPLINK_1G" | "UPLINK_10G" | "UPLINK_40G" | "UPLINK_100G" | (string & {});
export declare const UplinkGbps: S.String;
export type UplinkCount = "UPLINK_COUNT_1" | "UPLINK_COUNT_2" | "UPLINK_COUNT_3" | "UPLINK_COUNT_4" | "UPLINK_COUNT_5" | "UPLINK_COUNT_6" | "UPLINK_COUNT_7" | "UPLINK_COUNT_8" | "UPLINK_COUNT_12" | "UPLINK_COUNT_16" | (string & {});
export declare const UplinkCount: S.String;
export type FiberOpticCableType = "SINGLE_MODE" | "MULTI_MODE" | (string & {});
export declare const FiberOpticCableType: S.String;
export type OpticalStandard = "OPTIC_10GBASE_SR" | "OPTIC_10GBASE_IR" | "OPTIC_10GBASE_LR" | "OPTIC_40GBASE_SR" | "OPTIC_40GBASE_ESR" | "OPTIC_40GBASE_IR4_LR4L" | "OPTIC_40GBASE_LR4" | "OPTIC_100GBASE_SR4" | "OPTIC_100GBASE_CWDM4" | "OPTIC_100GBASE_LR4" | "OPTIC_100G_PSM4_MSA" | "OPTIC_1000BASE_LX" | "OPTIC_1000BASE_SX" | (string & {});
export declare const OpticalStandard: S.String;
export type MaximumSupportedWeightLbs = "NO_LIMIT" | "MAX_1400_LBS" | "MAX_1600_LBS" | "MAX_1800_LBS" | "MAX_2000_LBS" | (string & {});
export declare const MaximumSupportedWeightLbs: S.String;
export interface RackPhysicalProperties {
    PowerDrawKva?: PowerDrawKva;
    PowerPhase?: PowerPhase;
    PowerConnector?: PowerConnector;
    PowerFeedDrop?: PowerFeedDrop;
    UplinkGbps?: UplinkGbps;
    UplinkCount?: UplinkCount;
    FiberOpticCableType?: FiberOpticCableType;
    OpticalStandard?: OpticalStandard;
    MaximumSupportedWeightLbs?: MaximumSupportedWeightLbs;
}
export declare const RackPhysicalProperties: S.Schema<RackPhysicalProperties>;
export interface CreateSiteInput {
    Name: string;
    Description?: string;
    Notes?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    OperatingAddress?: Address;
    ShippingAddress?: Address;
    RackPhysicalProperties?: RackPhysicalProperties;
}
export declare const CreateSiteInput: S.Schema<CreateSiteInput>;
export interface Site {
    SiteId?: string;
    AccountId?: string;
    Name?: string;
    Description?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    SiteArn?: string;
    Notes?: string;
    OperatingAddressCountryCode?: string;
    OperatingAddressStateOrRegion?: string;
    OperatingAddressCity?: string;
    RackPhysicalProperties?: RackPhysicalProperties;
}
export declare const Site: S.Schema<Site>;
export interface CreateSiteOutput {
    Site?: Site;
}
export declare const CreateSiteOutput: S.Schema<CreateSiteOutput>;
export interface DeleteOutpostInput {
    OutpostId: string;
}
export declare const DeleteOutpostInput: S.Schema<DeleteOutpostInput>;
export interface DeleteOutpostOutput {
}
export declare const DeleteOutpostOutput: S.Schema<DeleteOutpostOutput>;
export interface DeleteSiteInput {
    SiteId: string;
}
export declare const DeleteSiteInput: S.Schema<DeleteSiteInput>;
export interface DeleteSiteOutput {
}
export declare const DeleteSiteOutput: S.Schema<DeleteSiteOutput>;
export interface GetCapacityTaskInput {
    CapacityTaskId: string;
    OutpostIdentifier: string;
}
export declare const GetCapacityTaskInput: S.Schema<GetCapacityTaskInput>;
export interface InstanceTypeCapacity {
    InstanceType: string;
    Count: number;
}
export declare const InstanceTypeCapacity: S.Schema<InstanceTypeCapacity>;
export type RequestedInstancePools = InstanceTypeCapacity[];
export declare const RequestedInstancePools: S.$Array<S.Schema<InstanceTypeCapacity>>;
export type InstanceIdList = string[];
export declare const InstanceIdList: S.$Array<S.String>;
export type AccountIdList = string[];
export declare const AccountIdList: S.$Array<S.String>;
export type AWSServiceName = "AWS" | "EC2" | "ELASTICACHE" | "ELB" | "RDS" | "ROUTE53" | (string & {});
export declare const AWSServiceName: S.String;
export type AWSServiceNameList = AWSServiceName[];
export declare const AWSServiceNameList: S.$Array<S.String>;
export interface InstancesToExclude {
    Instances?: string[];
    AccountIds?: string[];
    Services?: AWSServiceName[];
}
export declare const InstancesToExclude: S.Schema<InstancesToExclude>;
export type CapacityTaskStatus = "REQUESTED" | "IN_PROGRESS" | "FAILED" | "COMPLETED" | "WAITING_FOR_EVACUATION" | "CANCELLATION_IN_PROGRESS" | "CANCELLED" | (string & {});
export declare const CapacityTaskStatus: S.String;
export type CapacityTaskFailureType = "UNSUPPORTED_CAPACITY_CONFIGURATION" | "UNEXPECTED_ASSET_STATE" | "BLOCKING_INSTANCES_NOT_EVACUATED" | "INTERNAL_SERVER_ERROR" | "RESOURCE_NOT_FOUND" | (string & {});
export declare const CapacityTaskFailureType: S.String;
export interface CapacityTaskFailure {
    Reason: string;
    Type?: CapacityTaskFailureType;
}
export declare const CapacityTaskFailure: S.Schema<CapacityTaskFailure>;
export type TaskActionOnBlockingInstances = "WAIT_FOR_EVACUATION" | "FAIL_TASK" | (string & {});
export declare const TaskActionOnBlockingInstances: S.String;
export interface GetCapacityTaskOutput {
    CapacityTaskId?: string;
    OutpostId?: string;
    OrderId?: string;
    AssetId?: string;
    RequestedInstancePools?: InstanceTypeCapacity[];
    InstancesToExclude?: InstancesToExclude;
    DryRun?: boolean;
    CapacityTaskStatus?: CapacityTaskStatus;
    Failed?: CapacityTaskFailure;
    CreationDate?: Date;
    CompletionDate?: Date;
    LastModifiedDate?: Date;
    TaskActionOnBlockingInstances?: TaskActionOnBlockingInstances;
}
export declare const GetCapacityTaskOutput: S.Schema<GetCapacityTaskOutput>;
export interface GetCatalogItemInput {
    CatalogItemId: string;
}
export declare const GetCatalogItemInput: S.Schema<GetCatalogItemInput>;
export type CatalogItemStatus = "AVAILABLE" | "DISCONTINUED" | (string & {});
export declare const CatalogItemStatus: S.String;
export interface EC2Capacity {
    Family?: string;
    MaxSize?: string;
    Quantity?: string;
}
export declare const EC2Capacity: S.Schema<EC2Capacity>;
export type EC2CapacityListDefinition = EC2Capacity[];
export declare const EC2CapacityListDefinition: S.$Array<S.Schema<EC2Capacity>>;
export type SupportedUplinkGbpsListDefinition = number[];
export declare const SupportedUplinkGbpsListDefinition: S.$Array<S.Number>;
export type SupportedStorageEnum = "EBS" | "S3" | (string & {});
export declare const SupportedStorageEnum: S.String;
export type SupportedStorageList = SupportedStorageEnum[];
export declare const SupportedStorageList: S.$Array<S.String>;
export interface CatalogItem {
    CatalogItemId?: string;
    ItemStatus?: CatalogItemStatus;
    EC2Capacities?: EC2Capacity[];
    PowerKva?: number;
    WeightLbs?: number;
    SupportedUplinkGbps?: number[];
    SupportedStorage?: SupportedStorageEnum[];
}
export declare const CatalogItem: S.Schema<CatalogItem>;
export interface GetCatalogItemOutput {
    CatalogItem?: CatalogItem;
}
export declare const GetCatalogItemOutput: S.Schema<GetCatalogItemOutput>;
export interface GetConnectionRequest {
    ConnectionId: string;
}
export declare const GetConnectionRequest: S.Schema<GetConnectionRequest>;
export type CIDRList = string[];
export declare const CIDRList: S.$Array<S.String>;
export interface ConnectionDetails {
    ClientPublicKey?: string;
    ServerPublicKey?: string;
    ServerEndpoint?: string;
    ClientTunnelAddress?: string;
    ServerTunnelAddress?: string;
    AllowedIps?: string[];
}
export declare const ConnectionDetails: S.Schema<ConnectionDetails>;
export interface GetConnectionResponse {
    ConnectionId?: string;
    ConnectionDetails?: ConnectionDetails;
}
export declare const GetConnectionResponse: S.Schema<GetConnectionResponse>;
export interface GetOrderInput {
    OrderId: string;
}
export declare const GetOrderInput: S.Schema<GetOrderInput>;
export interface GetOrderOutput {
    Order?: Order;
}
export declare const GetOrderOutput: S.Schema<GetOrderOutput>;
export interface GetOutpostInput {
    OutpostId: string;
}
export declare const GetOutpostInput: S.Schema<GetOutpostInput>;
export interface GetOutpostOutput {
    Outpost?: Outpost;
}
export declare const GetOutpostOutput: S.Schema<GetOutpostOutput>;
export interface GetOutpostBillingInformationInput {
    NextToken?: string;
    MaxResults?: number;
    OutpostIdentifier: string;
}
export declare const GetOutpostBillingInformationInput: S.Schema<GetOutpostBillingInformationInput>;
export type SubscriptionType = "ORIGINAL" | "RENEWAL" | "CAPACITY_INCREASE" | (string & {});
export declare const SubscriptionType: S.String;
export type SubscriptionStatus = "ACTIVE" | "PENDING" | "INACTIVE" | "CANCELLED" | (string & {});
export declare const SubscriptionStatus: S.String;
export type OrderIdList = string[];
export declare const OrderIdList: S.$Array<S.String>;
export interface Subscription {
    SubscriptionId?: string;
    SubscriptionType?: SubscriptionType;
    SubscriptionStatus?: SubscriptionStatus;
    OrderIds?: string[];
    BeginDate?: Date;
    EndDate?: Date;
    MonthlyRecurringPrice?: number;
    UpfrontPrice?: number;
}
export declare const Subscription: S.Schema<Subscription>;
export type SubscriptionList = Subscription[];
export declare const SubscriptionList: S.$Array<S.Schema<Subscription>>;
export interface GetOutpostBillingInformationOutput {
    NextToken?: string;
    Subscriptions?: Subscription[];
    ContractEndDate?: string;
    PaymentTerm?: PaymentTerm;
    PaymentOption?: PaymentOption;
}
export declare const GetOutpostBillingInformationOutput: S.Schema<GetOutpostBillingInformationOutput>;
export interface GetOutpostInstanceTypesInput {
    OutpostId: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const GetOutpostInstanceTypesInput: S.Schema<GetOutpostInstanceTypesInput>;
export interface InstanceTypeItem {
    InstanceType?: string;
    VCPUs?: number;
}
export declare const InstanceTypeItem: S.Schema<InstanceTypeItem>;
export type InstanceTypeListDefinition = InstanceTypeItem[];
export declare const InstanceTypeListDefinition: S.$Array<S.Schema<InstanceTypeItem>>;
export interface GetOutpostInstanceTypesOutput {
    InstanceTypes?: InstanceTypeItem[];
    NextToken?: string;
    OutpostId?: string;
    OutpostArn?: string;
}
export declare const GetOutpostInstanceTypesOutput: S.Schema<GetOutpostInstanceTypesOutput>;
export interface GetOutpostSupportedInstanceTypesInput {
    OutpostIdentifier: string;
    OrderId?: string;
    AssetId?: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const GetOutpostSupportedInstanceTypesInput: S.Schema<GetOutpostSupportedInstanceTypesInput>;
export interface GetOutpostSupportedInstanceTypesOutput {
    InstanceTypes?: InstanceTypeItem[];
    NextToken?: string;
}
export declare const GetOutpostSupportedInstanceTypesOutput: S.Schema<GetOutpostSupportedInstanceTypesOutput>;
export interface GetRenewalPricingInput {
    OutpostIdentifier: string;
}
export declare const GetRenewalPricingInput: S.Schema<GetRenewalPricingInput>;
export type PricingResult = "PRICED" | "UNABLE_TO_PRICE" | (string & {});
export declare const PricingResult: S.String;
export type QuotePricingType = "SUBSCRIPTION" | (string & {});
export declare const QuotePricingType: S.String;
export interface SubscriptionPricingDetails {
    PaymentOption?: PaymentOption;
    PaymentTerm?: PaymentTerm;
    UpfrontPrice?: number;
    MonthlyRecurringPrice?: number;
}
export declare const SubscriptionPricingDetails: S.Schema<SubscriptionPricingDetails>;
export interface PricingOption {
    PricingType?: QuotePricingType;
    SubscriptionPricingDetails?: SubscriptionPricingDetails;
}
export declare const PricingOption: S.Schema<PricingOption>;
export type PricingOptionList = PricingOption[];
export declare const PricingOptionList: S.$Array<S.Schema<PricingOption>>;
export interface GetRenewalPricingOutput {
    PricingResult?: PricingResult;
    PricingOptions?: PricingOption[];
}
export declare const GetRenewalPricingOutput: S.Schema<GetRenewalPricingOutput>;
export interface GetSiteInput {
    SiteId: string;
}
export declare const GetSiteInput: S.Schema<GetSiteInput>;
export interface GetSiteOutput {
    Site?: Site;
}
export declare const GetSiteOutput: S.Schema<GetSiteOutput>;
export type AddressType = "SHIPPING_ADDRESS" | "OPERATING_ADDRESS" | (string & {});
export declare const AddressType: S.String;
export interface GetSiteAddressInput {
    SiteId: string;
    AddressType: AddressType;
}
export declare const GetSiteAddressInput: S.Schema<GetSiteAddressInput>;
export interface GetSiteAddressOutput {
    SiteId?: string;
    AddressType?: AddressType;
    Address?: Address;
}
export declare const GetSiteAddressOutput: S.Schema<GetSiteAddressOutput>;
export type AssetIdList = string[];
export declare const AssetIdList: S.$Array<S.String>;
export type OutpostInstanceTypeList = string[];
export declare const OutpostInstanceTypeList: S.$Array<S.String>;
export interface ListAssetInstancesInput {
    OutpostIdentifier: string;
    AssetIdFilter?: string[];
    InstanceTypeFilter?: string[];
    AccountIdFilter?: string[];
    AwsServiceFilter?: AWSServiceName[];
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListAssetInstancesInput: S.Schema<ListAssetInstancesInput>;
export interface AssetInstance {
    InstanceId?: string;
    InstanceType?: string;
    AssetId?: string;
    AccountId?: string;
    AwsServiceName?: AWSServiceName;
}
export declare const AssetInstance: S.Schema<AssetInstance>;
export type AssetInstanceList = AssetInstance[];
export declare const AssetInstanceList: S.$Array<S.Schema<AssetInstance>>;
export interface ListAssetInstancesOutput {
    AssetInstances?: AssetInstance[];
    NextToken?: string;
}
export declare const ListAssetInstancesOutput: S.Schema<ListAssetInstancesOutput>;
export type HostIdList = string[];
export declare const HostIdList: S.$Array<S.String>;
export type AssetState = "ACTIVE" | "RETIRING" | "ISOLATED" | "INSTALLING" | (string & {});
export declare const AssetState: S.String;
export type StatusList = AssetState[];
export declare const StatusList: S.$Array<S.String>;
export type AssetType = "COMPUTE" | "STORAGE" | "POWERSHELF" | "SWITCH" | "NETWORKING" | (string & {});
export declare const AssetType: S.String;
export type AssetTypeList = AssetType[];
export declare const AssetTypeList: S.$Array<S.String>;
export interface ListAssetsInput {
    OutpostIdentifier: string;
    HostIdFilter?: string[];
    MaxResults?: number;
    NextToken?: string;
    StatusFilter?: AssetState[];
    AssetTypeFilter?: AssetType[];
}
export declare const ListAssetsInput: S.Schema<ListAssetsInput>;
export type ComputeAssetState = "ACTIVE" | "ISOLATED" | "RETIRING" | "INSTALLING" | (string & {});
export declare const ComputeAssetState: S.String;
export type InstanceFamilies = string[];
export declare const InstanceFamilies: S.$Array<S.String>;
export interface AssetInstanceTypeCapacity {
    InstanceType: string;
    Count: number;
}
export declare const AssetInstanceTypeCapacity: S.Schema<AssetInstanceTypeCapacity>;
export type AssetInstanceCapacityList = AssetInstanceTypeCapacity[];
export declare const AssetInstanceCapacityList: S.$Array<S.Schema<AssetInstanceTypeCapacity>>;
export interface ComputeAttributes {
    HostId?: string;
    State?: ComputeAssetState;
    InstanceFamilies?: string[];
    InstanceTypeCapacities?: AssetInstanceTypeCapacity[];
    MaxVcpus?: number;
}
export declare const ComputeAttributes: S.Schema<ComputeAttributes>;
export interface AssetLocation {
    RackElevation?: number;
}
export declare const AssetLocation: S.Schema<AssetLocation>;
export interface AssetInfo {
    AssetId?: string;
    RackId?: string;
    AssetType?: AssetType;
    ComputeAttributes?: ComputeAttributes;
    AssetLocation?: AssetLocation;
}
export declare const AssetInfo: S.Schema<AssetInfo>;
export type AssetListDefinition = AssetInfo[];
export declare const AssetListDefinition: S.$Array<S.Schema<AssetInfo>>;
export interface ListAssetsOutput {
    Assets?: AssetInfo[];
    NextToken?: string;
}
export declare const ListAssetsOutput: S.Schema<ListAssetsOutput>;
export interface ListBlockingInstancesForCapacityTaskInput {
    OutpostIdentifier: string;
    CapacityTaskId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListBlockingInstancesForCapacityTaskInput: S.Schema<ListBlockingInstancesForCapacityTaskInput>;
export interface BlockingInstance {
    InstanceId?: string;
    AccountId?: string;
    AwsServiceName?: AWSServiceName;
}
export declare const BlockingInstance: S.Schema<BlockingInstance>;
export type BlockingInstancesList = BlockingInstance[];
export declare const BlockingInstancesList: S.$Array<S.Schema<BlockingInstance>>;
export interface ListBlockingInstancesForCapacityTaskOutput {
    BlockingInstances?: BlockingInstance[];
    NextToken?: string;
}
export declare const ListBlockingInstancesForCapacityTaskOutput: S.Schema<ListBlockingInstancesForCapacityTaskOutput>;
export type CapacityTaskStatusList = CapacityTaskStatus[];
export declare const CapacityTaskStatusList: S.$Array<S.String>;
export interface ListCapacityTasksInput {
    OutpostIdentifierFilter?: string;
    MaxResults?: number;
    NextToken?: string;
    CapacityTaskStatusFilter?: CapacityTaskStatus[];
}
export declare const ListCapacityTasksInput: S.Schema<ListCapacityTasksInput>;
export interface CapacityTaskSummary {
    CapacityTaskId?: string;
    OutpostId?: string;
    OrderId?: string;
    AssetId?: string;
    CapacityTaskStatus?: CapacityTaskStatus;
    CreationDate?: Date;
    CompletionDate?: Date;
    LastModifiedDate?: Date;
}
export declare const CapacityTaskSummary: S.Schema<CapacityTaskSummary>;
export type CapacityTaskList = CapacityTaskSummary[];
export declare const CapacityTaskList: S.$Array<S.Schema<CapacityTaskSummary>>;
export interface ListCapacityTasksOutput {
    CapacityTasks?: CapacityTaskSummary[];
    NextToken?: string;
}
export declare const ListCapacityTasksOutput: S.Schema<ListCapacityTasksOutput>;
export type CatalogItemClass = "RACK" | "SERVER" | (string & {});
export declare const CatalogItemClass: S.String;
export type CatalogItemClassList = CatalogItemClass[];
export declare const CatalogItemClassList: S.$Array<S.String>;
export type EC2FamilyList = string[];
export declare const EC2FamilyList: S.$Array<S.String>;
export interface ListCatalogItemsInput {
    NextToken?: string;
    MaxResults?: number;
    ItemClassFilter?: CatalogItemClass[];
    SupportedStorageFilter?: SupportedStorageEnum[];
    EC2FamilyFilter?: string[];
}
export declare const ListCatalogItemsInput: S.Schema<ListCatalogItemsInput>;
export type CatalogItemListDefinition = CatalogItem[];
export declare const CatalogItemListDefinition: S.$Array<S.Schema<CatalogItem>>;
export interface ListCatalogItemsOutput {
    CatalogItems?: CatalogItem[];
    NextToken?: string;
}
export declare const ListCatalogItemsOutput: S.Schema<ListCatalogItemsOutput>;
export interface ListOrdersInput {
    OutpostIdentifierFilter?: string;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListOrdersInput: S.Schema<ListOrdersInput>;
export type LineItemStatusCounts = {
    [key in LineItemStatus]?: number;
};
export declare const LineItemStatusCounts: S.$Record<S.String, S.optional<S.Number>>;
export interface OrderSummary {
    OutpostId?: string;
    OrderId?: string;
    OrderType?: OrderType;
    Status?: OrderStatus;
    LineItemCountsByStatus?: {
        [key: string]: number | undefined;
    };
    OrderSubmissionDate?: Date;
    OrderFulfilledDate?: Date;
}
export declare const OrderSummary: S.Schema<OrderSummary>;
export type OrderSummaryListDefinition = OrderSummary[];
export declare const OrderSummaryListDefinition: S.$Array<S.Schema<OrderSummary>>;
export interface ListOrdersOutput {
    Orders?: OrderSummary[];
    NextToken?: string;
}
export declare const ListOrdersOutput: S.Schema<ListOrdersOutput>;
export type LifeCycleStatusList = string[];
export declare const LifeCycleStatusList: S.$Array<S.String>;
export type AvailabilityZoneList = string[];
export declare const AvailabilityZoneList: S.$Array<S.String>;
export type AvailabilityZoneIdList = string[];
export declare const AvailabilityZoneIdList: S.$Array<S.String>;
export interface ListOutpostsInput {
    NextToken?: string;
    MaxResults?: number;
    LifeCycleStatusFilter?: string[];
    AvailabilityZoneFilter?: string[];
    AvailabilityZoneIdFilter?: string[];
}
export declare const ListOutpostsInput: S.Schema<ListOutpostsInput>;
export type OutpostListDefinition = Outpost[];
export declare const OutpostListDefinition: S.$Array<S.Schema<Outpost>>;
export interface ListOutpostsOutput {
    Outposts?: Outpost[];
    NextToken?: string;
}
export declare const ListOutpostsOutput: S.Schema<ListOutpostsOutput>;
export type CountryCodeList = string[];
export declare const CountryCodeList: S.$Array<S.String>;
export type StateOrRegionList = string[];
export declare const StateOrRegionList: S.$Array<S.String>;
export type CityList = string[];
export declare const CityList: S.$Array<S.String>;
export interface ListSitesInput {
    NextToken?: string;
    MaxResults?: number;
    OperatingAddressCountryCodeFilter?: string[];
    OperatingAddressStateOrRegionFilter?: string[];
    OperatingAddressCityFilter?: string[];
}
export declare const ListSitesInput: S.Schema<ListSitesInput>;
export type SiteListDefinition = Site[];
export declare const SiteListDefinition: S.$Array<S.Schema<Site>>;
export interface ListSitesOutput {
    Sites?: Site[];
    NextToken?: string;
}
export declare const ListSitesOutput: S.Schema<ListSitesOutput>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface StartCapacityTaskInput {
    OutpostIdentifier: string;
    OrderId?: string;
    AssetId?: string;
    InstancePools: InstanceTypeCapacity[];
    InstancesToExclude?: InstancesToExclude;
    DryRun?: boolean;
    TaskActionOnBlockingInstances?: TaskActionOnBlockingInstances;
}
export declare const StartCapacityTaskInput: S.Schema<StartCapacityTaskInput>;
export interface StartCapacityTaskOutput {
    CapacityTaskId?: string;
    OutpostId?: string;
    OrderId?: string;
    AssetId?: string;
    RequestedInstancePools?: InstanceTypeCapacity[];
    InstancesToExclude?: InstancesToExclude;
    DryRun?: boolean;
    CapacityTaskStatus?: CapacityTaskStatus;
    Failed?: CapacityTaskFailure;
    CreationDate?: Date;
    CompletionDate?: Date;
    LastModifiedDate?: Date;
    TaskActionOnBlockingInstances?: TaskActionOnBlockingInstances;
}
export declare const StartCapacityTaskOutput: S.Schema<StartCapacityTaskOutput>;
export interface StartConnectionRequest {
    DeviceSerialNumber?: string;
    AssetId: string;
    ClientPublicKey: string;
    NetworkInterfaceDeviceIndex: number;
}
export declare const StartConnectionRequest: S.Schema<StartConnectionRequest>;
export interface StartConnectionResponse {
    ConnectionId?: string;
    UnderlayIpAddress?: string;
}
export declare const StartConnectionResponse: S.Schema<StartConnectionResponse>;
export interface StartOutpostDecommissionInput {
    OutpostIdentifier: string;
    ValidateOnly?: boolean;
}
export declare const StartOutpostDecommissionInput: S.Schema<StartOutpostDecommissionInput>;
export type DecommissionRequestStatus = "SKIPPED" | "BLOCKED" | "REQUESTED" | (string & {});
export declare const DecommissionRequestStatus: S.String;
export type BlockingResourceType = "EC2_INSTANCE" | "OUTPOST_RAM_SHARE" | "LGW_ROUTING_DOMAIN" | "LGW_ROUTE_TABLE" | "LGW_VIRTUAL_INTERFACE_GROUP" | "OUTPOST_ORDER_CANCELLABLE" | "OUTPOST_ORDER_INTERVENTION_REQUIRED" | (string & {});
export declare const BlockingResourceType: S.String;
export type BlockingResourceTypeList = BlockingResourceType[];
export declare const BlockingResourceTypeList: S.$Array<S.String>;
export interface StartOutpostDecommissionOutput {
    Status?: DecommissionRequestStatus;
    BlockingResourceTypes?: BlockingResourceType[];
}
export declare const StartOutpostDecommissionOutput: S.Schema<StartOutpostDecommissionOutput>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateOutpostInput {
    OutpostId: string;
    Name?: string;
    Description?: string;
    SupportedHardwareType?: SupportedHardwareType;
}
export declare const UpdateOutpostInput: S.Schema<UpdateOutpostInput>;
export interface UpdateOutpostOutput {
    Outpost?: Outpost;
}
export declare const UpdateOutpostOutput: S.Schema<UpdateOutpostOutput>;
export interface UpdateSiteInput {
    SiteId: string;
    Name?: string;
    Description?: string;
    Notes?: string;
}
export declare const UpdateSiteInput: S.Schema<UpdateSiteInput>;
export interface UpdateSiteOutput {
    Site?: Site;
}
export declare const UpdateSiteOutput: S.Schema<UpdateSiteOutput>;
export interface UpdateSiteAddressInput {
    SiteId: string;
    AddressType: AddressType;
    Address: Address;
}
export declare const UpdateSiteAddressInput: S.Schema<UpdateSiteAddressInput>;
export interface UpdateSiteAddressOutput {
    AddressType?: AddressType;
    Address?: Address;
}
export declare const UpdateSiteAddressOutput: S.Schema<UpdateSiteAddressOutput>;
export interface UpdateSiteRackPhysicalPropertiesInput {
    SiteId: string;
    PowerDrawKva?: PowerDrawKva;
    PowerPhase?: PowerPhase;
    PowerConnector?: PowerConnector;
    PowerFeedDrop?: PowerFeedDrop;
    UplinkGbps?: UplinkGbps;
    UplinkCount?: UplinkCount;
    FiberOpticCableType?: FiberOpticCableType;
    OpticalStandard?: OpticalStandard;
    MaximumSupportedWeightLbs?: MaximumSupportedWeightLbs;
}
export declare const UpdateSiteRackPhysicalPropertiesInput: S.Schema<UpdateSiteRackPhysicalPropertiesInput>;
export interface UpdateSiteRackPhysicalPropertiesOutput {
    Site?: Site;
}
export declare const UpdateSiteRackPhysicalPropertiesOutput: S.Schema<UpdateSiteRackPhysicalPropertiesOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.optional<S.String>;
    readonly ResourceId: S.optional<S.String>;
    readonly ResourceType: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NotFoundException extends NotFoundException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type CancelCapacityTaskError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Cancels the capacity task.
 */
export declare const cancelCapacityTask: API.OperationMethod<CancelCapacityTaskInput, CancelCapacityTaskOutput, CancelCapacityTaskError, Credentials | Region | HttpClient.HttpClient>;
export type CancelOrderError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Cancels the specified order for an Outpost.
 */
export declare const cancelOrder: API.OperationMethod<CancelOrderInput, CancelOrderOutput, CancelOrderError, Credentials | Region | HttpClient.HttpClient>;
export type CreateOrderError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates an order for an Outpost.
 */
export declare const createOrder: API.OperationMethod<CreateOrderInput, CreateOrderOutput, CreateOrderError, Credentials | Region | HttpClient.HttpClient>;
export type CreateOutpostError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates an Outpost.
 *
 * You can specify either an Availability one or an AZ ID.
 */
export declare const createOutpost: API.OperationMethod<CreateOutpostInput, CreateOutpostOutput, CreateOutpostError, Credentials | Region | HttpClient.HttpClient>;
export type CreateRenewalError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Creates a renewal contract for the specified Outpost.
 */
export declare const createRenewal: API.OperationMethod<CreateRenewalInput, CreateRenewalOutput, CreateRenewalError, Credentials | Region | HttpClient.HttpClient>;
export type CreateSiteError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates a site for an Outpost.
 */
export declare const createSite: API.OperationMethod<CreateSiteInput, CreateSiteOutput, CreateSiteError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteOutpostError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the specified Outpost.
 */
export declare const deleteOutpost: API.OperationMethod<DeleteOutpostInput, DeleteOutpostOutput, DeleteOutpostError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSiteError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Deletes the specified site.
 */
export declare const deleteSite: API.OperationMethod<DeleteSiteInput, DeleteSiteOutput, DeleteSiteError, Credentials | Region | HttpClient.HttpClient>;
export type GetCapacityTaskError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets details of the specified capacity task.
 */
export declare const getCapacityTask: API.OperationMethod<GetCapacityTaskInput, GetCapacityTaskOutput, GetCapacityTaskError, Credentials | Region | HttpClient.HttpClient>;
export type GetCatalogItemError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets information about the specified catalog item.
 */
export declare const getCatalogItem: API.OperationMethod<GetCatalogItemInput, GetCatalogItemOutput, GetCatalogItemError, Credentials | Region | HttpClient.HttpClient>;
export type GetConnectionError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Amazon Web Services uses this action to install Outpost servers.
 *
 * Gets information about the specified connection.
 *
 * Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For
 * more information, see
 * Amazon Web Services managed policies for Amazon Web Services Outposts and
 * Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the *Amazon Web Services Outposts User Guide*.
 */
export declare const getConnection: API.OperationMethod<GetConnectionRequest, GetConnectionResponse, GetConnectionError, Credentials | Region | HttpClient.HttpClient>;
export type GetOrderError = InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets information about the specified order.
 */
export declare const getOrder: API.OperationMethod<GetOrderInput, GetOrderOutput, GetOrderError, Credentials | Region | HttpClient.HttpClient>;
export type GetOutpostError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets information about the specified Outpost.
 */
export declare const getOutpost: API.OperationMethod<GetOutpostInput, GetOutpostOutput, GetOutpostError, Credentials | Region | HttpClient.HttpClient>;
export type GetOutpostBillingInformationError = AccessDeniedException | InternalServerException | NotFoundException | CommonErrors;
/**
 * Gets current and historical billing information about the specified Outpost.
 */
export declare const getOutpostBillingInformation: API.OperationMethod<GetOutpostBillingInformationInput, GetOutpostBillingInformationOutput, GetOutpostBillingInformationError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetOutpostBillingInformationInput) => stream.Stream<GetOutpostBillingInformationOutput, GetOutpostBillingInformationError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetOutpostBillingInformationInput) => stream.Stream<Subscription, GetOutpostBillingInformationError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetOutpostInstanceTypesError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets the instance types for the specified Outpost.
 */
export declare const getOutpostInstanceTypes: API.OperationMethod<GetOutpostInstanceTypesInput, GetOutpostInstanceTypesOutput, GetOutpostInstanceTypesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetOutpostInstanceTypesInput) => stream.Stream<GetOutpostInstanceTypesOutput, GetOutpostInstanceTypesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetOutpostInstanceTypesInput) => stream.Stream<InstanceTypeItem, GetOutpostInstanceTypesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetOutpostSupportedInstanceTypesError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets the instance types that an Outpost can support in `InstanceTypeCapacity`.
 * This will generally include instance types that are not currently configured and therefore
 * cannot be launched with the current Outpost capacity configuration.
 */
export declare const getOutpostSupportedInstanceTypes: API.OperationMethod<GetOutpostSupportedInstanceTypesInput, GetOutpostSupportedInstanceTypesOutput, GetOutpostSupportedInstanceTypesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetOutpostSupportedInstanceTypesInput) => stream.Stream<GetOutpostSupportedInstanceTypesOutput, GetOutpostSupportedInstanceTypesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetOutpostSupportedInstanceTypesInput) => stream.Stream<InstanceTypeItem, GetOutpostSupportedInstanceTypesError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetRenewalPricingError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets all available renewal pricing options for the specified Outpost.
 */
export declare const getRenewalPricing: API.OperationMethod<GetRenewalPricingInput, GetRenewalPricingOutput, GetRenewalPricingError, Credentials | Region | HttpClient.HttpClient>;
export type GetSiteError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets information about the specified Outpost site.
 */
export declare const getSite: API.OperationMethod<GetSiteInput, GetSiteOutput, GetSiteError, Credentials | Region | HttpClient.HttpClient>;
export type GetSiteAddressError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Gets the site address of the specified site.
 */
export declare const getSiteAddress: API.OperationMethod<GetSiteAddressInput, GetSiteAddressOutput, GetSiteAddressError, Credentials | Region | HttpClient.HttpClient>;
export type ListAssetInstancesError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * A list of Amazon EC2 instances, belonging to all accounts, running on the specified Outpost.
 * Does not include Amazon EBS or Amazon S3 instances.
 */
export declare const listAssetInstances: API.OperationMethod<ListAssetInstancesInput, ListAssetInstancesOutput, ListAssetInstancesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAssetInstancesInput) => stream.Stream<ListAssetInstancesOutput, ListAssetInstancesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAssetInstancesInput) => stream.Stream<AssetInstance, ListAssetInstancesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListAssetsError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Lists the hardware assets for the specified Outpost.
 *
 * Use filters to return specific results. If you specify multiple filters, the results include only the resources that match
 * all of the specified filters. For a filter where you can specify multiple values, the results include
 * items that match any of the values that you specify for the filter.
 */
export declare const listAssets: API.OperationMethod<ListAssetsInput, ListAssetsOutput, ListAssetsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAssetsInput) => stream.Stream<ListAssetsOutput, ListAssetsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAssetsInput) => stream.Stream<AssetInfo, ListAssetsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListBlockingInstancesForCapacityTaskError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * A list of Amazon EC2 instances running on the Outpost and belonging to the account that
 * initiated the capacity task. Use this list to specify the instances you cannot stop to free up
 * capacity to run the capacity task.
 */
export declare const listBlockingInstancesForCapacityTask: API.OperationMethod<ListBlockingInstancesForCapacityTaskInput, ListBlockingInstancesForCapacityTaskOutput, ListBlockingInstancesForCapacityTaskError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListBlockingInstancesForCapacityTaskInput) => stream.Stream<ListBlockingInstancesForCapacityTaskOutput, ListBlockingInstancesForCapacityTaskError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListBlockingInstancesForCapacityTaskInput) => stream.Stream<BlockingInstance, ListBlockingInstancesForCapacityTaskError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListCapacityTasksError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Lists the capacity tasks for your Amazon Web Services account.
 *
 * Use filters to return specific results. If you specify multiple filters, the results include only the resources that match
 * all of the specified filters. For a filter where you can specify multiple values, the results include
 * items that match any of the values that you specify for the filter.
 */
export declare const listCapacityTasks: API.OperationMethod<ListCapacityTasksInput, ListCapacityTasksOutput, ListCapacityTasksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCapacityTasksInput) => stream.Stream<ListCapacityTasksOutput, ListCapacityTasksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCapacityTasksInput) => stream.Stream<CapacityTaskSummary, ListCapacityTasksError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListCatalogItemsError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Lists the items in the catalog.
 *
 * Use filters to return specific results. If you specify multiple filters, the results include only the resources that match
 * all of the specified filters. For a filter where you can specify multiple values, the results include
 * items that match any of the values that you specify for the filter.
 */
export declare const listCatalogItems: API.OperationMethod<ListCatalogItemsInput, ListCatalogItemsOutput, ListCatalogItemsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListCatalogItemsInput) => stream.Stream<ListCatalogItemsOutput, ListCatalogItemsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListCatalogItemsInput) => stream.Stream<CatalogItem, ListCatalogItemsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListOrdersError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Lists the Outpost orders for your Amazon Web Services account.
 */
export declare const listOrders: API.OperationMethod<ListOrdersInput, ListOrdersOutput, ListOrdersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListOrdersInput) => stream.Stream<ListOrdersOutput, ListOrdersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListOrdersInput) => stream.Stream<OrderSummary, ListOrdersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListOutpostsError = AccessDeniedException | InternalServerException | ValidationException | CommonErrors;
/**
 * Lists the Outposts for your Amazon Web Services account.
 *
 * Use filters to return specific results. If you specify multiple filters, the results include only the resources that match
 * all of the specified filters. For a filter where you can specify multiple values, the results include
 * items that match any of the values that you specify for the filter.
 */
export declare const listOutposts: API.OperationMethod<ListOutpostsInput, ListOutpostsOutput, ListOutpostsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListOutpostsInput) => stream.Stream<ListOutpostsOutput, ListOutpostsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListOutpostsInput) => stream.Stream<Outpost, ListOutpostsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSitesError = AccessDeniedException | InternalServerException | ValidationException | CommonErrors;
/**
 * Lists the Outpost sites for your Amazon Web Services account. Use filters to return specific
 * results.
 *
 * Use filters to return specific results. If you specify multiple filters, the results include only the resources that match
 * all of the specified filters. For a filter where you can specify multiple values, the results include
 * items that match any of the values that you specify for the filter.
 */
export declare const listSites: API.OperationMethod<ListSitesInput, ListSitesOutput, ListSitesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSitesInput) => stream.Stream<ListSitesOutput, ListSitesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSitesInput) => stream.Stream<Site, ListSitesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Lists the tags for the specified resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type StartCapacityTaskError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Starts the specified capacity task. You can have one active capacity task for each order
 * and each Outpost.
 */
export declare const startCapacityTask: API.OperationMethod<StartCapacityTaskInput, StartCapacityTaskOutput, StartCapacityTaskError, Credentials | Region | HttpClient.HttpClient>;
export type StartConnectionError = AccessDeniedException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Amazon Web Services uses this action to install Outpost servers.
 *
 * Starts the connection required for Outpost server installation.
 *
 * Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For
 * more information, see
 * Amazon Web Services managed policies for Amazon Web Services Outposts and
 * Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the *Amazon Web Services Outposts User Guide*.
 */
export declare const startConnection: API.OperationMethod<StartConnectionRequest, StartConnectionResponse, StartConnectionError, Credentials | Region | HttpClient.HttpClient>;
export type StartOutpostDecommissionError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Starts the decommission process to return the Outposts racks or servers.
 */
export declare const startOutpostDecommission: API.OperationMethod<StartOutpostDecommissionInput, StartOutpostDecommissionOutput, StartOutpostDecommissionError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Adds tags to the specified resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Removes tags from the specified resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateOutpostError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Updates an Outpost.
 */
export declare const updateOutpost: API.OperationMethod<UpdateOutpostInput, UpdateOutpostOutput, UpdateOutpostError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSiteError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Updates the specified site.
 */
export declare const updateSite: API.OperationMethod<UpdateSiteInput, UpdateSiteOutput, UpdateSiteError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSiteAddressError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Updates the address of the specified site.
 *
 * You can't update a site address if there is an order in progress. You must wait for the
 * order to complete or cancel the order.
 *
 * You can update the operating address before you place an order at the site, or after all
 * Outposts that belong to the site have been deactivated.
 */
export declare const updateSiteAddress: API.OperationMethod<UpdateSiteAddressInput, UpdateSiteAddressOutput, UpdateSiteAddressError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSiteRackPhysicalPropertiesError = AccessDeniedException | ConflictException | InternalServerException | NotFoundException | ValidationException | CommonErrors;
/**
 * Update the physical and logistical details for a rack at a site. For more information
 * about hardware requirements for racks, see Network
 * readiness checklist in the Amazon Web Services Outposts User Guide.
 *
 * To update a rack at a site with an order of `IN_PROGRESS`, you must wait for
 * the order to complete or cancel the order.
 */
export declare const updateSiteRackPhysicalProperties: API.OperationMethod<UpdateSiteRackPhysicalPropertiesInput, UpdateSiteRackPhysicalPropertiesOutput, UpdateSiteRackPhysicalPropertiesError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=outposts.d.ts.map