import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
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 Arn = string;
export type TagKey = string;
export type TagValue = string;
export type ClusterName = string;
export type SubnetId = string;
export type SecurityGroupId = string;
export type SBClientToken = string;
export type ClusterIdentifier = string;
export type BootstrapId = string;
export type SharedSecret = string | redacted.Redacted<string>;
export type MaxResults = number;
export type ComputeNodeGroupName = string;
export type AmiId = string;
export type InstanceProfileArn = string;
export type ComputeNodeGroupIdentifier = string;
export type QueueName = string;
export type QueueIdentifier = string;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type ResponseTagMap = {
    [key: string]: string | undefined;
};
export declare const ResponseTagMap: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export type RequestTagMap = {
    [key: string]: string | undefined;
};
export declare const RequestTagMap: S.$Record<S.String, S.optional<S.String>>;
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 TagKeys = string[];
export declare const TagKeys: 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 type SchedulerType = "SLURM" | (string & {});
export declare const SchedulerType: S.String;
export interface SchedulerRequest {
    type: SchedulerType;
    version: string;
}
export declare const SchedulerRequest: S.Schema<SchedulerRequest>;
export type Size = "SMALL" | "MEDIUM" | "LARGE" | (string & {});
export declare const Size: S.String;
export type SubnetIdList = string[];
export declare const SubnetIdList: S.$Array<S.String>;
export type SecurityGroupIdList = string[];
export declare const SecurityGroupIdList: S.$Array<S.String>;
export type NetworkType = "IPV4" | "IPV6" | (string & {});
export declare const NetworkType: S.String;
export interface NetworkingRequest {
    subnetIds?: string[];
    securityGroupIds?: string[];
    networkType?: NetworkType;
}
export declare const NetworkingRequest: S.Schema<NetworkingRequest>;
export interface SlurmCustomSetting {
    parameterName: string;
    parameterValue: string;
}
export declare const SlurmCustomSetting: S.Schema<SlurmCustomSetting>;
export type SlurmCustomSettings = SlurmCustomSetting[];
export declare const SlurmCustomSettings: S.$Array<S.Schema<SlurmCustomSetting>>;
export interface SlurmdbdCustomSetting {
    parameterName: string;
    parameterValue: string;
}
export declare const SlurmdbdCustomSetting: S.Schema<SlurmdbdCustomSetting>;
export type SlurmdbdCustomSettings = SlurmdbdCustomSetting[];
export declare const SlurmdbdCustomSettings: S.$Array<S.Schema<SlurmdbdCustomSetting>>;
export interface CgroupCustomSetting {
    parameterName: string;
    parameterValue: string;
}
export declare const CgroupCustomSetting: S.Schema<CgroupCustomSetting>;
export type CgroupCustomSettings = CgroupCustomSetting[];
export declare const CgroupCustomSettings: S.$Array<S.Schema<CgroupCustomSetting>>;
export type AccountingMode = "STANDARD" | "NONE" | (string & {});
export declare const AccountingMode: S.String;
export interface AccountingRequest {
    defaultPurgeTimeInDays?: number;
    mode: AccountingMode;
}
export declare const AccountingRequest: S.Schema<AccountingRequest>;
export type SlurmRestMode = "STANDARD" | "NONE" | (string & {});
export declare const SlurmRestMode: S.String;
export interface SlurmRestRequest {
    mode: SlurmRestMode;
}
export declare const SlurmRestRequest: S.Schema<SlurmRestRequest>;
export interface ClusterSlurmConfigurationRequest {
    scaleDownIdleTimeInSeconds?: number;
    slurmCustomSettings?: SlurmCustomSetting[];
    slurmdbdCustomSettings?: SlurmdbdCustomSetting[];
    cgroupCustomSettings?: CgroupCustomSetting[];
    accounting?: AccountingRequest;
    slurmRest?: SlurmRestRequest;
}
export declare const ClusterSlurmConfigurationRequest: S.Schema<ClusterSlurmConfigurationRequest>;
export interface CreateClusterRequest {
    clusterName: string;
    scheduler: SchedulerRequest;
    size: Size;
    networking: NetworkingRequest;
    slurmConfiguration?: ClusterSlurmConfigurationRequest;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateClusterRequest: S.Schema<CreateClusterRequest>;
export type ClusterStatus = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "CREATE_FAILED" | "DELETE_FAILED" | "UPDATE_FAILED" | "SUSPENDING" | "SUSPENDED" | "RESUMING" | (string & {});
export declare const ClusterStatus: S.String;
export interface Scheduler {
    type: SchedulerType;
    version: string;
}
export declare const Scheduler: S.Schema<Scheduler>;
export interface SlurmAuthKey {
    secretArn: string;
    secretVersion: string;
}
export declare const SlurmAuthKey: S.Schema<SlurmAuthKey>;
export interface JwtKey {
    secretArn: string;
    secretVersion: string;
}
export declare const JwtKey: S.Schema<JwtKey>;
export interface JwtAuth {
    jwtKey?: JwtKey;
}
export declare const JwtAuth: S.Schema<JwtAuth>;
export interface Accounting {
    defaultPurgeTimeInDays?: number;
    mode: AccountingMode;
}
export declare const Accounting: S.Schema<Accounting>;
export interface SlurmRest {
    mode: SlurmRestMode;
}
export declare const SlurmRest: S.Schema<SlurmRest>;
export interface ClusterSlurmConfiguration {
    scaleDownIdleTimeInSeconds?: number;
    slurmCustomSettings?: SlurmCustomSetting[];
    slurmdbdCustomSettings?: SlurmdbdCustomSetting[];
    cgroupCustomSettings?: CgroupCustomSetting[];
    authKey?: SlurmAuthKey;
    jwtAuth?: JwtAuth;
    accounting?: Accounting;
    slurmRest?: SlurmRest;
}
export declare const ClusterSlurmConfiguration: S.Schema<ClusterSlurmConfiguration>;
export interface Networking {
    subnetIds?: string[];
    securityGroupIds?: string[];
    networkType?: NetworkType;
}
export declare const Networking: S.Schema<Networking>;
export type EndpointType = "SLURMCTLD" | "SLURMDBD" | "SLURMRESTD" | (string & {});
export declare const EndpointType: S.String;
export interface Endpoint {
    type: EndpointType;
    privateIpAddress: string;
    publicIpAddress?: string;
    ipv6Address?: string;
    port: string;
}
export declare const Endpoint: S.Schema<Endpoint>;
export type Endpoints = Endpoint[];
export declare const Endpoints: S.$Array<S.Schema<Endpoint>>;
export interface ErrorInfo {
    code?: string;
    message?: string;
}
export declare const ErrorInfo: S.Schema<ErrorInfo>;
export type ErrorInfoList = ErrorInfo[];
export declare const ErrorInfoList: S.$Array<S.Schema<ErrorInfo>>;
export interface Cluster {
    name: string;
    id: string;
    arn: string;
    status: ClusterStatus;
    createdAt: Date;
    modifiedAt: Date;
    scheduler: Scheduler;
    size: Size;
    slurmConfiguration?: ClusterSlurmConfiguration;
    networking: Networking;
    endpoints?: Endpoint[];
    errorInfo?: ErrorInfo[];
}
export declare const Cluster: S.Schema<Cluster>;
export interface CreateClusterResponse {
    cluster?: Cluster;
}
export declare const CreateClusterResponse: S.Schema<CreateClusterResponse>;
export type ValidationExceptionReason = "unknownOperation" | "cannotParse" | "fieldValidationFailed" | "other" | (string & {});
export declare const ValidationExceptionReason: S.String;
export interface ValidationExceptionField {
    name: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export interface UpdateAccountingRequest {
    defaultPurgeTimeInDays?: number;
    mode?: AccountingMode;
}
export declare const UpdateAccountingRequest: S.Schema<UpdateAccountingRequest>;
export interface UpdateSlurmRestRequest {
    mode?: SlurmRestMode;
}
export declare const UpdateSlurmRestRequest: S.Schema<UpdateSlurmRestRequest>;
export interface UpdateClusterSlurmConfigurationRequest {
    scaleDownIdleTimeInSeconds?: number;
    slurmCustomSettings?: SlurmCustomSetting[];
    slurmdbdCustomSettings?: SlurmdbdCustomSetting[];
    cgroupCustomSettings?: CgroupCustomSetting[];
    accounting?: UpdateAccountingRequest;
    slurmRest?: UpdateSlurmRestRequest;
}
export declare const UpdateClusterSlurmConfigurationRequest: S.Schema<UpdateClusterSlurmConfigurationRequest>;
export interface UpdateClusterRequest {
    clusterIdentifier: string;
    clientToken?: string;
    slurmConfiguration?: UpdateClusterSlurmConfigurationRequest;
}
export declare const UpdateClusterRequest: S.Schema<UpdateClusterRequest>;
export interface UpdateClusterResponse {
    cluster?: Cluster;
}
export declare const UpdateClusterResponse: S.Schema<UpdateClusterResponse>;
export interface DeleteClusterRequest {
    clusterIdentifier: string;
    clientToken?: string;
}
export declare const DeleteClusterRequest: S.Schema<DeleteClusterRequest>;
export interface DeleteClusterResponse {
}
export declare const DeleteClusterResponse: S.Schema<DeleteClusterResponse>;
export interface GetClusterRequest {
    clusterIdentifier: string;
}
export declare const GetClusterRequest: S.Schema<GetClusterRequest>;
export interface GetClusterResponse {
    cluster?: Cluster;
}
export declare const GetClusterResponse: S.Schema<GetClusterResponse>;
export interface RegisterComputeNodeGroupInstanceRequest {
    clusterIdentifier: string;
    bootstrapId: string;
}
export declare const RegisterComputeNodeGroupInstanceRequest: S.Schema<RegisterComputeNodeGroupInstanceRequest>;
export interface RegisterComputeNodeGroupInstanceResponse {
    nodeID: string;
    sharedSecret: string | redacted.Redacted<string>;
    endpoints: Endpoint[];
}
export declare const RegisterComputeNodeGroupInstanceResponse: S.Schema<RegisterComputeNodeGroupInstanceResponse>;
export interface ListClustersRequest {
    nextToken?: string;
    maxResults?: number;
}
export declare const ListClustersRequest: S.Schema<ListClustersRequest>;
export interface ClusterSummary {
    name: string;
    id: string;
    arn: string;
    createdAt: Date;
    modifiedAt: Date;
    status: ClusterStatus;
}
export declare const ClusterSummary: S.Schema<ClusterSummary>;
export type ClusterList = ClusterSummary[];
export declare const ClusterList: S.$Array<S.Schema<ClusterSummary>>;
export interface ListClustersResponse {
    clusters: ClusterSummary[];
    nextToken?: string;
}
export declare const ListClustersResponse: S.Schema<ListClustersResponse>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export type PurchaseOption = "ONDEMAND" | "SPOT" | "CAPACITY_BLOCK" | (string & {});
export declare const PurchaseOption: S.String;
export interface CustomLaunchTemplate {
    id: string;
    version: string;
}
export declare const CustomLaunchTemplate: S.Schema<CustomLaunchTemplate>;
export interface ScalingConfigurationRequest {
    minInstanceCount: number;
    maxInstanceCount: number;
}
export declare const ScalingConfigurationRequest: S.Schema<ScalingConfigurationRequest>;
export interface InstanceConfig {
    instanceType?: string;
}
export declare const InstanceConfig: S.Schema<InstanceConfig>;
export type InstanceList = InstanceConfig[];
export declare const InstanceList: S.$Array<S.Schema<InstanceConfig>>;
export type SpotAllocationStrategy = "lowest-price" | "capacity-optimized" | "price-capacity-optimized" | (string & {});
export declare const SpotAllocationStrategy: S.String;
export interface SpotOptions {
    allocationStrategy?: SpotAllocationStrategy;
}
export declare const SpotOptions: S.Schema<SpotOptions>;
export interface ComputeNodeGroupSlurmConfigurationRequest {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const ComputeNodeGroupSlurmConfigurationRequest: S.Schema<ComputeNodeGroupSlurmConfigurationRequest>;
export interface CreateComputeNodeGroupRequest {
    clusterIdentifier: string;
    computeNodeGroupName: string;
    amiId?: string;
    subnetIds: string[];
    purchaseOption?: PurchaseOption;
    customLaunchTemplate: CustomLaunchTemplate;
    iamInstanceProfileArn: string;
    scalingConfiguration: ScalingConfigurationRequest;
    instanceConfigs: InstanceConfig[];
    spotOptions?: SpotOptions;
    slurmConfiguration?: ComputeNodeGroupSlurmConfigurationRequest;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateComputeNodeGroupRequest: S.Schema<CreateComputeNodeGroupRequest>;
export type ComputeNodeGroupStatus = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "CREATE_FAILED" | "DELETE_FAILED" | "UPDATE_FAILED" | "DELETED" | "SUSPENDING" | "SUSPENDED" | "RESUMING" | (string & {});
export declare const ComputeNodeGroupStatus: S.String;
export interface ScalingConfiguration {
    minInstanceCount: number;
    maxInstanceCount: number;
}
export declare const ScalingConfiguration: S.Schema<ScalingConfiguration>;
export interface ComputeNodeGroupSlurmConfiguration {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const ComputeNodeGroupSlurmConfiguration: S.Schema<ComputeNodeGroupSlurmConfiguration>;
export interface ComputeNodeGroup {
    name: string;
    id: string;
    arn: string;
    clusterId: string;
    createdAt: Date;
    modifiedAt: Date;
    status: ComputeNodeGroupStatus;
    amiId?: string;
    subnetIds: string[];
    purchaseOption?: PurchaseOption;
    customLaunchTemplate: CustomLaunchTemplate;
    iamInstanceProfileArn: string;
    scalingConfiguration: ScalingConfiguration;
    instanceConfigs: InstanceConfig[];
    spotOptions?: SpotOptions;
    slurmConfiguration?: ComputeNodeGroupSlurmConfiguration;
    errorInfo?: ErrorInfo[];
}
export declare const ComputeNodeGroup: S.Schema<ComputeNodeGroup>;
export interface CreateComputeNodeGroupResponse {
    computeNodeGroup?: ComputeNodeGroup;
}
export declare const CreateComputeNodeGroupResponse: S.Schema<CreateComputeNodeGroupResponse>;
export interface UpdateComputeNodeGroupSlurmConfigurationRequest {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const UpdateComputeNodeGroupSlurmConfigurationRequest: S.Schema<UpdateComputeNodeGroupSlurmConfigurationRequest>;
export interface UpdateComputeNodeGroupRequest {
    clusterIdentifier: string;
    computeNodeGroupIdentifier: string;
    amiId?: string;
    subnetIds?: string[];
    customLaunchTemplate?: CustomLaunchTemplate;
    purchaseOption?: PurchaseOption;
    spotOptions?: SpotOptions;
    scalingConfiguration?: ScalingConfigurationRequest;
    iamInstanceProfileArn?: string;
    slurmConfiguration?: UpdateComputeNodeGroupSlurmConfigurationRequest;
    clientToken?: string;
}
export declare const UpdateComputeNodeGroupRequest: S.Schema<UpdateComputeNodeGroupRequest>;
export interface UpdateComputeNodeGroupResponse {
    computeNodeGroup?: ComputeNodeGroup;
}
export declare const UpdateComputeNodeGroupResponse: S.Schema<UpdateComputeNodeGroupResponse>;
export interface DeleteComputeNodeGroupRequest {
    clusterIdentifier: string;
    computeNodeGroupIdentifier: string;
    clientToken?: string;
}
export declare const DeleteComputeNodeGroupRequest: S.Schema<DeleteComputeNodeGroupRequest>;
export interface DeleteComputeNodeGroupResponse {
}
export declare const DeleteComputeNodeGroupResponse: S.Schema<DeleteComputeNodeGroupResponse>;
export interface GetComputeNodeGroupRequest {
    clusterIdentifier: string;
    computeNodeGroupIdentifier: string;
}
export declare const GetComputeNodeGroupRequest: S.Schema<GetComputeNodeGroupRequest>;
export interface GetComputeNodeGroupResponse {
    computeNodeGroup?: ComputeNodeGroup;
}
export declare const GetComputeNodeGroupResponse: S.Schema<GetComputeNodeGroupResponse>;
export interface ListComputeNodeGroupsRequest {
    clusterIdentifier: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListComputeNodeGroupsRequest: S.Schema<ListComputeNodeGroupsRequest>;
export interface ComputeNodeGroupSummary {
    name: string;
    id: string;
    arn: string;
    clusterId: string;
    createdAt: Date;
    modifiedAt: Date;
    status: ComputeNodeGroupStatus;
}
export declare const ComputeNodeGroupSummary: S.Schema<ComputeNodeGroupSummary>;
export type ComputeNodeGroupList = ComputeNodeGroupSummary[];
export declare const ComputeNodeGroupList: S.$Array<S.Schema<ComputeNodeGroupSummary>>;
export interface ListComputeNodeGroupsResponse {
    computeNodeGroups: ComputeNodeGroupSummary[];
    nextToken?: string;
}
export declare const ListComputeNodeGroupsResponse: S.Schema<ListComputeNodeGroupsResponse>;
export interface ComputeNodeGroupConfiguration {
    computeNodeGroupId?: string;
}
export declare const ComputeNodeGroupConfiguration: S.Schema<ComputeNodeGroupConfiguration>;
export type ComputeNodeGroupConfigurationList = ComputeNodeGroupConfiguration[];
export declare const ComputeNodeGroupConfigurationList: S.$Array<S.Schema<ComputeNodeGroupConfiguration>>;
export interface QueueSlurmConfigurationRequest {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const QueueSlurmConfigurationRequest: S.Schema<QueueSlurmConfigurationRequest>;
export interface CreateQueueRequest {
    clusterIdentifier: string;
    queueName: string;
    computeNodeGroupConfigurations?: ComputeNodeGroupConfiguration[];
    slurmConfiguration?: QueueSlurmConfigurationRequest;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateQueueRequest: S.Schema<CreateQueueRequest>;
export type QueueStatus = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | "CREATE_FAILED" | "DELETE_FAILED" | "UPDATE_FAILED" | "SUSPENDING" | "SUSPENDED" | "RESUMING" | (string & {});
export declare const QueueStatus: S.String;
export interface QueueSlurmConfiguration {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const QueueSlurmConfiguration: S.Schema<QueueSlurmConfiguration>;
export interface Queue {
    name: string;
    id: string;
    arn: string;
    clusterId: string;
    createdAt: Date;
    modifiedAt: Date;
    status: QueueStatus;
    computeNodeGroupConfigurations: ComputeNodeGroupConfiguration[];
    slurmConfiguration?: QueueSlurmConfiguration;
    errorInfo?: ErrorInfo[];
}
export declare const Queue: S.Schema<Queue>;
export interface CreateQueueResponse {
    queue?: Queue;
}
export declare const CreateQueueResponse: S.Schema<CreateQueueResponse>;
export interface UpdateQueueSlurmConfigurationRequest {
    slurmCustomSettings?: SlurmCustomSetting[];
}
export declare const UpdateQueueSlurmConfigurationRequest: S.Schema<UpdateQueueSlurmConfigurationRequest>;
export interface UpdateQueueRequest {
    clusterIdentifier: string;
    queueIdentifier: string;
    computeNodeGroupConfigurations?: ComputeNodeGroupConfiguration[];
    slurmConfiguration?: UpdateQueueSlurmConfigurationRequest;
    clientToken?: string;
}
export declare const UpdateQueueRequest: S.Schema<UpdateQueueRequest>;
export interface UpdateQueueResponse {
    queue?: Queue;
}
export declare const UpdateQueueResponse: S.Schema<UpdateQueueResponse>;
export interface DeleteQueueRequest {
    clusterIdentifier: string;
    queueIdentifier: string;
    clientToken?: string;
}
export declare const DeleteQueueRequest: S.Schema<DeleteQueueRequest>;
export interface DeleteQueueResponse {
}
export declare const DeleteQueueResponse: S.Schema<DeleteQueueResponse>;
export interface GetQueueRequest {
    clusterIdentifier: string;
    queueIdentifier: string;
}
export declare const GetQueueRequest: S.Schema<GetQueueRequest>;
export interface GetQueueResponse {
    queue?: Queue;
}
export declare const GetQueueResponse: S.Schema<GetQueueResponse>;
export interface ListQueuesRequest {
    clusterIdentifier: string;
    nextToken?: string;
    maxResults?: number;
}
export declare const ListQueuesRequest: S.Schema<ListQueuesRequest>;
export interface QueueSummary {
    name: string;
    id: string;
    arn: string;
    clusterId: string;
    createdAt: Date;
    modifiedAt: Date;
    status: QueueStatus;
}
export declare const QueueSummary: S.Schema<QueueSummary>;
export type QueueList = QueueSummary[];
export declare const QueueList: S.$Array<S.Schema<QueueSummary>>;
export interface ListQueuesResponse {
    queues: QueueSummary[];
    nextToken?: string;
}
export declare const ListQueuesResponse: S.Schema<ListQueuesResponse>;
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
    readonly resourceId: S.String;
    readonly resourceType: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
    readonly serviceCode: S.String;
    readonly resourceId: S.optional<S.String>;
    readonly resourceType: S.optional<S.String>;
    readonly quotaCode: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: 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.String;
    readonly resourceId: S.String;
    readonly resourceType: 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.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
    readonly retryAfterSeconds: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly reason: S.String;
    readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
export type ListTagsForResourceError = ResourceNotFoundException | CommonErrors;
/**
 * Returns a list of all tags on an PCS resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * Adds or edits tags on an PCS resource. Each tag consists of a tag key and a tag value. The tag key and tag value are case-sensitive strings. The tag value can be an empty (null) string. To add a tag, specify a new tag key and a tag value. To edit a tag, specify an existing tag key and a new tag value.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = ResourceNotFoundException | CommonErrors;
/**
 * Deletes tags from an PCS resource. To delete a tag, specify the tag key and the Amazon Resource Name (ARN) of the PCS resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateClusterError = AccessDeniedException | ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a cluster in your account. PCS creates the cluster controller in a service-owned account. The cluster controller communicates with the cluster resources in your account. The subnets and security groups for the cluster must already exist before you use this API action.
 *
 * It takes time for PCS to create the cluster. The cluster is in a `Creating` state until it is ready to use. There can only be 1 cluster in a `Creating` state per Amazon Web Services Region per Amazon Web Services account. `CreateCluster` fails with a `ServiceQuotaExceededException` if there is already a cluster in a `Creating` state.
 */
export declare const createCluster: API.OperationMethod<CreateClusterRequest, CreateClusterResponse, CreateClusterError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates a cluster configuration. You can modify Slurm scheduler settings, accounting configuration, and security groups for an existing cluster.
 *
 * You can only update clusters that are in `ACTIVE`, `UPDATE_FAILED`, or `SUSPENDED` state. All associated resources (queues and compute node groups) must be in `ACTIVE` state before you can update the cluster.
 */
export declare const updateCluster: API.OperationMethod<UpdateClusterRequest, UpdateClusterResponse, UpdateClusterError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a cluster and all its linked resources. You must delete all queues and compute node groups associated with the cluster before you can delete the cluster.
 */
export declare const deleteCluster: API.OperationMethod<DeleteClusterRequest, DeleteClusterResponse, DeleteClusterError, Credentials | Region | HttpClient.HttpClient>;
export type GetClusterError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns detailed information about a running cluster in your account. This API action provides networking information, endpoint information for communication with the scheduler, and provisioning status.
 */
export declare const getCluster: API.OperationMethod<GetClusterRequest, GetClusterResponse, GetClusterError, Credentials | Region | HttpClient.HttpClient>;
export type RegisterComputeNodeGroupInstanceError = AccessDeniedException | InternalServerException | CommonErrors;
/**
 * This API action isn't intended for you to use.
 *
 * PCS uses this API action to register the compute nodes it launches in your account.
 */
export declare const registerComputeNodeGroupInstance: API.OperationMethod<RegisterComputeNodeGroupInstanceRequest, RegisterComputeNodeGroupInstanceResponse, RegisterComputeNodeGroupInstanceError, Credentials | Region | HttpClient.HttpClient>;
export type ListClustersError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of running clusters in your account.
 */
export declare const listClusters: API.OperationMethod<ListClustersRequest, ListClustersResponse, ListClustersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListClustersRequest) => stream.Stream<ListClustersResponse, ListClustersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListClustersRequest) => stream.Stream<ClusterSummary, ListClustersError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateComputeNodeGroupError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a managed set of compute nodes. You associate a compute node group with a cluster through 1 or more PCS queues or as part of the login fleet. A compute node group includes the definition of the compute properties and lifecycle management. PCS uses the information you provide to this API action to launch compute nodes in your account. You can only specify subnets in the same Amazon VPC as your cluster. You receive billing charges for the compute nodes that PCS launches in your account. You must already have a launch template before you call this API. For more information, see Launch an instance from a launch template in the *Amazon Elastic Compute Cloud User Guide for Linux Instances*.
 */
export declare const createComputeNodeGroup: API.OperationMethod<CreateComputeNodeGroupRequest, CreateComputeNodeGroupResponse, CreateComputeNodeGroupError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateComputeNodeGroupError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates a compute node group. You can update many of the fields related to your compute node group including the configurations for networking, compute nodes, and settings specific to your scheduler (such as Slurm).
 */
export declare const updateComputeNodeGroup: API.OperationMethod<UpdateComputeNodeGroupRequest, UpdateComputeNodeGroupResponse, UpdateComputeNodeGroupError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteComputeNodeGroupError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a compute node group. You must delete all queues associated with the compute node group first.
 */
export declare const deleteComputeNodeGroup: API.OperationMethod<DeleteComputeNodeGroupRequest, DeleteComputeNodeGroupResponse, DeleteComputeNodeGroupError, Credentials | Region | HttpClient.HttpClient>;
export type GetComputeNodeGroupError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns detailed information about a compute node group. This API action provides networking information, EC2 instance type, compute node group status, and scheduler (such as Slurm) configuration.
 */
export declare const getComputeNodeGroup: API.OperationMethod<GetComputeNodeGroupRequest, GetComputeNodeGroupResponse, GetComputeNodeGroupError, Credentials | Region | HttpClient.HttpClient>;
export type ListComputeNodeGroupsError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of all compute node groups associated with a cluster.
 */
export declare const listComputeNodeGroups: API.OperationMethod<ListComputeNodeGroupsRequest, ListComputeNodeGroupsResponse, ListComputeNodeGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListComputeNodeGroupsRequest) => stream.Stream<ListComputeNodeGroupsResponse, ListComputeNodeGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListComputeNodeGroupsRequest) => stream.Stream<ComputeNodeGroupSummary, ListComputeNodeGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateQueueError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a job queue. You must associate 1 or more compute node groups with the queue. You can associate 1 compute node group with multiple queues.
 */
export declare const createQueue: API.OperationMethod<CreateQueueRequest, CreateQueueResponse, CreateQueueError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateQueueError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the compute node group configuration of a queue. Use this API to change the compute node groups that the queue can send jobs to.
 */
export declare const updateQueue: API.OperationMethod<UpdateQueueRequest, UpdateQueueResponse, UpdateQueueError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteQueueError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a job queue. If the compute node group associated with this queue isn't associated with any other queues, PCS terminates all the compute nodes for this queue.
 */
export declare const deleteQueue: API.OperationMethod<DeleteQueueRequest, DeleteQueueResponse, DeleteQueueError, Credentials | Region | HttpClient.HttpClient>;
export type GetQueueError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns detailed information about a queue. The information includes the compute node groups that the queue uses to schedule jobs.
 */
export declare const getQueue: API.OperationMethod<GetQueueRequest, GetQueueResponse, GetQueueError, Credentials | Region | HttpClient.HttpClient>;
export type ListQueuesError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns a list of all queues associated with a cluster.
 */
export declare const listQueues: API.OperationMethod<ListQueuesRequest, ListQueuesResponse, ListQueuesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListQueuesRequest) => stream.Stream<ListQueuesResponse, ListQueuesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListQueuesRequest) => stream.Stream<QueueSummary, ListQueuesError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=pcs.d.ts.map