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 OutpostId = string;
export type SubnetId = string;
export type SecurityGroupId = string;
export type CustomerOwnedIpv4Pool = string;
export type EndpointArn = string;
export type ErrorMessage = string;
export type EndpointId = string;
export type NextToken = string;
export type MaxResults = number;
export type CidrBlock = string;
export type CreationTime = Date;
export type NetworkInterfaceId = string;
export type VpcId = string;
export type ErrorCode = string;
export type Message = string;
export type OutpostArn = string;
export type S3OutpostArn = string;
export type AwsAccountId = string;
export type CapacityInBytes = number;
export type EndpointAccessType = "Private" | "CustomerOwnedIp" | (string & {});
export declare const EndpointAccessType: S.String;
export interface CreateEndpointRequest {
    OutpostId: string;
    SubnetId: string;
    SecurityGroupId: string;
    AccessType?: EndpointAccessType;
    CustomerOwnedIpv4Pool?: string;
}
export declare const CreateEndpointRequest: S.Schema<CreateEndpointRequest>;
export interface CreateEndpointResult {
    EndpointArn?: string;
}
export declare const CreateEndpointResult: S.Schema<CreateEndpointResult>;
export interface DeleteEndpointRequest {
    EndpointId: string;
    OutpostId: string;
}
export declare const DeleteEndpointRequest: S.Schema<DeleteEndpointRequest>;
export interface DeleteEndpointResponse {
}
export declare const DeleteEndpointResponse: S.Schema<DeleteEndpointResponse>;
export interface ListEndpointsRequest {
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListEndpointsRequest: S.Schema<ListEndpointsRequest>;
export type EndpointStatus = "Pending" | "Available" | "Deleting" | "Create_Failed" | "Delete_Failed" | (string & {});
export declare const EndpointStatus: S.String;
export interface NetworkInterface {
    NetworkInterfaceId?: string;
}
export declare const NetworkInterface: S.Schema<NetworkInterface>;
export type NetworkInterfaces = NetworkInterface[];
export declare const NetworkInterfaces: S.$Array<S.Schema<NetworkInterface>>;
export interface FailedReason {
    ErrorCode?: string;
    Message?: string;
}
export declare const FailedReason: S.Schema<FailedReason>;
export interface Endpoint {
    EndpointArn?: string;
    OutpostsId?: string;
    CidrBlock?: string;
    Status?: EndpointStatus;
    CreationTime?: Date;
    NetworkInterfaces?: NetworkInterface[];
    VpcId?: string;
    SubnetId?: string;
    SecurityGroupId?: string;
    AccessType?: EndpointAccessType;
    CustomerOwnedIpv4Pool?: string;
    FailedReason?: FailedReason;
}
export declare const Endpoint: S.Schema<Endpoint>;
export type Endpoints = Endpoint[];
export declare const Endpoints: S.$Array<S.Schema<Endpoint>>;
export interface ListEndpointsResult {
    Endpoints?: Endpoint[];
    NextToken?: string;
}
export declare const ListEndpointsResult: S.Schema<ListEndpointsResult>;
export interface ListOutpostsWithS3Request {
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListOutpostsWithS3Request: S.Schema<ListOutpostsWithS3Request>;
export interface Outpost {
    OutpostArn?: string;
    S3OutpostArn?: string;
    OutpostId?: string;
    OwnerId?: string;
    CapacityInBytes?: number;
}
export declare const Outpost: S.Schema<Outpost>;
export type Outposts = Outpost[];
export declare const Outposts: S.$Array<S.Schema<Outpost>>;
export interface ListOutpostsWithS3Result {
    Outposts?: Outpost[];
    NextToken?: string;
}
export declare const ListOutpostsWithS3Result: S.Schema<ListOutpostsWithS3Result>;
export interface ListSharedEndpointsRequest {
    NextToken?: string;
    MaxResults?: number;
    OutpostId: string;
}
export declare const ListSharedEndpointsRequest: S.Schema<ListSharedEndpointsRequest>;
export interface ListSharedEndpointsResult {
    Endpoints?: Endpoint[];
    NextToken?: string;
}
export declare const ListSharedEndpointsResult: S.Schema<ListSharedEndpointsResult>;
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>;
}>, 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 OutpostOfflineException_base: S.Class<OutpostOfflineException, S.TaggedStruct<"OutpostOfflineException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class OutpostOfflineException extends OutpostOfflineException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_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 {
}
export type CreateEndpointError = AccessDeniedException | ConflictException | InternalServerException | OutpostOfflineException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates an endpoint and associates it with the specified Outpost.
 *
 * It can take up to 5 minutes for this action to finish.
 *
 * Related actions include:
 *
 * - DeleteEndpoint
 *
 * - ListEndpoints
 */
export declare const createEndpoint: API.OperationMethod<CreateEndpointRequest, CreateEndpointResult, CreateEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteEndpointError = AccessDeniedException | InternalServerException | OutpostOfflineException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes an endpoint.
 *
 * It can take up to 5 minutes for this action to finish.
 *
 * Related actions include:
 *
 * - CreateEndpoint
 *
 * - ListEndpoints
 */
export declare const deleteEndpoint: API.OperationMethod<DeleteEndpointRequest, DeleteEndpointResponse, DeleteEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type ListEndpointsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists endpoints associated with the specified Outpost.
 *
 * Related actions include:
 *
 * - CreateEndpoint
 *
 * - DeleteEndpoint
 */
export declare const listEndpoints: API.OperationMethod<ListEndpointsRequest, ListEndpointsResult, ListEndpointsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEndpointsRequest) => stream.Stream<ListEndpointsResult, ListEndpointsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEndpointsRequest) => stream.Stream<Endpoint, ListEndpointsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListOutpostsWithS3Error = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the Outposts with S3 on Outposts capacity for your Amazon Web Services account.
 * Includes S3 on Outposts that you have access to as the Outposts owner, or as a shared user
 * from Resource Access Manager (RAM).
 */
export declare const listOutpostsWithS3: API.OperationMethod<ListOutpostsWithS3Request, ListOutpostsWithS3Result, ListOutpostsWithS3Error, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListOutpostsWithS3Request) => stream.Stream<ListOutpostsWithS3Result, ListOutpostsWithS3Error, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListOutpostsWithS3Request) => stream.Stream<Outpost, ListOutpostsWithS3Error, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSharedEndpointsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all endpoints associated with an Outpost that has been shared by Amazon Web Services Resource Access Manager (RAM).
 *
 * Related actions include:
 *
 * - CreateEndpoint
 *
 * - DeleteEndpoint
 */
export declare const listSharedEndpoints: API.OperationMethod<ListSharedEndpointsRequest, ListSharedEndpointsResult, ListSharedEndpointsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSharedEndpointsRequest) => stream.Stream<ListSharedEndpointsResult, ListSharedEndpointsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSharedEndpointsRequest) => stream.Stream<Endpoint, ListSharedEndpointsError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=s3outposts.d.ts.map