import type { ListmonkClient } from "@listmonk-ops/openapi";
import { type TransactionalIdempotencyStore } from "@listmonk-ops/operations";
import { z } from "zod";
import { type SequenceEnrollment, type SequenceRepository } from "./sequences.js";
export interface SequenceOperationContext {
    repository?: SequenceRepository;
    client?: Pick<ListmonkClient, "subscriber" | "transactional"> & Partial<Pick<ListmonkClient, "list">>;
    idempotencyStore?: TransactionalIdempotencyStore;
    hashPayload?: (serialized: string) => string;
    target?: {
        baseUrl?: string;
        username?: string;
    };
    now?: () => Date;
}
declare const sequenceValidateInputSchema: z.ZodObject<{
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>;
declare const sequenceCreateInputSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>;
declare const sequenceUpdateInputSchema: z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>;
declare const sequenceListInputSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<{
        active: "active";
        paused: "paused";
    }>>;
}, z.core.$strip>;
declare const sequenceGetInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
declare const sequenceDeleteInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
declare const sequenceEnrollInputSchema: z.ZodObject<{
    id: z.ZodUUID;
    subscriber_id: z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>;
    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    start_at: z.ZodOptional<z.ZodISODateTime>;
    expected_prior_enrollments: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
declare const sequenceEnrollmentListInputSchema: z.ZodObject<{
    sequence_id: z.ZodOptional<z.ZodUUID>;
    subscriber_id: z.ZodOptional<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    status: z.ZodOptional<z.ZodEnum<{
        ambiguous: "ambiguous";
        cancelled: "cancelled";
        completed: "completed";
        failed: "failed";
        paused: "paused";
        pending: "pending";
        running: "running";
        waiting: "waiting";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>;
declare const sequenceEnrollmentGetInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
declare const sequencePauseInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
declare const sequenceResumeInputSchema: z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>;
declare const sequenceTickInputSchema: z.ZodObject<{
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    lease_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const sequenceReconcileInputSchema: z.ZodObject<{
    enrollment_id: z.ZodOptional<z.ZodUUID>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
    resolution: z.ZodOptional<z.ZodEnum<{
        not_sent: "not_sent";
        sent: "sent";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    dry_run: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
}, z.core.$strip>;
declare const sequenceStatusInputSchema: z.ZodObject<{
    worker_stale_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>;
declare function toEnrollmentOutput(enrollment: SequenceEnrollment): {
    id: string;
    sequence_id: string;
    revision: number;
    subscriber_reference_present: true;
    status: import("./sequences.js").SequenceEnrollmentStatus;
    retry_count: number;
    current_step_id: string;
    /** The requested initial activation time; next_run_at moves as steps advance. */
    start_at: string | undefined;
    next_run_at: string;
    last_error_present: boolean;
    created_at: string;
    updated_at: string;
};
export declare function executeSequenceValidateOperation(_context: SequenceOperationContext, input: z.output<typeof sequenceValidateInputSchema>): Promise<{
    valid: true;
    step_count: number;
    step_ids: string[];
}>;
export declare function executeSequenceCreateOperation(context: SequenceOperationContext, input: z.output<typeof sequenceCreateInputSchema>): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
    created: true;
} | {
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
    created: false;
}>;
export declare function executeSequenceUpdateOperation(context: SequenceOperationContext, input: z.output<typeof sequenceUpdateInputSchema>): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
    updated: boolean;
}>;
export declare function executeSequenceListOperation(context: SequenceOperationContext, input: z.output<typeof sequenceListInputSchema>): Promise<{
    sequences: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    }[];
}>;
export declare function executeSequenceGetOperation(context: SequenceOperationContext, input: z.output<typeof sequenceGetInputSchema>): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function executeSequenceDeleteOperation(context: SequenceOperationContext, input: z.output<typeof sequenceDeleteInputSchema>): Promise<{
    deleted: true;
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
} | {
    sequence?: undefined;
    deleted: false;
}>;
export declare function executeSequenceEnrollOperation(context: SequenceOperationContext, input: z.output<typeof sequenceEnrollInputSchema>): Promise<{
    enrollment: ReturnType<typeof toEnrollmentOutput>;
    created: boolean;
}>;
export declare function executeSequenceEnrollmentListOperation(context: SequenceOperationContext, input: z.output<typeof sequenceEnrollmentListInputSchema>): Promise<{
    enrollments: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: import("./sequences.js").SequenceEnrollmentStatus;
        retry_count: number;
        current_step_id: string;
        /** The requested initial activation time; next_run_at moves as steps advance. */
        start_at: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    }[];
}>;
export declare function executeSequenceEnrollmentGetOperation(context: SequenceOperationContext, input: z.output<typeof sequenceEnrollmentGetInputSchema>): Promise<{
    enrollment: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: import("./sequences.js").SequenceEnrollmentStatus;
        retry_count: number;
        current_step_id: string;
        /** The requested initial activation time; next_run_at moves as steps advance. */
        start_at: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    };
}>;
export declare function executeSequencePauseOperation(context: SequenceOperationContext, input: z.output<typeof sequencePauseInputSchema>): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function executeSequenceResumeOperation(context: SequenceOperationContext, input: z.output<typeof sequenceResumeInputSchema>): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: import("./sequences.js").SequenceDefinitionStatus;
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function executeSequenceTickOperation(context: SequenceOperationContext, input: z.output<typeof sequenceTickInputSchema>): Promise<{
    claimed: number;
    claimed_ids: string[];
    claimed_steps: {
        enrollment_id: string;
        step_id: string;
    }[];
    advanced: number;
    waiting: number;
    completed: number;
    failed: number;
    ambiguous: number;
    cancelled: number;
    completed_at: string;
    requested: number;
    already_done: number;
    pending_ids: string[];
} | {
    requested?: undefined;
    already_done?: undefined;
    pending_ids?: undefined;
    claimed: number;
    claimed_ids: string[];
    claimed_steps: {
        enrollment_id: string;
        step_id: string;
    }[];
    advanced: number;
    waiting: number;
    completed: number;
    failed: number;
    ambiguous: number;
    cancelled: number;
    completed_at: string;
}>;
export declare function executeSequenceReconcileOperation(context: SequenceOperationContext, input: z.output<typeof sequenceReconcileInputSchema>): Promise<{
    scanned_ids: string[];
    scanned: number;
    recovered: number;
    unchanged: number;
    dry_run: boolean;
    enrollment: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: import("./sequences.js").SequenceEnrollmentStatus;
        retry_count: number;
        current_step_id: string;
        /** The requested initial activation time; next_run_at moves as steps advance. */
        start_at: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    };
} | {
    enrollment?: undefined;
    scanned_ids: string[];
    scanned: number;
    recovered: number;
    unchanged: number;
    dry_run: boolean;
}>;
export declare function executeSequenceStatusOperation(context: SequenceOperationContext, input: z.output<typeof sequenceStatusInputSchema>): Promise<{
    store: "file" | "postgres";
    schema_version: number;
    healthy: boolean;
    checked_at: string;
    definitions: Readonly<{
        total: number;
        active: number;
        paused: number;
    }>;
    enrollments: {
        due: number;
        leased: number;
        oldestDueAt?: string | undefined;
        oldest_due_at: string | undefined;
        ambiguous: number;
        cancelled: number;
        completed: number;
        failed: number;
        paused: number;
        pending: number;
        running: number;
        waiting: number;
    };
    workers: {
        running: number;
        stale: number;
        stopped: number;
        failed: number;
        lastHeartbeatAt?: string | undefined;
        last_heartbeat_at: string | undefined;
    };
}>;
export declare const sequenceValidateOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    valid: z.ZodLiteral<true>;
    step_count: z.ZodNumber;
    step_ids: z.ZodArray<z.ZodString>;
}, z.core.$strip>>;
export declare const sequenceCreateOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>>;
export declare const sequenceUpdateOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    updated: z.ZodBoolean;
}, z.core.$strip>>;
export declare const sequenceListOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<{
        active: "active";
        paused: "paused";
    }>>;
}, z.core.$strip>, z.ZodObject<{
    sequences: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>>;
export declare const sequenceGetOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>>;
export declare const sequenceDeleteOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    deleted: z.ZodBoolean;
    sequence: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>>;
export declare const sequenceEnrollOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    subscriber_id: z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>;
    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    start_at: z.ZodOptional<z.ZodISODateTime>;
    expected_prior_enrollments: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>>;
export declare const sequenceEnrollmentListOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    sequence_id: z.ZodOptional<z.ZodUUID>;
    subscriber_id: z.ZodOptional<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    status: z.ZodOptional<z.ZodEnum<{
        ambiguous: "ambiguous";
        cancelled: "cancelled";
        completed: "completed";
        failed: "failed";
        paused: "paused";
        pending: "pending";
        running: "running";
        waiting: "waiting";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    enrollments: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>>;
export declare const sequenceEnrollmentGetOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>>;
export declare const sequencePauseOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>>;
export declare const sequenceResumeOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>>;
export declare const sequenceTickOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    lease_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>, z.ZodObject<{
    claimed: z.ZodNumber;
    claimed_ids: z.ZodArray<z.ZodUUID>;
    claimed_steps: z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>;
    advanced: z.ZodNumber;
    waiting: z.ZodNumber;
    completed: z.ZodNumber;
    failed: z.ZodNumber;
    ambiguous: z.ZodNumber;
    cancelled: z.ZodNumber;
    completed_at: z.ZodISODateTime;
    requested: z.ZodOptional<z.ZodNumber>;
    already_done: z.ZodOptional<z.ZodNumber>;
    pending_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
}, z.core.$strip>>;
export declare const sequenceReconcileOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    enrollment_id: z.ZodOptional<z.ZodUUID>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
    resolution: z.ZodOptional<z.ZodEnum<{
        not_sent: "not_sent";
        sent: "sent";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    dry_run: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    scanned_ids: z.ZodArray<z.ZodUUID>;
    scanned: z.ZodNumber;
    recovered: z.ZodNumber;
    unchanged: z.ZodNumber;
    dry_run: z.ZodBoolean;
    enrollment: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>>;
export declare const sequenceStatusOperation: import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    worker_stale_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    store: z.ZodEnum<{
        file: "file";
        postgres: "postgres";
    }>;
    schema_version: z.ZodNumber;
    healthy: z.ZodBoolean;
    checked_at: z.ZodISODateTime;
    definitions: z.ZodObject<{
        total: z.ZodNumber;
        active: z.ZodNumber;
        paused: z.ZodNumber;
    }, z.core.$strip>;
    enrollments: z.ZodObject<{
        pending: z.ZodNumber;
        running: z.ZodNumber;
        waiting: z.ZodNumber;
        paused: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        ambiguous: z.ZodNumber;
        cancelled: z.ZodNumber;
        due: z.ZodNumber;
        leased: z.ZodNumber;
        oldest_due_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
    workers: z.ZodObject<{
        running: z.ZodNumber;
        stale: z.ZodNumber;
        stopped: z.ZodNumber;
        failed: z.ZodNumber;
        last_heartbeat_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
}, z.core.$strip>>;
export declare function invokeSequenceValidateOperation(context: SequenceOperationContext, input: unknown): Promise<{
    valid: true;
    step_count: number;
    step_ids: string[];
}>;
export declare function invokeSequenceCreateOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
    created: boolean;
}>;
export declare function invokeSequenceUpdateOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
    updated: boolean;
}>;
export declare function invokeSequenceListOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequences: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    }[];
}>;
export declare function invokeSequenceGetOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function invokeSequenceDeleteOperation(context: SequenceOperationContext, input: unknown): Promise<{
    deleted: boolean;
    sequence?: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    } | undefined;
}>;
export declare function invokeSequenceEnrollOperation(context: SequenceOperationContext, input: unknown): Promise<{
    enrollment: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: "ambiguous" | "cancelled" | "completed" | "failed" | "paused" | "pending" | "running" | "waiting";
        retry_count: number;
        current_step_id: string;
        start_at?: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    };
    created: boolean;
}>;
export declare function invokeSequenceEnrollmentListOperation(context: SequenceOperationContext, input: unknown): Promise<{
    enrollments: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: "ambiguous" | "cancelled" | "completed" | "failed" | "paused" | "pending" | "running" | "waiting";
        retry_count: number;
        current_step_id: string;
        start_at?: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    }[];
}>;
export declare function invokeSequenceEnrollmentGetOperation(context: SequenceOperationContext, input: unknown): Promise<{
    enrollment: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: "ambiguous" | "cancelled" | "completed" | "failed" | "paused" | "pending" | "running" | "waiting";
        retry_count: number;
        current_step_id: string;
        start_at?: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    };
}>;
export declare function invokeSequencePauseOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function invokeSequenceResumeOperation(context: SequenceOperationContext, input: unknown): Promise<{
    sequence: {
        id: string;
        name: string;
        description_present: boolean;
        status: "active" | "paused";
        current_revision: number;
        revisions: {
            revision: number;
            step_count: number;
            step_types: ("condition" | "send" | "stop" | "wait" | "wait_until")[];
            content_fingerprint: string;
            created_at: string;
        }[];
        created_at: string;
        updated_at: string;
    };
}>;
export declare function invokeSequenceTickOperation(context: SequenceOperationContext, input: unknown): Promise<{
    claimed: number;
    claimed_ids: string[];
    claimed_steps: {
        enrollment_id: string;
        step_id: string;
    }[];
    advanced: number;
    waiting: number;
    completed: number;
    failed: number;
    ambiguous: number;
    cancelled: number;
    completed_at: string;
    requested?: number | undefined;
    already_done?: number | undefined;
    pending_ids?: string[] | undefined;
}>;
export declare function invokeSequenceReconcileOperation(context: SequenceOperationContext, input: unknown): Promise<{
    scanned_ids: string[];
    scanned: number;
    recovered: number;
    unchanged: number;
    dry_run: boolean;
    enrollment?: {
        id: string;
        sequence_id: string;
        revision: number;
        subscriber_reference_present: true;
        status: "ambiguous" | "cancelled" | "completed" | "failed" | "paused" | "pending" | "running" | "waiting";
        retry_count: number;
        current_step_id: string;
        start_at?: string | undefined;
        next_run_at: string;
        last_error_present: boolean;
        created_at: string;
        updated_at: string;
    } | undefined;
}>;
export declare function invokeSequenceStatusOperation(context: SequenceOperationContext, input: unknown): Promise<{
    store: "file" | "postgres";
    schema_version: number;
    healthy: boolean;
    checked_at: string;
    definitions: {
        total: number;
        active: number;
        paused: number;
    };
    enrollments: {
        pending: number;
        running: number;
        waiting: number;
        paused: number;
        completed: number;
        failed: number;
        ambiguous: number;
        cancelled: number;
        due: number;
        leased: number;
        oldest_due_at?: string | undefined;
    };
    workers: {
        running: number;
        stale: number;
        stopped: number;
        failed: number;
        last_heartbeat_at?: string | undefined;
    };
}>;
export declare const sequenceOperations: (import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    valid: z.ZodLiteral<true>;
    step_count: z.ZodNumber;
    step_ids: z.ZodArray<z.ZodString>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    updated: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<{
        active: "active";
        paused: "paused";
    }>>;
}, z.core.$strip>, z.ZodObject<{
    sequences: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    deleted: z.ZodBoolean;
    sequence: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    subscriber_id: z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>;
    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    start_at: z.ZodOptional<z.ZodISODateTime>;
    expected_prior_enrollments: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    sequence_id: z.ZodOptional<z.ZodUUID>;
    subscriber_id: z.ZodOptional<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    status: z.ZodOptional<z.ZodEnum<{
        ambiguous: "ambiguous";
        cancelled: "cancelled";
        completed: "completed";
        failed: "failed";
        paused: "paused";
        pending: "pending";
        running: "running";
        waiting: "waiting";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    enrollments: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    lease_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>, z.ZodObject<{
    claimed: z.ZodNumber;
    claimed_ids: z.ZodArray<z.ZodUUID>;
    claimed_steps: z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>;
    advanced: z.ZodNumber;
    waiting: z.ZodNumber;
    completed: z.ZodNumber;
    failed: z.ZodNumber;
    ambiguous: z.ZodNumber;
    cancelled: z.ZodNumber;
    completed_at: z.ZodISODateTime;
    requested: z.ZodOptional<z.ZodNumber>;
    already_done: z.ZodOptional<z.ZodNumber>;
    pending_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    enrollment_id: z.ZodOptional<z.ZodUUID>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
    resolution: z.ZodOptional<z.ZodEnum<{
        not_sent: "not_sent";
        sent: "sent";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    dry_run: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    scanned_ids: z.ZodArray<z.ZodUUID>;
    scanned: z.ZodNumber;
    recovered: z.ZodNumber;
    unchanged: z.ZodNumber;
    dry_run: z.ZodBoolean;
    enrollment: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    worker_stale_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    store: z.ZodEnum<{
        file: "file";
        postgres: "postgres";
    }>;
    schema_version: z.ZodNumber;
    healthy: z.ZodBoolean;
    checked_at: z.ZodISODateTime;
    definitions: z.ZodObject<{
        total: z.ZodNumber;
        active: z.ZodNumber;
        paused: z.ZodNumber;
    }, z.core.$strip>;
    enrollments: z.ZodObject<{
        pending: z.ZodNumber;
        running: z.ZodNumber;
        waiting: z.ZodNumber;
        paused: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        ambiguous: z.ZodNumber;
        cancelled: z.ZodNumber;
        due: z.ZodNumber;
        leased: z.ZodNumber;
        oldest_due_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
    workers: z.ZodObject<{
        running: z.ZodNumber;
        stale: z.ZodNumber;
        stopped: z.ZodNumber;
        failed: z.ZodNumber;
        last_heartbeat_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
}, z.core.$strip>>)[];
export declare const sequenceOperationCatalog: Readonly<{
    id: string;
    title: string;
    operations: (import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"send">;
            template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
            consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
            from_email: z.ZodOptional<z.ZodString>;
            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            content_type: z.ZodOptional<z.ZodEnum<{
                html: "html";
                markdown: "markdown";
                plain: "plain";
            }>>;
            messenger: z.ZodOptional<z.ZodString>;
            subject: z.ZodOptional<z.ZodString>;
            altbody: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait">;
            duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait_until">;
            at: z.ZodISODateTime;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"condition">;
            path: z.ZodString;
            operator: z.ZodEnum<{
                equals: "equals";
                exists: "exists";
                not_equals: "not_equals";
            }>;
            value: z.ZodOptional<z.ZodUnknown>;
            on_true: z.ZodString;
            on_false: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"stop">;
        }, z.core.$strip>], "type">>;
    }, z.core.$strip>, z.ZodObject<{
        valid: z.ZodLiteral<true>;
        step_count: z.ZodNumber;
        step_ids: z.ZodArray<z.ZodString>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"send">;
            template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
            consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
            from_email: z.ZodOptional<z.ZodString>;
            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            content_type: z.ZodOptional<z.ZodEnum<{
                html: "html";
                markdown: "markdown";
                plain: "plain";
            }>>;
            messenger: z.ZodOptional<z.ZodString>;
            subject: z.ZodOptional<z.ZodString>;
            altbody: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait">;
            duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait_until">;
            at: z.ZodISODateTime;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"condition">;
            path: z.ZodString;
            operator: z.ZodEnum<{
                equals: "equals";
                exists: "exists";
                not_equals: "not_equals";
            }>;
            value: z.ZodOptional<z.ZodUnknown>;
            on_true: z.ZodString;
            on_false: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"stop">;
        }, z.core.$strip>], "type">>;
    }, z.core.$strip>, z.ZodObject<{
        sequence: z.ZodObject<{
            id: z.ZodUUID;
            name: z.ZodString;
            description_present: z.ZodBoolean;
            status: z.ZodEnum<{
                active: "active";
                paused: "paused";
            }>;
            current_revision: z.ZodNumber;
            revisions: z.ZodArray<z.ZodObject<{
                revision: z.ZodNumber;
                step_count: z.ZodNumber;
                step_types: z.ZodArray<z.ZodEnum<{
                    condition: "condition";
                    send: "send";
                    stop: "stop";
                    wait: "wait";
                    wait_until: "wait_until";
                }>>;
                content_fingerprint: z.ZodString;
                created_at: z.ZodISODateTime;
            }, z.core.$strip>>;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>;
        created: z.ZodBoolean;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"send">;
            template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
            consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
            from_email: z.ZodOptional<z.ZodString>;
            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            content_type: z.ZodOptional<z.ZodEnum<{
                html: "html";
                markdown: "markdown";
                plain: "plain";
            }>>;
            messenger: z.ZodOptional<z.ZodString>;
            subject: z.ZodOptional<z.ZodString>;
            altbody: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait">;
            duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"wait_until">;
            at: z.ZodISODateTime;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"condition">;
            path: z.ZodString;
            operator: z.ZodEnum<{
                equals: "equals";
                exists: "exists";
                not_equals: "not_equals";
            }>;
            value: z.ZodOptional<z.ZodUnknown>;
            on_true: z.ZodString;
            on_false: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            type: z.ZodLiteral<"stop">;
        }, z.core.$strip>], "type">>;
    }, z.core.$strip>, z.ZodObject<{
        sequence: z.ZodObject<{
            id: z.ZodUUID;
            name: z.ZodString;
            description_present: z.ZodBoolean;
            status: z.ZodEnum<{
                active: "active";
                paused: "paused";
            }>;
            current_revision: z.ZodNumber;
            revisions: z.ZodArray<z.ZodObject<{
                revision: z.ZodNumber;
                step_count: z.ZodNumber;
                step_types: z.ZodArray<z.ZodEnum<{
                    condition: "condition";
                    send: "send";
                    stop: "stop";
                    wait: "wait";
                    wait_until: "wait_until";
                }>>;
                content_fingerprint: z.ZodString;
                created_at: z.ZodISODateTime;
            }, z.core.$strip>>;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>;
        updated: z.ZodBoolean;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        status: z.ZodOptional<z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>>;
    }, z.core.$strip>, z.ZodObject<{
        sequences: z.ZodArray<z.ZodObject<{
            id: z.ZodUUID;
            name: z.ZodString;
            description_present: z.ZodBoolean;
            status: z.ZodEnum<{
                active: "active";
                paused: "paused";
            }>;
            current_revision: z.ZodNumber;
            revisions: z.ZodArray<z.ZodObject<{
                revision: z.ZodNumber;
                step_count: z.ZodNumber;
                step_types: z.ZodArray<z.ZodEnum<{
                    condition: "condition";
                    send: "send";
                    stop: "stop";
                    wait: "wait";
                    wait_until: "wait_until";
                }>>;
                content_fingerprint: z.ZodString;
                created_at: z.ZodISODateTime;
            }, z.core.$strip>>;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        id: z.ZodUUID;
    }, z.core.$strip>, z.ZodObject<{
        sequence: z.ZodObject<{
            id: z.ZodUUID;
            name: z.ZodString;
            description_present: z.ZodBoolean;
            status: z.ZodEnum<{
                active: "active";
                paused: "paused";
            }>;
            current_revision: z.ZodNumber;
            revisions: z.ZodArray<z.ZodObject<{
                revision: z.ZodNumber;
                step_count: z.ZodNumber;
                step_types: z.ZodArray<z.ZodEnum<{
                    condition: "condition";
                    send: "send";
                    stop: "stop";
                    wait: "wait";
                    wait_until: "wait_until";
                }>>;
                content_fingerprint: z.ZodString;
                created_at: z.ZodISODateTime;
            }, z.core.$strip>>;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        id: z.ZodUUID;
    }, z.core.$strip>, z.ZodObject<{
        deleted: z.ZodBoolean;
        sequence: z.ZodOptional<z.ZodObject<{
            id: z.ZodUUID;
            name: z.ZodString;
            description_present: z.ZodBoolean;
            status: z.ZodEnum<{
                active: "active";
                paused: "paused";
            }>;
            current_revision: z.ZodNumber;
            revisions: z.ZodArray<z.ZodObject<{
                revision: z.ZodNumber;
                step_count: z.ZodNumber;
                step_types: z.ZodArray<z.ZodEnum<{
                    condition: "condition";
                    send: "send";
                    stop: "stop";
                    wait: "wait";
                    wait_until: "wait_until";
                }>>;
                content_fingerprint: z.ZodString;
                created_at: z.ZodISODateTime;
            }, z.core.$strip>>;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        id: z.ZodUUID;
        subscriber_id: z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>;
        context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        expected_prior_enrollments: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>, z.ZodObject<{
        enrollment: z.ZodObject<{
            id: z.ZodUUID;
            sequence_id: z.ZodUUID;
            revision: z.ZodNumber;
            subscriber_reference_present: z.ZodLiteral<true>;
            status: z.ZodEnum<{
                ambiguous: "ambiguous";
                cancelled: "cancelled";
                completed: "completed";
                failed: "failed";
                paused: "paused";
                pending: "pending";
                running: "running";
                waiting: "waiting";
            }>;
            retry_count: z.ZodNumber;
            current_step_id: z.ZodString;
            start_at: z.ZodOptional<z.ZodISODateTime>;
            next_run_at: z.ZodISODateTime;
            last_error_present: z.ZodBoolean;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>;
        created: z.ZodBoolean;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        sequence_id: z.ZodOptional<z.ZodUUID>;
        subscriber_id: z.ZodOptional<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
        status: z.ZodOptional<z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>>;
        limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    }, z.core.$strip>, z.ZodObject<{
        enrollments: z.ZodArray<z.ZodObject<{
            id: z.ZodUUID;
            sequence_id: z.ZodUUID;
            revision: z.ZodNumber;
            subscriber_reference_present: z.ZodLiteral<true>;
            status: z.ZodEnum<{
                ambiguous: "ambiguous";
                cancelled: "cancelled";
                completed: "completed";
                failed: "failed";
                paused: "paused";
                pending: "pending";
                running: "running";
                waiting: "waiting";
            }>;
            retry_count: z.ZodNumber;
            current_step_id: z.ZodString;
            start_at: z.ZodOptional<z.ZodISODateTime>;
            next_run_at: z.ZodISODateTime;
            last_error_present: z.ZodBoolean;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        id: z.ZodUUID;
    }, z.core.$strip>, z.ZodObject<{
        enrollment: z.ZodObject<{
            id: z.ZodUUID;
            sequence_id: z.ZodUUID;
            revision: z.ZodNumber;
            subscriber_reference_present: z.ZodLiteral<true>;
            status: z.ZodEnum<{
                ambiguous: "ambiguous";
                cancelled: "cancelled";
                completed: "completed";
                failed: "failed";
                paused: "paused";
                pending: "pending";
                running: "running";
                waiting: "waiting";
            }>;
            retry_count: z.ZodNumber;
            current_step_id: z.ZodString;
            start_at: z.ZodOptional<z.ZodISODateTime>;
            next_run_at: z.ZodISODateTime;
            last_error_present: z.ZodBoolean;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
        lease_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
        recovery_set: z.ZodOptional<z.ZodArray<z.ZodObject<{
            enrollment_id: z.ZodUUID;
            step_id: z.ZodString;
        }, z.core.$strip>>>;
    }, z.core.$strip>, z.ZodObject<{
        claimed: z.ZodNumber;
        claimed_ids: z.ZodArray<z.ZodUUID>;
        claimed_steps: z.ZodArray<z.ZodObject<{
            enrollment_id: z.ZodUUID;
            step_id: z.ZodString;
        }, z.core.$strip>>;
        advanced: z.ZodNumber;
        waiting: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        ambiguous: z.ZodNumber;
        cancelled: z.ZodNumber;
        completed_at: z.ZodISODateTime;
        requested: z.ZodOptional<z.ZodNumber>;
        already_done: z.ZodOptional<z.ZodNumber>;
        pending_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        enrollment_id: z.ZodOptional<z.ZodUUID>;
        recovery_set: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
        resolution: z.ZodOptional<z.ZodEnum<{
            not_sent: "not_sent";
            sent: "sent";
        }>>;
        limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
        dry_run: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
    }, z.core.$strip>, z.ZodObject<{
        scanned_ids: z.ZodArray<z.ZodUUID>;
        scanned: z.ZodNumber;
        recovered: z.ZodNumber;
        unchanged: z.ZodNumber;
        dry_run: z.ZodBoolean;
        enrollment: z.ZodOptional<z.ZodObject<{
            id: z.ZodUUID;
            sequence_id: z.ZodUUID;
            revision: z.ZodNumber;
            subscriber_reference_present: z.ZodLiteral<true>;
            status: z.ZodEnum<{
                ambiguous: "ambiguous";
                cancelled: "cancelled";
                completed: "completed";
                failed: "failed";
                paused: "paused";
                pending: "pending";
                running: "running";
                waiting: "waiting";
            }>;
            retry_count: z.ZodNumber;
            current_step_id: z.ZodString;
            start_at: z.ZodOptional<z.ZodISODateTime>;
            next_run_at: z.ZodISODateTime;
            last_error_present: z.ZodBoolean;
            created_at: z.ZodISODateTime;
            updated_at: z.ZodISODateTime;
        }, z.core.$strip>>;
    }, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
        worker_stale_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    }, z.core.$strip>, z.ZodObject<{
        store: z.ZodEnum<{
            file: "file";
            postgres: "postgres";
        }>;
        schema_version: z.ZodNumber;
        healthy: z.ZodBoolean;
        checked_at: z.ZodISODateTime;
        definitions: z.ZodObject<{
            total: z.ZodNumber;
            active: z.ZodNumber;
            paused: z.ZodNumber;
        }, z.core.$strip>;
        enrollments: z.ZodObject<{
            pending: z.ZodNumber;
            running: z.ZodNumber;
            waiting: z.ZodNumber;
            paused: z.ZodNumber;
            completed: z.ZodNumber;
            failed: z.ZodNumber;
            ambiguous: z.ZodNumber;
            cancelled: z.ZodNumber;
            due: z.ZodNumber;
            leased: z.ZodNumber;
            oldest_due_at: z.ZodOptional<z.ZodISODateTime>;
        }, z.core.$strip>;
        workers: z.ZodObject<{
            running: z.ZodNumber;
            stale: z.ZodNumber;
            stopped: z.ZodNumber;
            failed: z.ZodNumber;
            last_heartbeat_at: z.ZodOptional<z.ZodISODateTime>;
        }, z.core.$strip>;
    }, z.core.$strip>>)[];
    specMigrationExemptions: readonly import("@listmonk-ops/operations/specs").OperationSpecMigrationExemption[];
}>;
export declare function getSequenceOperationByMcpName(name: string): import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    valid: z.ZodLiteral<true>;
    step_count: z.ZodNumber;
    step_ids: z.ZodArray<z.ZodString>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"send">;
        template_id: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
        consent_list_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
        from_email: z.ZodOptional<z.ZodString>;
        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        content_type: z.ZodOptional<z.ZodEnum<{
            html: "html";
            markdown: "markdown";
            plain: "plain";
        }>>;
        messenger: z.ZodOptional<z.ZodString>;
        subject: z.ZodOptional<z.ZodString>;
        altbody: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait">;
        duration_seconds: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"wait_until">;
        at: z.ZodISODateTime;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"condition">;
        path: z.ZodString;
        operator: z.ZodEnum<{
            equals: "equals";
            exists: "exists";
            not_equals: "not_equals";
        }>;
        value: z.ZodOptional<z.ZodUnknown>;
        on_true: z.ZodString;
        on_false: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"stop">;
    }, z.core.$strip>], "type">>;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    updated: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<{
        active: "active";
        paused: "paused";
    }>>;
}, z.core.$strip>, z.ZodObject<{
    sequences: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    sequence: z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    deleted: z.ZodBoolean;
    sequence: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        name: z.ZodString;
        description_present: z.ZodBoolean;
        status: z.ZodEnum<{
            active: "active";
            paused: "paused";
        }>;
        current_revision: z.ZodNumber;
        revisions: z.ZodArray<z.ZodObject<{
            revision: z.ZodNumber;
            step_count: z.ZodNumber;
            step_types: z.ZodArray<z.ZodEnum<{
                condition: "condition";
                send: "send";
                stop: "stop";
                wait: "wait";
                wait_until: "wait_until";
            }>>;
            content_fingerprint: z.ZodString;
            created_at: z.ZodISODateTime;
        }, z.core.$strip>>;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
    subscriber_id: z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>;
    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    start_at: z.ZodOptional<z.ZodISODateTime>;
    expected_prior_enrollments: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
    created: z.ZodBoolean;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    sequence_id: z.ZodOptional<z.ZodUUID>;
    subscriber_id: z.ZodOptional<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    status: z.ZodOptional<z.ZodEnum<{
        ambiguous: "ambiguous";
        cancelled: "cancelled";
        completed: "completed";
        failed: "failed";
        paused: "paused";
        pending: "pending";
        running: "running";
        waiting: "waiting";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    enrollments: z.ZodArray<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    id: z.ZodUUID;
}, z.core.$strip>, z.ZodObject<{
    enrollment: z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    lease_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>, z.ZodObject<{
    claimed: z.ZodNumber;
    claimed_ids: z.ZodArray<z.ZodUUID>;
    claimed_steps: z.ZodArray<z.ZodObject<{
        enrollment_id: z.ZodUUID;
        step_id: z.ZodString;
    }, z.core.$strip>>;
    advanced: z.ZodNumber;
    waiting: z.ZodNumber;
    completed: z.ZodNumber;
    failed: z.ZodNumber;
    ambiguous: z.ZodNumber;
    cancelled: z.ZodNumber;
    completed_at: z.ZodISODateTime;
    requested: z.ZodOptional<z.ZodNumber>;
    already_done: z.ZodOptional<z.ZodNumber>;
    pending_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    enrollment_id: z.ZodOptional<z.ZodUUID>;
    recovery_set: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
    resolution: z.ZodOptional<z.ZodEnum<{
        not_sent: "not_sent";
        sent: "sent";
    }>>;
    limit: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
    dry_run: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    scanned_ids: z.ZodArray<z.ZodUUID>;
    scanned: z.ZodNumber;
    recovered: z.ZodNumber;
    unchanged: z.ZodNumber;
    dry_run: z.ZodBoolean;
    enrollment: z.ZodOptional<z.ZodObject<{
        id: z.ZodUUID;
        sequence_id: z.ZodUUID;
        revision: z.ZodNumber;
        subscriber_reference_present: z.ZodLiteral<true>;
        status: z.ZodEnum<{
            ambiguous: "ambiguous";
            cancelled: "cancelled";
            completed: "completed";
            failed: "failed";
            paused: "paused";
            pending: "pending";
            running: "running";
            waiting: "waiting";
        }>;
        retry_count: z.ZodNumber;
        current_step_id: z.ZodString;
        start_at: z.ZodOptional<z.ZodISODateTime>;
        next_run_at: z.ZodISODateTime;
        last_error_present: z.ZodBoolean;
        created_at: z.ZodISODateTime;
        updated_at: z.ZodISODateTime;
    }, z.core.$strip>>;
}, z.core.$strip>> | import("@listmonk-ops/operations").OperationDefinition<SequenceOperationContext, z.ZodObject<{
    worker_stale_ms: z.ZodDefault<z.ZodNonOptional<z.ZodPreprocess<z.ZodCoercedNumber<unknown>, unknown>>>;
}, z.core.$strip>, z.ZodObject<{
    store: z.ZodEnum<{
        file: "file";
        postgres: "postgres";
    }>;
    schema_version: z.ZodNumber;
    healthy: z.ZodBoolean;
    checked_at: z.ZodISODateTime;
    definitions: z.ZodObject<{
        total: z.ZodNumber;
        active: z.ZodNumber;
        paused: z.ZodNumber;
    }, z.core.$strip>;
    enrollments: z.ZodObject<{
        pending: z.ZodNumber;
        running: z.ZodNumber;
        waiting: z.ZodNumber;
        paused: z.ZodNumber;
        completed: z.ZodNumber;
        failed: z.ZodNumber;
        ambiguous: z.ZodNumber;
        cancelled: z.ZodNumber;
        due: z.ZodNumber;
        leased: z.ZodNumber;
        oldest_due_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
    workers: z.ZodObject<{
        running: z.ZodNumber;
        stale: z.ZodNumber;
        stopped: z.ZodNumber;
        failed: z.ZodNumber;
        last_heartbeat_at: z.ZodOptional<z.ZodISODateTime>;
    }, z.core.$strip>;
}, z.core.$strip>> | undefined;
export declare function invokeSequenceOperationByMcpName(context: SequenceOperationContext, name: string, input: unknown): Promise<{
    operation: (typeof sequenceOperations)[number];
    output: unknown;
} | undefined>;
export {};