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 HumanLoopName = string;
export type FailureReason = string;
export type HumanLoopArn = string;
export type FlowDefinitionArn = string;
export type NextToken = string;
export type MaxResults = number;
export type InputContent = string;
export interface DeleteHumanLoopRequest {
    HumanLoopName: string;
}
export declare const DeleteHumanLoopRequest: S.Schema<DeleteHumanLoopRequest>;
export interface DeleteHumanLoopResponse {
}
export declare const DeleteHumanLoopResponse: S.Schema<DeleteHumanLoopResponse>;
export interface DescribeHumanLoopRequest {
    HumanLoopName: string;
}
export declare const DescribeHumanLoopRequest: S.Schema<DescribeHumanLoopRequest>;
export type HumanLoopStatus = "InProgress" | "Failed" | "Completed" | "Stopped" | "Stopping" | (string & {});
export declare const HumanLoopStatus: S.String;
export interface HumanLoopOutput {
    OutputS3Uri?: string;
}
export declare const HumanLoopOutput: S.Schema<HumanLoopOutput>;
export interface DescribeHumanLoopResponse {
    CreationTime: Date;
    FailureReason?: string;
    FailureCode?: string;
    HumanLoopStatus: HumanLoopStatus;
    HumanLoopName: string;
    HumanLoopArn: string;
    FlowDefinitionArn: string;
    HumanLoopOutput?: HumanLoopOutput & {
        OutputS3Uri: string;
    };
}
export declare const DescribeHumanLoopResponse: S.Schema<DescribeHumanLoopResponse>;
export type SortOrder = "Ascending" | "Descending" | (string & {});
export declare const SortOrder: S.String;
export interface ListHumanLoopsRequest {
    CreationTimeAfter?: Date;
    CreationTimeBefore?: Date;
    FlowDefinitionArn?: string;
    SortOrder?: SortOrder;
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListHumanLoopsRequest: S.Schema<ListHumanLoopsRequest>;
export interface HumanLoopSummary {
    HumanLoopName?: string;
    HumanLoopStatus?: HumanLoopStatus;
    CreationTime?: Date;
    FailureReason?: string;
    FlowDefinitionArn?: string;
}
export declare const HumanLoopSummary: S.Schema<HumanLoopSummary>;
export type HumanLoopSummaries = HumanLoopSummary[];
export declare const HumanLoopSummaries: S.$Array<S.Schema<HumanLoopSummary>>;
export interface ListHumanLoopsResponse {
    HumanLoopSummaries: HumanLoopSummary[];
    NextToken?: string;
}
export declare const ListHumanLoopsResponse: S.Schema<ListHumanLoopsResponse>;
export interface HumanLoopInput {
    InputContent?: string;
}
export declare const HumanLoopInput: S.Schema<HumanLoopInput>;
export type ContentClassifier = "FreeOfPersonallyIdentifiableInformation" | "FreeOfAdultContent" | (string & {});
export declare const ContentClassifier: S.String;
export type ContentClassifiers = ContentClassifier[];
export declare const ContentClassifiers: S.$Array<S.String>;
export interface HumanLoopDataAttributes {
    ContentClassifiers?: ContentClassifier[];
}
export declare const HumanLoopDataAttributes: S.Schema<HumanLoopDataAttributes>;
export interface StartHumanLoopRequest {
    HumanLoopName?: string;
    FlowDefinitionArn?: string;
    HumanLoopInput?: HumanLoopInput;
    DataAttributes?: HumanLoopDataAttributes;
}
export declare const StartHumanLoopRequest: S.Schema<StartHumanLoopRequest>;
export interface StartHumanLoopResponse {
    HumanLoopArn?: string;
}
export declare const StartHumanLoopResponse: S.Schema<StartHumanLoopResponse>;
export interface StopHumanLoopRequest {
    HumanLoopName?: string;
}
export declare const StopHumanLoopRequest: S.Schema<StopHumanLoopRequest>;
export interface StopHumanLoopResponse {
}
export declare const StopHumanLoopResponse: S.Schema<StopHumanLoopResponse>;
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 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 {
}
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 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 DeleteHumanLoopError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes the specified human loop for a flow definition.
 *
 * If the human loop was deleted, this operation will return a
 * `ResourceNotFoundException`.
 */
export declare const deleteHumanLoop: API.OperationMethod<DeleteHumanLoopRequest, DeleteHumanLoopResponse, DeleteHumanLoopError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeHumanLoopError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about the specified human loop. If the human loop was deleted, this
 * operation will return a `ResourceNotFoundException` error.
 */
export declare const describeHumanLoop: API.OperationMethod<DescribeHumanLoopRequest, DescribeHumanLoopResponse, DescribeHumanLoopError, Credentials | Region | HttpClient.HttpClient>;
export type ListHumanLoopsError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Returns information about human loops, given the specified parameters. If a human loop was deleted, it will not be included.
 */
export declare const listHumanLoops: API.OperationMethod<ListHumanLoopsRequest, ListHumanLoopsResponse, ListHumanLoopsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListHumanLoopsRequest) => stream.Stream<ListHumanLoopsResponse, ListHumanLoopsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListHumanLoopsRequest) => stream.Stream<HumanLoopSummary, ListHumanLoopsError, Credentials | Region | HttpClient.HttpClient>;
};
export type StartHumanLoopError = ConflictException | InternalServerException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Starts a human loop, provided that at least one activation condition is met.
 */
export declare const startHumanLoop: API.OperationMethod<StartHumanLoopRequest, StartHumanLoopResponse, StartHumanLoopError, Credentials | Region | HttpClient.HttpClient>;
export type StopHumanLoopError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Stops the specified human loop.
 */
export declare const stopHumanLoop: API.OperationMethod<StopHumanLoopRequest, StopHumanLoopResponse, StopHumanLoopError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=sagemaker-a2i-runtime.d.ts.map