import { z } from 'zod';
import type { UnknownRestBinding } from '../rest-bindings.ts';
declare const forkWorkflowInput: z.ZodObject<{
    workflowId: z.ZodString;
    fromStep: z.ZodOptional<z.ZodUnknown>;
    revision: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const forkWorkflowOutput: z.ZodObject<{
    id: z.ZodString;
}, z.core.$strip>;
export type ForkWorkflowInput = z.infer<typeof forkWorkflowInput>;
export type ForkWorkflowOutput = z.infer<typeof forkWorkflowOutput>;
/**
 * Map an engine error thrown by `engine.fork` to the canonical operation fault.
 *
 * Routing order:
 *   1. `WorkflowRevisionUnavailableError`           → Conflict (409), typed check
 *      first so its message text never accidentally matches a substring
 *      branch below (e.g. its own "not registered" text could otherwise
 *      match the generic 'not found' branch).
 *   2. `VersionMismatchError`                       → Conflict (409), typed check
 *      (Codex review round 11, P2 — see below)
 *   3. `ForkSourceReplacedError`                    → Conflict (409), typed check
 *      (Codex review, item 6 — the source run was replaced by a concurrent
 *      `start-new` while this fork was still resolving or committing, a
 *      legitimate retryable race, not an engine failure)
 *   4. 'fromStep' / 'Checkpoint not found at step' → InvalidParams (400)
 *   5. 'Checkpoint not found'                       → NotFound, resource: 'checkpoint'
 *   6. 'not found'                                  → NotFound, resource: 'workflow'
 *   7. otherwise                                    → EngineFailure
 */
export declare function resolveForkAccess(error: unknown): never;
export declare const forkWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
    workflowId: string;
    fromStep?: unknown;
    revision?: string | undefined;
}, {
    id: string;
}, unknown>;
export declare const forkWorkflowRestBinding: UnknownRestBinding;
export {};