import { type DisplayProperty } from "@systemfsoftware/trigger.dev_core-v2";
import { type ErrorWithStack, type SchemaError, type ServerTask } from "@systemfsoftware/trigger.dev_core-v2";
declare const ResumeWithTaskError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeWithTaskError";
} & Readonly<A>;
export declare class ResumeWithTaskError extends ResumeWithTaskError_base<{
    readonly task: ServerTask;
}> {
    constructor(task: ServerTask);
}
declare const ResumeWithParallelTaskError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeWithTaskError";
} & Readonly<A>;
export declare class ResumeWithParallelTaskError extends ResumeWithParallelTaskError_base<{
    readonly task: ServerTask;
    readonly childErrors: ReadonlyArray<TriggerInternalError>;
}> {
    constructor(task: ServerTask, childErrors: ReadonlyArray<TriggerInternalError>);
}
declare const RetryWithTaskError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "RetryWithTaskError";
} & Readonly<A>;
export declare class RetryWithTaskError extends RetryWithTaskError_base<{
    readonly cause: ErrorWithStack;
    readonly task: ServerTask;
    readonly retryAt: Date;
}> {
    constructor(cause: ErrorWithStack, task: ServerTask, retryAt: Date);
}
declare const CanceledWithTaskError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "CanceledWithTaskError";
} & Readonly<A>;
export declare class CanceledWithTaskError extends CanceledWithTaskError_base<{
    readonly task: ServerTask;
}> {
    constructor(task: ServerTask);
}
declare const YieldExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "YieldExecutionError";
} & Readonly<A>;
export declare class YieldExecutionError extends YieldExecutionError_base<{
    readonly key: string;
}> {
    constructor(key: string);
}
declare const AutoYieldExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "YieldExecutionError";
} & Readonly<A>;
export declare class AutoYieldExecutionError extends AutoYieldExecutionError_base<{
    readonly location: string;
    readonly timeRemaining: number;
    readonly timeElapsed: number;
}> {
    constructor(location: string, timeRemaining: number, timeElapsed: number);
}
declare const AutoYieldWithCompletedTaskExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "AutoYieldWithCompletedTaskExecutionError";
} & Readonly<A>;
export declare class AutoYieldWithCompletedTaskExecutionError extends AutoYieldWithCompletedTaskExecutionError_base<{
    readonly id: string;
    readonly properties?: DisplayProperty[];
    readonly data: {
        location: string;
        timeRemaining: number;
        timeElapsed: number;
    };
    readonly output?: string;
}> {
    constructor(id: string, properties: DisplayProperty[] | undefined, data: {
        location: string;
        timeRemaining: number;
        timeElapsed: number;
    }, output?: string);
}
declare const AutoYieldRateLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "AutoYieldRateLimitError";
} & Readonly<A>;
export declare class AutoYieldRateLimitError extends AutoYieldRateLimitError_base<{
    readonly resetAtTimestamp: number;
}> {
    constructor(resetAtTimestamp: number);
}
declare const ParsedPayloadSchemaError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "ParsedPayloadSchemaError";
} & Readonly<A>;
export declare class ParsedPayloadSchemaError extends ParsedPayloadSchemaError_base<{
    readonly schemaErrors: ReadonlyArray<SchemaError>;
}> {
    constructor(schemaErrors: ReadonlyArray<SchemaError>);
}
export type TriggerInternalError = ResumeWithTaskError | RetryWithTaskError | CanceledWithTaskError | YieldExecutionError | AutoYieldExecutionError | AutoYieldWithCompletedTaskExecutionError | AutoYieldRateLimitError | ResumeWithParallelTaskError;
/** Use this function if you're using a `try/catch` block to catch errors.
 * It checks if a thrown error is a special internal error that you should ignore.
 * If this returns `true` then you must rethrow the error: `throw err;`
 * @param err The error to check
 * @returns `true` if the error is a Trigger Error, `false` otherwise.
 */
export declare function isTriggerError(err: unknown): err is TriggerInternalError;
declare const ErrorWithTask_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "ErrorWithTask";
} & Readonly<A>;
export declare class ErrorWithTask extends ErrorWithTask_base<{
    readonly cause: ServerTask;
    readonly message: string;
}> {
    constructor(cause: ServerTask, message: string);
}
export {};
//# sourceMappingURL=errors.d.ts.map