@ablehi/server-contract 0.2.2 → 0.2.4

package/dist/edge-COdVAE2s.d.ts

@@ -0,0 +1,987 @@
+declare const SERVER_CONTRACT_VERSION = "0.2.4";
+type ServerContractVersion = typeof SERVER_CONTRACT_VERSION;
+
+declare const FLOW_IR_SCHEMA_VERSION = "flow.ir.v1";
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonArray = JsonValue[];
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type ValueExpression = JsonValue;
+type Mapping = {
+    [key: string]: ValueExpression;
+};
+type Operand = string | number | boolean | null;
+type Collection = JsonArray | string;
+type BooleanExpression = {
+    and: BooleanExpression[];
+} | {
+    or: BooleanExpression[];
+} | {
+    not: BooleanExpression;
+} | {
+    eq: [Operand, Operand];
+} | {
+    ne: [Operand, Operand];
+} | {
+    in: [Operand, Collection];
+} | {
+    exists: Operand;
+};
+type TriggerBinding = ScheduleTriggerBinding | IntegrationTriggerBinding | ManualTriggerBinding;
+type ScheduleTriggerBinding = {
+    id: string;
+    kind: "schedule";
+    cron: string;
+    timezone: string;
+    inputMapping?: Mapping;
+};
+type IntegrationTriggerBinding = {
+    id: string;
+    kind: "integration";
+    triggerRef: string;
+    connectionRef: string;
+    config?: JsonObject;
+    inputMapping?: Mapping;
+    dedupeKey?: ValueExpression;
+};
+type ManualTriggerBinding = {
+    id: string;
+    kind: "manual";
+    label?: string;
+};
+type NodeCommon = {
+    id: string;
+    runIf?: BooleanExpression;
+    dependsOn?: string[];
+};
+type ActionNode = NodeCommon & {
+    kind: "action";
+    toolRef: string;
+    connectionRef: string;
+    inputs: Mapping;
+    idempotent?: boolean;
+    retry?: {
+        on: string[];
+        limit: number;
+        backoff: "exponential" | "fixed";
+    };
+    timeout?: string;
+};
+type WaitEventNode = NodeCommon & {
+    kind: "wait_event";
+    eventType: string;
+    correlation: {
+        key: ValueExpression;
+    };
+    timeout: string;
+    onTimeout: "fail" | string;
+};
+type SleepNode = NodeCommon & {
+    kind: "sleep";
+    duration: string;
+};
+type HumanInputPrompt = {
+    title: TextExpression;
+    body?: TextExpression;
+    format?: "plain" | "markdown";
+};
+type HumanInputChoice = {
+    id: string;
+    label: string;
+    style?: "primary" | "secondary" | "danger";
+};
+type HumanChoiceInput = {
+    kind: "choice";
+    choices: HumanInputChoice[];
+    allowComment?: boolean;
+};
+type HumanTextInput = {
+    kind: "text";
+    multiline?: boolean;
+    placeholder?: string;
+    required?: boolean;
+};
+type HumanFormField = {
+    id: string;
+    label: string;
+    type: "text" | "textarea" | "number" | "boolean" | "select";
+    required?: boolean;
+    options?: Array<{
+        id: string;
+        label: string;
+    }>;
+};
+type HumanFormInput = {
+    kind: "form";
+    fields: HumanFormField[];
+};
+type HumanInputSpec = HumanChoiceInput | HumanTextInput | HumanFormInput;
+type HumanInputDeliveryAction = {
+    id: string;
+    toolRef: string;
+    connectionRef: string;
+    inputs: Mapping;
+};
+type HumanInputDelivery = {
+    actions?: HumanInputDeliveryAction[];
+};
+type HumanInputNode = NodeCommon & {
+    kind: "human_input";
+    prompt: HumanInputPrompt;
+    input: HumanInputSpec;
+    timeout: string;
+    delivery?: HumanInputDelivery;
+};
+type FlowNode = ActionNode | WaitEventNode | SleepNode | HumanInputNode;
+type TextExpression = string;
+type FlowCompositionSpec = {
+    title: TextExpression;
+    detail: {
+        format: "markdown";
+        body: TextExpression;
+        data?: Mapping;
+    };
+    report?: {
+        title?: TextExpression;
+        format: "markdown";
+        body: TextExpression;
+        data?: Mapping;
+    };
+};
+type FlowDefinition = {
+    flow: string;
+    triggers?: TriggerBinding[];
+    inputSchema: JsonObject;
+    nodes: FlowNode[];
+    outputs?: Mapping;
+    composition: FlowCompositionSpec;
+};
+type FlowIrValidationCode = "INVALID_IR_SHAPE" | "INVALID_NODE_ID" | "INVALID_TRIGGER_ID" | "INVALID_TRIGGER_KIND" | "INVALID_CRON" | "INVALID_NODE_KIND" | "MISSING_NODE_FIELD" | "INVALID_EVENT_TYPE" | "INVALID_DURATION" | "INVALID_RETRY" | "INVALID_HUMAN_INPUT" | "DUPLICATE_NODE_ID" | "DUPLICATE_TRIGGER_ID" | "DANGLING_DEPENDS_ON" | "DATA_REF_TARGET_MISSING" | "DATA_REF_TARGET_NO_OUTPUT" | "DATA_REF_FORWARD_REFERENCE" | "CYCLE_DETECTED" | "INVALID_ON_TIMEOUT_TARGET" | "INVALID_DSL_OPERATOR" | "INVALID_DSL_OPERAND" | "INVALID_DSL_ARITY" | "TRIGGER_REF_SCOPE_VIOLATION" | "NODE_REF_SCOPE_VIOLATION" | "HUMAN_INPUT_REF_SCOPE_VIOLATION" | "NOW_REF_SCOPE_VIOLATION" | "UNKNOWN_REF_ROOT" | "MALFORMED_TEMPLATE_REFERENCE" | "MALFORMED_NOW_EXPR";
+type FlowIrValidationIssue = {
+    code: FlowIrValidationCode;
+    message: string;
+    path: string;
+};
+type FlowIrValidationResult = {
+    valid: boolean;
+    issues: FlowIrValidationIssue[];
+};
+
+declare const FLOW_INTERPRETER_CONTRACT_VERSION = "flow.interp.v2";
+type FlowInterpreterContractVersion = typeof FLOW_INTERPRETER_CONTRACT_VERSION;
+
+type ContractParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    reason: string;
+};
+declare function contractParseOk<T>(value: T): ContractParseResult<T>;
+declare function contractParseFail<T>(reason: string): ContractParseResult<T>;
+declare function isJsonRecord(value: unknown): value is Record<string, unknown>;
+
+type AblehiSuccess<T> = {
+    ok: true;
+    data: T;
+};
+type AblehiFailure = {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        issues?: unknown;
+        retryable?: boolean;
+    };
+};
+type AblehiEnvelope<T> = AblehiSuccess<T> | AblehiFailure;
+
+declare const CONTEXT_STATE_CLEANUP_ROUTE_PATH = "/cleanup-state-scopes";
+type ContextStateScope = {
+    kind: "webhook-trigger";
+    workspaceId: string;
+    triggerInstanceId: string;
+} | {
+    kind: "polling-trigger";
+    workspaceId: string;
+    pollingInstanceId: string;
+} | {
+    kind: "flow-action";
+    workspaceId: string;
+    flowId: string;
+    nodeId: string;
+    connectionId: string | null;
+};
+type ContextStateCleanupRequestBody = {
+    scopes: ContextStateScope[];
+};
+type ContextStateCleanupResponseData = {
+    deleted: number;
+};
+declare function parseContextStateScope(value: unknown): ContractParseResult<ContextStateScope>;
+declare function parseContextStateCleanupRequestBody(body: unknown): ContractParseResult<ContextStateCleanupRequestBody>;
+declare function parseContextStateCleanupResponseData(data: unknown): ContractParseResult<ContextStateCleanupResponseData>;
+
+declare const INTERNAL_FLOW_RUNS_ROUTE_PREFIX = "/internal/flow-runs";
+declare const EXECUTION_CONTEXT_ROUTE_SUBPATH = "/:flowRunId/execution-context";
+declare function executionContextPath(flowRunId: string): string;
+type ExecutionBindingConnection = {
+    installationId: string;
+    connectionRef: string;
+    connectionId: string;
+    authType: string;
+    connectionConfig?: Record<string, unknown>;
+};
+type ExecutionBinding<TToolDescriptor = Record<string, unknown>, TIntegrationDescriptor = Record<string, unknown>> = {
+    nodeId: string;
+    toolRef: string;
+    toolDescriptor: TToolDescriptor;
+    integrationDescriptor: TIntegrationDescriptor;
+    connection: ExecutionBindingConnection;
+    stateScope: ContextStateScope;
+};
+type FileRuntimeLimits = {
+    fileMaxBytes: number;
+    fileReadMaxBytes: number;
+    inlineMultipartBytesMax: number;
+};
+type FlowExecutionContextFileRuntime = {
+    limits: FileRuntimeLimits;
+} | null;
+type ExecutionContextCompiled = {
+    irSchemaVersion: string;
+    interpreterContractVersion: string;
+    ir: FlowDefinition;
+    compiledArtifactId: string;
+};
+type ExecutionContextData<TToolDescriptor = Record<string, unknown>, TIntegrationDescriptor = Record<string, unknown>> = {
+    flowRunId: string;
+    workspaceId: string;
+    input: Record<string, unknown>;
+    compiled: ExecutionContextCompiled;
+    executionBindings: Array<ExecutionBinding<TToolDescriptor, TIntegrationDescriptor>>;
+    fileRuntime: FlowExecutionContextFileRuntime;
+};
+declare function parseFileRuntimeLimits(value: unknown): ContractParseResult<FileRuntimeLimits>;
+declare function parseExecutionContextData(data: unknown): ContractParseResult<ExecutionContextData>;
+
+declare const STEP_RESULT_ROUTE_SUBPATH = "/:flowRunId/steps/:nodeId/result";
+declare const FLOW_RUN_RESULT_ROUTE_SUBPATH = "/:flowRunId/result";
+declare const EVENT_WAIT_ROUTE_SUBPATH = "/:flowRunId/event-waits/:nodeId";
+declare function stepResultPath(flowRunId: string, nodeId: string): string;
+declare function flowRunResultPath(flowRunId: string): string;
+declare function eventWaitPath(flowRunId: string, nodeId: string): string;
+type StepRecordResult = {
+    status: "succeeded";
+    output: unknown;
+} | {
+    status: "failed";
+    errorCode: string;
+    issues?: unknown;
+};
+type StepRecordBody = {
+    attempt: number;
+    result: StepRecordResult;
+    durationMs?: number;
+};
+type StepRecordData = {
+    flowRunId: string;
+    nodeId: string;
+    recorded: "succeeded" | "failed";
+};
+type StepRecordBodyParseResult = {
+    ok: true;
+    value: StepRecordBody;
+} | {
+    ok: false;
+    kind: "validation" | "step_result_invalid";
+    reason: string;
+};
+declare function parseStepRecordBody(body: unknown): StepRecordBodyParseResult;
+declare function parseStepRecordData(data: unknown): ContractParseResult<StepRecordData>;
+type RenderedFlowComposition = {
+    title: string;
+    detail: {
+        format: "markdown";
+        body: string;
+        data?: unknown;
+    };
+    report?: {
+        origin: "flow_node";
+        title?: string;
+        format: "markdown";
+        body: string;
+        data?: unknown;
+    };
+};
+type FlowRunResultRequestBody = {
+    status: "succeeded";
+    output?: unknown;
+    composition?: RenderedFlowComposition;
+} | {
+    status: "failed";
+    error: {
+        code: string;
+        message: string;
+    };
+};
+type ParsedFlowRunResultBody = {
+    status: "succeeded" | "failed";
+    output?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+    composition?: unknown;
+};
+declare function parseFlowRunResultBody(body: unknown): ContractParseResult<ParsedFlowRunResultBody>;
+type FlowRunResultData = {
+    run: unknown;
+};
+declare function parseFlowRunResultData(data: unknown): ContractParseResult<FlowRunResultData>;
+type RegisterFlowRunWaitBody = {
+    eventType: string;
+    correlationKey: string;
+};
+type CompleteFlowRunWaitBody = {
+    eventType: string;
+    correlationKey: string;
+    outcome: "received" | "timed_out";
+    eventId?: string;
+};
+type RegisterFlowRunWaitData = {
+    registered: true;
+};
+type CompleteFlowRunWaitData = {
+    completed: true;
+};
+declare function parseRegisterFlowRunWaitBody(body: unknown): ContractParseResult<RegisterFlowRunWaitBody>;
+declare function parseCompleteFlowRunWaitBody(body: unknown): ContractParseResult<CompleteFlowRunWaitBody>;
+declare function parseRegisterFlowRunWaitData(data: unknown): ContractParseResult<RegisterFlowRunWaitData>;
+
+declare const INTERNAL_FLOW_VERSIONS_ROUTE_PREFIX = "/internal/flow-versions";
+declare const HANDLER_BUNDLES_ROUTE_SUBPATH = "/:flowVersionId/handler-bundles";
+declare const INTERNAL_INSTALLATIONS_ROUTE_PREFIX = "/internal/installations";
+declare const TOOL_HANDLER_BUNDLES_ROUTE_SUBPATH = "/:installationId/handler-bundles";
+declare function handlerBundlesPath(flowVersionId: string, compiledArtifactId: string): string;
+declare function toolHandlerBundlesPath(args: {
+    installationId: string;
+    workspaceId: string;
+    artifactDigest: string;
+}): string;
+type RuntimeNetworkModel = "managed_only" | "managed_plus_unmanaged_sdk";
+type RuntimeNetwork = {
+    networkModel: RuntimeNetworkModel;
+    apiHosts: string[];
+    authHosts: string[];
+    httpsOnly: boolean;
+};
+type HandlerBundleModule = {
+    entry: string;
+    files: Record<string, string>;
+};
+type HandlerBundle = {
+    toolRef: string;
+    kind: "request";
+    runtimeNetwork: RuntimeNetwork;
+} | {
+    toolRef: string;
+    kind: "handler";
+    module: HandlerBundleModule;
+    runtimeNetwork: RuntimeNetwork;
+};
+type HandlerBundlesData = {
+    flowVersionId: string;
+    compiledArtifactId: string;
+    bundles: HandlerBundle[];
+};
+type ToolHandlerBundlesData = {
+    installationId: string;
+    artifactDigest: string;
+    bundles: HandlerBundle[];
+};
+type HandlerBundlesParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    kind: "shape" | "runtime_network";
+    reason: string;
+};
+declare function parseRuntimeNetwork(value: unknown): HandlerBundlesParseResult<RuntimeNetwork>;
+declare function parseHandlerBundlesData(data: unknown): HandlerBundlesParseResult<HandlerBundlesData>;
+declare function parseToolHandlerBundlesData(data: unknown): HandlerBundlesParseResult<ToolHandlerBundlesData>;
+declare function parseHandlerBundle(value: unknown): HandlerBundlesParseResult<HandlerBundle>;
+
+declare const INTERNAL_WEBHOOK_TRIGGER_INSTANCES_ROUTE_PREFIX = "/internal/webhook-trigger-instances";
+declare const WEBHOOK_TRIGGER_CONTEXT_ROUTE_SUBPATH = "/:triggerInstanceId/context";
+declare const WEBHOOK_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH = "/:triggerInstanceId/handler-bundles";
+declare const WEBHOOK_TRIGGER_DELIVERY_ROUTE_SUBPATH = "/:triggerInstanceId/deliveries/:deliveryId";
+declare const WEBHOOK_TRIGGER_EVENTS_ROUTE_SUBPATH = "/:triggerInstanceId/events";
+declare const WEBHOOK_TRIGGER_REARM_ROUTE_SUBPATH = "/:triggerInstanceId/rearm";
+declare function webhookTriggerContextPath(triggerInstanceId: string, artifactDigest: string): string;
+declare function webhookTriggerHandlerBundlesPath(triggerInstanceId: string, artifactDigest: string): string;
+declare function webhookTriggerDeliveryPath(triggerInstanceId: string, deliveryId: string): string;
+declare function webhookTriggerEventsPath(triggerInstanceId: string): string;
+declare function webhookTriggerRearmPath(triggerInstanceId: string): string;
+declare const WEBHOOK_PROTOCOL_ADAPTER_BUNDLE_ROUTE_SUBPATH = "/:installationId/webhook-protocol-adapter-bundle";
+declare function webhookProtocolAdapterBundlePath(args: {
+    installationId: string;
+    workspaceId: string;
+    artifactDigest: string;
+}): string;
+type WebhookTriggerVerificationMethod = "header_exact_match" | "hmac_sha256" | "hmac_sha1";
+type PackageWebhookTriggerRuntimeDescriptor = {
+    trigger_id: string;
+    trigger_ref: string;
+    type: "webhook";
+    webhook: {
+        verification_method: WebhookTriggerVerificationMethod;
+        signature_header: string;
+        timestamp_header?: string;
+        tolerance_seconds?: number;
+        binding_policy: "per_instance";
+        endpoint_mode: "instance";
+        ack_mode: "platform_managed";
+        event_handler_module: string;
+        enable_handler_module: string;
+        disable_handler_module: string;
+        renew_handler_module?: string;
+    };
+};
+type TriggerConnectionInfo = {
+    connectionId: string;
+    connectionRef: string;
+    integrationRef: string;
+    authType: "oauth2" | "oauth1" | "api_key" | "basic_auth" | "bearer" | "jwt" | "custom" | "two_step";
+    connectionConfig?: Record<string, unknown>;
+};
+type WebhookWatcherContext = {
+    artifactDigest: string;
+    triggerRef: string;
+    triggerName: string;
+    integrationRef: string;
+    inputs: Record<string, unknown>;
+    connection: TriggerConnectionInfo | null;
+    runtime: PackageWebhookTriggerRuntimeDescriptor;
+    stateScope: ContextStateScope;
+    watcher?: {
+        instanceId: string;
+        generation: number;
+    };
+};
+type WebhookDelivery = {
+    deliveryId: string;
+    receivedAt: string;
+    request: {
+        method: "POST";
+        headers: Record<string, string>;
+        rawBody: string;
+    };
+};
+type TriggerHandlerModule = {
+    specifier: string;
+    source: string;
+};
+type TriggerHandlerBundlesData = {
+    triggerRef: string;
+    artifactDigest: string;
+    modules: TriggerHandlerModule[];
+    runtimeNetwork: RuntimeNetwork;
+};
+type WebhookPublishEvent = {
+    eventId: string;
+    occurredAt: string;
+    dedupeKey?: string;
+    payload: Record<string, unknown>;
+};
+type WebhookPublishEventsBody = {
+    deliveryId: string;
+    events: WebhookPublishEvent[];
+};
+type WebhookPublishEventsData = {
+    deliveryId: string;
+    results: {
+        eventId: string;
+        flowRunId: string;
+        status: "dispatched" | "duplicate";
+    }[];
+};
+type WebhookRearmBody = {
+    expectedWatcherInstanceId: string;
+};
+type WebhookRearmData = {
+    rearmed: boolean;
+};
+type WebhookProtocolAdapterModule = {
+    specifier: string;
+    source: string;
+};
+declare const WEBHOOK_PROTOCOL_ADAPTER_MODULE = "modules/webhook/protocol-adapter.js";
+type WebhookProtocolAdapterBundleData = {
+    protocolId: string;
+    artifactDigest: string;
+    module: typeof WEBHOOK_PROTOCOL_ADAPTER_MODULE;
+    modules: WebhookProtocolAdapterModule[];
+};
+declare function flowScriptProtocolAdapterModuleName(artifactDigest: string): string;
+declare function parseWebhookWatcherContext(data: unknown): ContractParseResult<WebhookWatcherContext>;
+declare function parseWebhookDelivery(data: unknown): ContractParseResult<WebhookDelivery>;
+declare function parseTriggerHandlerBundlesData(data: unknown): HandlerBundlesParseResult<TriggerHandlerBundlesData>;
+declare function parseWebhookPublishEventsBody(body: unknown): ContractParseResult<WebhookPublishEventsBody>;
+declare function parseWebhookRearmBody(body: unknown): ContractParseResult<WebhookRearmBody>;
+
+declare const INTERNAL_POLLING_TRIGGER_INSTANCES_ROUTE_PREFIX = "/internal/polling-trigger-instances";
+declare const POLLING_TRIGGER_CONTEXT_ROUTE_SUBPATH = "/:pollingInstanceId/context";
+declare const POLLING_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH = "/:pollingInstanceId/handler-bundles";
+declare const POLLING_TRIGGER_TICK_EVENTS_ROUTE_SUBPATH = "/:pollingInstanceId/ticks/:tickId/events";
+declare function pollingTriggerContextPath(pollingInstanceId: string, artifactDigest: string, tickId: string): string;
+declare function pollingTriggerHandlerBundlesPath(pollingInstanceId: string, artifactDigest: string): string;
+declare function pollingTriggerTickEventsPath(pollingInstanceId: string, tickId: string): string;
+type PackagePollingTriggerRuntimeDescriptor = {
+    trigger_id: string;
+    trigger_ref: string;
+    type: "polling";
+    polling: {
+        schedule: {
+            type: "interval";
+            every_seconds: number;
+        };
+        dedup: {
+            strategy: "cursor" | "hash" | "id_field";
+            cursor_field?: string;
+            id_field?: string;
+        };
+        run_handler_module: string;
+    };
+};
+type PollingTriggerContext = {
+    artifactDigest: string;
+    triggerRef: string;
+    triggerName: string;
+    integrationRef: string;
+    inputs: Record<string, unknown>;
+    connection: TriggerConnectionInfo | null;
+    runtime: PackagePollingTriggerRuntimeDescriptor;
+    stateScope: ContextStateScope;
+    tick: {
+        tickId: string;
+        scheduledAt: string;
+        attempt: number;
+    };
+    limits: {
+        maxEventsPerTick: number;
+    };
+};
+type PollingPublishEvent = {
+    eventId: string;
+    occurredAt?: string;
+    dedupeKey?: string;
+    payload: Record<string, unknown>;
+};
+type PollingPublishBody = {
+    events: PollingPublishEvent[];
+    nextCursor?: string | null;
+};
+type PublishPollingTickEventResult = {
+    eventId: string;
+    dedupeKey: string;
+    duplicate: boolean;
+    flowRunId: string | null;
+};
+type PublishPollingTickEventsData = {
+    tickId: string;
+    cursorUpdated: boolean;
+    results: PublishPollingTickEventResult[];
+};
+declare function parsePollingTriggerContext(data: unknown): ContractParseResult<PollingTriggerContext>;
+declare function parsePollingPublishBody(body: unknown): ContractParseResult<PollingPublishBody>;
+declare function parsePublishPollingTickEventsData(data: unknown): ContractParseResult<PublishPollingTickEventsData>;
+
+declare const INTERNAL_EGRESS_GRANTS_ROUTE_PREFIX = "/internal/egress-grants";
+declare const INTERNAL_TOOL_INVOCATIONS_ROUTE_PREFIX = "/internal/tool-invocations";
+declare const FLOW_RUN_EGRESS_GRANT_ROUTE_SUBPATH = "/:flowRunId/egress-grant";
+declare const TOOL_INVOCATION_EGRESS_GRANT_ROUTE_SUBPATH = "/:invocationId/egress-grant";
+declare const POLLING_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH = "/:pollingInstanceId/egress-grant";
+declare const WEBHOOK_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH = "/:triggerInstanceId/egress-grant";
+declare const EGRESS_GRANT_CONSUME_ROUTE_SUBPATH = "/:grantId/consume";
+declare const EGRESS_GRANT_AUDIT_ROUTE_SUBPATH = "/:grantId/audit";
+declare const flowRunEgressGrantPath: (flowRunId: string) => string;
+declare const toolInvocationEgressGrantPath: (invocationId: string) => string;
+declare const pollingTriggerEgressGrantPath: (pollingInstanceId: string) => string;
+declare const webhookTriggerEgressGrantPath: (triggerInstanceId: string) => string;
+declare const egressGrantConsumePath: (grantId: string) => string;
+declare const egressGrantAuditPath: (grantId: string) => string;
+declare const EGRESS_GRANT_SCOPE_KINDS: readonly ["flow_action", "single_tool", "polling_trigger", "webhook_trigger"];
+type EgressGrantScopeKind = (typeof EGRESS_GRANT_SCOPE_KINDS)[number];
+type EgressGrantFileRuntime = {
+    baseUrl: string;
+    token: string;
+    expiresAt: string;
+    limits: {
+        fileReadMaxBytes: number;
+        inlineMultipartBytesMax: number;
+    };
+};
+type EgressGrant<TDescriptor = unknown> = {
+    grantId: string;
+    scopeKind: EgressGrantScopeKind;
+    scopeId: string;
+    workspaceId: string;
+    installationId: string;
+    connectionId: string | null;
+    artifactDigest: string;
+    descriptorHash: string;
+    requestDigest: string;
+    issuedAt: string;
+    expiresAt: string;
+    networkPolicy: unknown;
+    descriptor: TDescriptor;
+    connection: unknown | null;
+    credential: unknown | null;
+    fileRuntime?: EgressGrantFileRuntime;
+    signature: string;
+};
+type EgressGrantConsumeBody = {
+    scopeKind: EgressGrantScopeKind;
+    scopeId: string;
+    requestDigest: string;
+};
+type EgressGrantAuditBody = {
+    scopeKind: EgressGrantScopeKind;
+    scopeId: string;
+    providerHost: string;
+    status?: number;
+    durationMs: number;
+    requestBytes?: number;
+    responseBytes?: number;
+    errorCode?: string;
+};
+type FlowActionGrantBody = {
+    nodeId: string;
+    requestDigest: string;
+    requestHasMultipartFiles: boolean;
+};
+type SingleToolGrantBody = {
+    requestDigest: string;
+};
+type PollingTriggerGrantBody = {
+    tickId: string;
+    requestDigest: string;
+};
+type WebhookTriggerGrantBody = {
+    phase: "lifecycle" | "handler";
+    lifecycle?: "enable" | "disable" | "renew";
+    requestDigest: string;
+};
+declare function isValidRequestDigest(value: unknown): value is string;
+declare function requestHasMultipartFileParts(request: unknown): boolean;
+type EgressGrantBodyParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    kind: "shape" | "request_digest";
+    reason: string;
+};
+declare function parseFlowActionGrantBody(body: unknown): EgressGrantBodyParseResult<FlowActionGrantBody>;
+declare function parseSingleToolGrantBody(body: unknown): EgressGrantBodyParseResult<SingleToolGrantBody>;
+declare function parsePollingTriggerGrantBody(body: unknown): EgressGrantBodyParseResult<PollingTriggerGrantBody>;
+declare function parseWebhookTriggerGrantBody(body: unknown): EgressGrantBodyParseResult<WebhookTriggerGrantBody>;
+declare function parseEgressGrantConsumeBody(body: unknown): EgressGrantBodyParseResult<EgressGrantConsumeBody>;
+declare function parseEgressGrantAuditBody(body: unknown): EgressGrantBodyParseResult<EgressGrantAuditBody>;
+declare function parseEgressGrantData(data: unknown): ContractParseResult<EgressGrant<unknown>>;
+declare function parseEgressGrantConsumeData(data: unknown): ContractParseResult<{
+    consumed: true;
+}>;
+
+declare const FLOW_RUN_RUNTIME_CREDENTIAL_ROUTE_SUBPATH = "/:flowRunId/runtime-credential";
+declare const TOOL_INVOCATION_RUNTIME_CREDENTIAL_ROUTE_SUBPATH = "/:invocationId/runtime-credential";
+declare const POLLING_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH = "/:pollingInstanceId/runtime-credential";
+declare const WEBHOOK_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH = "/:triggerInstanceId/runtime-credential";
+declare const flowRunRuntimeCredentialPath: (flowRunId: string) => string;
+declare const toolInvocationRuntimeCredentialPath: (invocationId: string) => string;
+declare const pollingTriggerRuntimeCredentialPath: (pollingInstanceId: string) => string;
+declare const webhookTriggerRuntimeCredentialPath: (triggerInstanceId: string) => string;
+declare const RUNTIME_CREDENTIAL_SESSION_SCOPE_KINDS: readonly ["flow_action", "tool_invoke", "polling_trigger", "webhook_trigger"];
+type RuntimeCredentialSessionScopeKind = (typeof RUNTIME_CREDENTIAL_SESSION_SCOPE_KINDS)[number];
+type RuntimeCredentialSessionNetwork = {
+    networkModel: "managed_plus_unmanaged_sdk";
+    apiHosts: string[];
+    authHosts: string[];
+    httpsOnly: true;
+};
+type RuntimeCredentialSession<TCredential = unknown> = {
+    sessionId: string;
+    scopeKind: RuntimeCredentialSessionScopeKind;
+    scopeId: string;
+    workspaceId: string;
+    installationId: string;
+    artifactDigest: string;
+    descriptorHash: string;
+    connectionId: string;
+    connectionRef: string;
+    authType: string;
+    credential: TCredential;
+    network: RuntimeCredentialSessionNetwork;
+    expiresAt: string;
+};
+type FlowRuntimeCredentialBody = {
+    nodeId: string;
+};
+type PollingRuntimeCredentialBody = {
+    tickId: string;
+};
+type WebhookRuntimeCredentialBody = {
+    executionKind: "event_handler" | "lifecycle";
+    deliveryId?: string;
+    lifecycleOperation?: "enable" | "disable" | "renew";
+};
+declare function parseFlowRuntimeCredentialBody(body: unknown): ContractParseResult<FlowRuntimeCredentialBody>;
+declare function parseSingleToolRuntimeCredentialBody(body: unknown): ContractParseResult<null>;
+declare function parsePollingRuntimeCredentialBody(body: unknown): ContractParseResult<PollingRuntimeCredentialBody>;
+declare function parseWebhookRuntimeCredentialBody(body: unknown): ContractParseResult<WebhookRuntimeCredentialBody>;
+declare function parseRuntimeCredentialSessionCredential(data: unknown): ContractParseResult<Record<string, unknown>>;
+
+declare const WORKSPACE_FILES_ROUTE_PREFIX = "/workspaces/:workspaceId/files";
+type FileAccessIntent = "preview" | "download" | "text";
+type FileRefData = {
+    file_id: string;
+    name: string;
+    mime_type?: string;
+    size_bytes: number;
+    created_at: string;
+    expires_at: string;
+    sha256?: string;
+    source?: string;
+};
+type PresignedFileUrlData = {
+    method: "GET" | "PUT";
+    url: string;
+    headers: Record<string, string>;
+    expires_at: string;
+};
+type FileUploadSessionData = {
+    file: FileRefData;
+    upload: PresignedFileUrlData;
+};
+type FileAccessData = {
+    file: FileRefData;
+    access: PresignedFileUrlData;
+    intent: FileAccessIntent;
+};
+declare const workspaceFileUploadSessionPath: (workspaceId: string) => string;
+declare const workspaceFileCompletePath: (workspaceId: string, fileId: string) => string;
+declare const workspaceFileMetadataPath: (workspaceId: string, fileId: string) => string;
+declare const workspaceFileAccessPath: (workspaceId: string, fileId: string, intent: FileAccessIntent) => string;
+declare function parseFileRefData(data: unknown): ContractParseResult<FileRefData>;
+declare function parseFileUploadSessionData(data: unknown): ContractParseResult<FileUploadSessionData>;
+declare function parseFileAccessData(data: unknown): ContractParseResult<FileAccessData>;
+
+declare const INTERNAL_FILES_ROUTE_PREFIX = "/internal/files";
+declare const FILE_UPLOAD_SESSION_ROUTE_SUBPATH = "/upload-session";
+declare const FILE_COMPLETE_ROUTE_SUBPATH = "/:fileId/complete";
+declare const FILE_ACCESS_ROUTE_SUBPATH = "/:fileId/access";
+declare const FILE_STAT_ROUTE_SUBPATH = "/:fileId/stat";
+declare const FILE_CONTENT_ROUTE_SUBPATH = "/:fileId/content";
+type FileRuntimeScopeKind = "flow_run" | "tool_invocation";
+type FileRuntimeScope = {
+    scopeKind: FileRuntimeScopeKind;
+    scopeId: string;
+};
+type InternalFileAccessIntent = "runtime_read" | "provider_multipart";
+type InternalFileAccessData = {
+    file: FileRefData;
+    access: PresignedFileUrlData;
+    intent: InternalFileAccessIntent;
+};
+declare const internalFilesPath: () => string;
+declare const internalFileUploadSessionPath: () => string;
+declare const internalFileCompletePath: (fileId: string) => string;
+declare const internalFileAccessPath: (fileId: string, intent: InternalFileAccessIntent) => string;
+declare const internalFileStatPath: (fileId: string, scope: FileRuntimeScope) => string;
+declare const internalFileContentPath: (fileId: string, scope: FileRuntimeScope) => string;
+
+declare function parseInternalFileAccessData(data: unknown): ContractParseResult<InternalFileAccessData>;
+
+declare const HUMAN_INPUTS_ROUTE_SUBPATH = "/:flowRunId/human-inputs";
+declare const HUMAN_INPUT_REQUEST_ROUTE_SUBPATH = "/:flowRunId/human-inputs/:requestId";
+declare const HUMAN_INPUT_EXPIRE_ROUTE_SUBPATH = "/:flowRunId/human-inputs/:requestId/expire";
+declare const HUMAN_INPUT_ACKNOWLEDGE_ROUTE_SUBPATH = "/:flowRunId/human-inputs/:requestId/acknowledge";
+declare const humanInputsPath: (flowRunId: string) => string;
+declare const humanInputRequestPath: (flowRunId: string, requestId: string) => string;
+declare const humanInputExpirePath: (flowRunId: string, requestId: string) => string;
+declare const humanInputAcknowledgePath: (flowRunId: string, requestId: string) => string;
+declare const HUMAN_INPUT_RESOLVED_EVENT_PREFIX = "human_input_resolved";
+declare function humanInputResolvedEventType(requestId: string): string;
+type HumanInputResolvedEvent = {
+    requestId: string;
+    flowRunId: string;
+    nodeId: string;
+    status: "submitted" | "expired";
+};
+type RenderedHumanInputPrompt = {
+    title: string;
+    body?: string;
+    format?: "plain" | "markdown";
+};
+type PartiallyRenderedValue = {
+    kind: "literal";
+    value: unknown;
+} | {
+    kind: "array";
+    items: PartiallyRenderedValue[];
+} | {
+    kind: "object";
+    entries: Record<string, PartiallyRenderedValue>;
+} | {
+    kind: "human_input_ref";
+    path: string;
+} | {
+    kind: "template";
+    parts: PartiallyRenderedTemplatePart[];
+};
+type PartiallyRenderedTemplatePart = {
+    kind: "literal";
+    value: string;
+} | {
+    kind: "human_input_ref";
+    path: string;
+};
+type PartiallyRenderedMapping = Record<string, PartiallyRenderedValue>;
+type PartiallyRenderedHumanInputDelivery = {
+    actions?: Array<{
+        id: string;
+        inputs: PartiallyRenderedMapping;
+    }>;
+};
+type CreateHumanInputRequestBody = {
+    nodeId: string;
+    renderedPrompt: RenderedHumanInputPrompt;
+    input: HumanInputSpec;
+    partiallyRenderedDelivery?: PartiallyRenderedHumanInputDelivery;
+    timeout: string;
+    expiresAt: string;
+};
+type HumanInputResponse = {
+    kind: "choice";
+    choiceId: string;
+    comment?: string;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "form";
+    values: Record<string, unknown>;
+};
+type HumanInputActor = {
+    type: "user";
+    userId: string;
+} | {
+    type: "api_key";
+    apiKeyId: string;
+} | {
+    type: "anonymous";
+} | {
+    type: "provider";
+    provider: string;
+    providerActorId?: string;
+} | {
+    type: "system";
+};
+type HumanInputOutput = {
+    status: "submitted";
+    response: HumanInputResponse;
+    actor: Exclude<HumanInputActor, {
+        type: "system";
+    }>;
+    submissionSource: string;
+    submittedAt: string;
+} | {
+    status: "expired";
+    actor: {
+        type: "system";
+    };
+    expiredAt: string;
+};
+type HumanInputRequestView = {
+    id: string;
+    workspaceId: string;
+    flowRunId: string;
+    nodeId: string;
+    status: "pending" | "submitted" | "expired" | "cancelled";
+    inputKind: string;
+    timeout: string;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+    output: HumanInputOutput | null;
+};
+declare function parseCreateHumanInputBody(body: unknown): ContractParseResult<CreateHumanInputRequestBody>;
+declare function parseHumanInputRequestViewData(data: unknown): ContractParseResult<HumanInputRequestView>;
+declare function parseHumanInputCreateData(data: unknown): ContractParseResult<{
+    created: boolean;
+    request: HumanInputRequestView;
+}>;
+declare function parseHumanInputAcknowledgeData(data: unknown): ContractParseResult<{
+    acknowledged: true;
+}>;
+
+declare const WFP_USER_RUNTIME_MANIFEST_FORMAT_VERSION = "ablehi-wfp-user-runtime-manifest/v1";
+type WfpUserRuntimeManifest = {
+    formatVersion: typeof WFP_USER_RUNTIME_MANIFEST_FORMAT_VERSION;
+    runtimeContractVersion: string;
+    sha256: string;
+    sourceRevision: string;
+};
+declare const WFP_USER_RUNTIME_UNKNOWN_SOURCE_REVISION = "unknown";
+declare function wfpUserRuntimeManifestPath(bundlePath: string): string;
+
+declare const DEPLOYMENT_HANDSHAKE_ROUTE = "/internal/deployment-handshake";
+type DeploymentHandshakeRequestBody = {
+    nonce: string;
+    timestamp: string;
+    contractVersion: string;
+    dispatchNamespace: string;
+    probe: string;
+};
+type DeploymentHandshakeData = {
+    nonce: string;
+    contractVersion: string;
+    dispatchNamespace: string;
+    capabilities: string[];
+    proof: string;
+};
+type DeploymentHandshakeResponse = {
+    ok: true;
+    data: DeploymentHandshakeData;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+declare const DEPLOYMENT_HANDSHAKE_DISPATCHER_CAPABILITIES: readonly ["start", "terminate", "send-event", "start-webhook-watcher", "run-polling-tick", "invoke-tool", "invoke-trigger-handler", "invoke-webhook-protocol-adapter", "deployment-handshake"];
+declare const DEPLOYMENT_HANDSHAKE_REQUIRED_CAPABILITIES: readonly ["start", "terminate", "send-event", "start-webhook-watcher", "run-polling-tick", "invoke-tool", "invoke-trigger-handler", "invoke-webhook-protocol-adapter", "deployment-handshake"];
+declare const HANDSHAKE_REQUEST_INVALID = "HANDSHAKE_REQUEST_INVALID";
+declare const HANDSHAKE_SECRET_UNCONFIGURED = "HANDSHAKE_SECRET_UNCONFIGURED";
+declare const HANDSHAKE_SECRET_MISMATCH = "HANDSHAKE_SECRET_MISMATCH";
+declare const HANDSHAKE_CONTRACT_VERSION_MISMATCH = "HANDSHAKE_CONTRACT_VERSION_MISMATCH";
+declare const HANDSHAKE_DISPATCH_NAMESPACE_MISMATCH = "HANDSHAKE_DISPATCH_NAMESPACE_MISMATCH";
+declare const HANDSHAKE_CAPABILITY_MISSING = "HANDSHAKE_CAPABILITY_MISSING";
+declare function deploymentHandshakeProbePayload(input: {
+    nonce: string;
+    timestamp: string;
+    contractVersion: string;
+    dispatchNamespace: string;
+}): string;
+declare function deploymentHandshakeResponseProofPayload(input: {
+    nonce: string;
+    contractVersion: string;
+    dispatchNamespace: string;
+    capabilities: string[];
+}): string;
+
+export { type FileAccessIntent as $, type AblehiEnvelope as A, type BooleanExpression as B, CONTEXT_STATE_CLEANUP_ROUTE_PATH as C, DEPLOYMENT_HANDSHAKE_DISPATCHER_CAPABILITIES as D, EGRESS_GRANT_AUDIT_ROUTE_SUBPATH as E, type FlowNode as F, type EgressGrantConsumeBody as G, type EgressGrantFileRuntime as H, type EgressGrantScopeKind as I, type JsonValue as J, type ExecutionBinding as K, type ExecutionBindingConnection as L, type Mapping as M, type ExecutionContextCompiled as N, type ExecutionContextData as O, FILE_ACCESS_ROUTE_SUBPATH as P, FILE_COMPLETE_ROUTE_SUBPATH as Q, FILE_CONTENT_ROUTE_SUBPATH as R, FILE_STAT_ROUTE_SUBPATH as S, type TriggerBinding as T, FILE_UPLOAD_SESSION_ROUTE_SUBPATH as U, FLOW_INTERPRETER_CONTRACT_VERSION as V, FLOW_IR_SCHEMA_VERSION as W, FLOW_RUN_EGRESS_GRANT_ROUTE_SUBPATH as X, FLOW_RUN_RESULT_ROUTE_SUBPATH as Y, FLOW_RUN_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as Z, type FileAccessData as _, type FlowIrValidationResult as a, POLLING_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as a$, type FileRefData as a0, type FileRuntimeLimits as a1, type FileRuntimeScope as a2, type FileRuntimeScopeKind as a3, type FileUploadSessionData as a4, type FlowActionGrantBody as a5, type FlowDefinition as a6, type FlowExecutionContextFileRuntime as a7, type FlowInterpreterContractVersion as a8, type FlowIrValidationCode as a9, type HumanInputDeliveryAction as aA, type HumanInputNode as aB, type HumanInputOutput as aC, type HumanInputPrompt as aD, type HumanInputRequestView as aE, type HumanInputResolvedEvent as aF, type HumanInputResponse as aG, type HumanInputSpec as aH, type HumanTextInput as aI, INTERNAL_EGRESS_GRANTS_ROUTE_PREFIX as aJ, INTERNAL_FILES_ROUTE_PREFIX as aK, INTERNAL_FLOW_RUNS_ROUTE_PREFIX as aL, INTERNAL_FLOW_VERSIONS_ROUTE_PREFIX as aM, INTERNAL_INSTALLATIONS_ROUTE_PREFIX as aN, INTERNAL_POLLING_TRIGGER_INSTANCES_ROUTE_PREFIX as aO, INTERNAL_TOOL_INVOCATIONS_ROUTE_PREFIX as aP, INTERNAL_WEBHOOK_TRIGGER_INSTANCES_ROUTE_PREFIX as aQ, type IntegrationTriggerBinding as aR, type InternalFileAccessData as aS, type InternalFileAccessIntent as aT, type JsonArray as aU, type ManualTriggerBinding as aV, type NodeCommon as aW, type Operand as aX, POLLING_TRIGGER_CONTEXT_ROUTE_SUBPATH as aY, POLLING_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH as aZ, POLLING_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH as a_, type FlowIrValidationIssue as aa, type FlowRunResultData as ab, type FlowRunResultRequestBody as ac, type FlowRuntimeCredentialBody as ad, HANDLER_BUNDLES_ROUTE_SUBPATH as ae, HANDSHAKE_CAPABILITY_MISSING as af, HANDSHAKE_CONTRACT_VERSION_MISMATCH as ag, HANDSHAKE_DISPATCH_NAMESPACE_MISMATCH as ah, HANDSHAKE_REQUEST_INVALID as ai, HANDSHAKE_SECRET_MISMATCH as aj, HANDSHAKE_SECRET_UNCONFIGURED as ak, HUMAN_INPUTS_ROUTE_SUBPATH as al, HUMAN_INPUT_ACKNOWLEDGE_ROUTE_SUBPATH as am, HUMAN_INPUT_EXPIRE_ROUTE_SUBPATH as an, HUMAN_INPUT_REQUEST_ROUTE_SUBPATH as ao, HUMAN_INPUT_RESOLVED_EVENT_PREFIX as ap, type HandlerBundle as aq, type HandlerBundleModule as ar, type HandlerBundlesData as as, type HandlerBundlesParseResult as at, type HumanChoiceInput as au, type HumanFormField as av, type HumanFormInput as aw, type HumanInputActor as ax, type HumanInputChoice as ay, type HumanInputDelivery as az, type JsonObject as b, type WebhookPublishEventsData as b$, POLLING_TRIGGER_TICK_EVENTS_ROUTE_SUBPATH as b0, type PackagePollingTriggerRuntimeDescriptor as b1, type PackageWebhookTriggerRuntimeDescriptor as b2, type ParsedFlowRunResultBody as b3, type PartiallyRenderedHumanInputDelivery as b4, type PartiallyRenderedMapping as b5, type PartiallyRenderedTemplatePart as b6, type PartiallyRenderedValue as b7, type PollingPublishBody as b8, type PollingPublishEvent as b9, TOOL_HANDLER_BUNDLES_ROUTE_SUBPATH as bA, TOOL_INVOCATION_EGRESS_GRANT_ROUTE_SUBPATH as bB, TOOL_INVOCATION_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as bC, type TextExpression as bD, type ToolHandlerBundlesData as bE, type TriggerConnectionInfo as bF, type TriggerHandlerBundlesData as bG, type TriggerHandlerModule as bH, type ValueExpression as bI, WEBHOOK_PROTOCOL_ADAPTER_BUNDLE_ROUTE_SUBPATH as bJ, WEBHOOK_PROTOCOL_ADAPTER_MODULE as bK, WEBHOOK_TRIGGER_CONTEXT_ROUTE_SUBPATH as bL, WEBHOOK_TRIGGER_DELIVERY_ROUTE_SUBPATH as bM, WEBHOOK_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH as bN, WEBHOOK_TRIGGER_EVENTS_ROUTE_SUBPATH as bO, WEBHOOK_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH as bP, WEBHOOK_TRIGGER_REARM_ROUTE_SUBPATH as bQ, WEBHOOK_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as bR, WFP_USER_RUNTIME_MANIFEST_FORMAT_VERSION as bS, WFP_USER_RUNTIME_UNKNOWN_SOURCE_REVISION as bT, WORKSPACE_FILES_ROUTE_PREFIX as bU, type WaitEventNode as bV, type WebhookDelivery as bW, type WebhookProtocolAdapterBundleData as bX, type WebhookProtocolAdapterModule as bY, type WebhookPublishEvent as bZ, type WebhookPublishEventsBody as b_, type PollingRuntimeCredentialBody as ba, type PollingTriggerContext as bb, type PollingTriggerGrantBody as bc, type PresignedFileUrlData as bd, type PublishPollingTickEventResult as be, type PublishPollingTickEventsData as bf, RUNTIME_CREDENTIAL_SESSION_SCOPE_KINDS as bg, type RegisterFlowRunWaitBody as bh, type RegisterFlowRunWaitData as bi, type RenderedFlowComposition as bj, type RenderedHumanInputPrompt as bk, type RuntimeCredentialSession as bl, type RuntimeCredentialSessionNetwork as bm, type RuntimeCredentialSessionScopeKind as bn, type RuntimeNetwork as bo, type RuntimeNetworkModel as bp, SERVER_CONTRACT_VERSION as bq, STEP_RESULT_ROUTE_SUBPATH as br, type ScheduleTriggerBinding as bs, type ServerContractVersion as bt, type SingleToolGrantBody as bu, type SleepNode as bv, type StepRecordBody as bw, type StepRecordBodyParseResult as bx, type StepRecordData as by, type StepRecordResult as bz, type FlowCompositionSpec as c, parseRegisterFlowRunWaitData as c$, type WebhookRearmBody as c0, type WebhookRearmData as c1, type WebhookRuntimeCredentialBody as c2, type WebhookTriggerGrantBody as c3, type WebhookTriggerVerificationMethod as c4, type WebhookWatcherContext as c5, type WfpUserRuntimeManifest as c6, contractParseFail as c7, contractParseOk as c8, deploymentHandshakeProbePayload as c9, parseContextStateScope as cA, parseCreateHumanInputBody as cB, parseEgressGrantAuditBody as cC, parseEgressGrantConsumeBody as cD, parseEgressGrantConsumeData as cE, parseEgressGrantData as cF, parseExecutionContextData as cG, parseFileAccessData as cH, parseFileRefData as cI, parseFileRuntimeLimits as cJ, parseFileUploadSessionData as cK, parseFlowActionGrantBody as cL, parseFlowRunResultBody as cM, parseFlowRunResultData as cN, parseFlowRuntimeCredentialBody as cO, parseHandlerBundle as cP, parseHandlerBundlesData as cQ, parseHumanInputAcknowledgeData as cR, parseHumanInputCreateData as cS, parseHumanInputRequestViewData as cT, parseInternalFileAccessData as cU, parsePollingPublishBody as cV, parsePollingRuntimeCredentialBody as cW, parsePollingTriggerContext as cX, parsePollingTriggerGrantBody as cY, parsePublishPollingTickEventsData as cZ, parseRegisterFlowRunWaitBody as c_, deploymentHandshakeResponseProofPayload as ca, egressGrantAuditPath as cb, egressGrantConsumePath as cc, eventWaitPath as cd, executionContextPath as ce, flowRunEgressGrantPath as cf, flowRunResultPath as cg, flowRunRuntimeCredentialPath as ch, flowScriptProtocolAdapterModuleName as ci, handlerBundlesPath as cj, humanInputAcknowledgePath as ck, humanInputExpirePath as cl, humanInputRequestPath as cm, humanInputResolvedEventType as cn, humanInputsPath as co, internalFileAccessPath as cp, internalFileCompletePath as cq, internalFileContentPath as cr, internalFileStatPath as cs, internalFileUploadSessionPath as ct, internalFilesPath as cu, isJsonRecord as cv, isValidRequestDigest as cw, parseCompleteFlowRunWaitBody as cx, parseContextStateCleanupRequestBody as cy, parseContextStateCleanupResponseData as cz, type AblehiFailure as d, parseRuntimeCredentialSessionCredential as d0, parseRuntimeNetwork as d1, parseSingleToolGrantBody as d2, parseSingleToolRuntimeCredentialBody as d3, parseStepRecordBody as d4, parseStepRecordData as d5, parseToolHandlerBundlesData as d6, parseTriggerHandlerBundlesData as d7, parseWebhookDelivery as d8, parseWebhookPublishEventsBody as d9, workspaceFileMetadataPath as dA, workspaceFileUploadSessionPath as dB, parseWebhookRearmBody as da, parseWebhookRuntimeCredentialBody as db, parseWebhookTriggerGrantBody as dc, parseWebhookWatcherContext as dd, pollingTriggerContextPath as de, pollingTriggerEgressGrantPath as df, pollingTriggerHandlerBundlesPath as dg, pollingTriggerRuntimeCredentialPath as dh, pollingTriggerTickEventsPath as di, requestHasMultipartFileParts as dj, stepResultPath as dk, toolHandlerBundlesPath as dl, toolInvocationEgressGrantPath as dm, toolInvocationRuntimeCredentialPath as dn, webhookProtocolAdapterBundlePath as dp, webhookTriggerContextPath as dq, webhookTriggerDeliveryPath as dr, webhookTriggerEgressGrantPath as ds, webhookTriggerEventsPath as dt, webhookTriggerHandlerBundlesPath as du, webhookTriggerRearmPath as dv, webhookTriggerRuntimeCredentialPath as dw, wfpUserRuntimeManifestPath as dx, workspaceFileAccessPath as dy, workspaceFileCompletePath as dz, type AblehiSuccess as e, type ActionNode as f, type Collection as g, type CompleteFlowRunWaitBody as h, type CompleteFlowRunWaitData as i, type ContextStateCleanupRequestBody as j, type ContextStateCleanupResponseData as k, type ContextStateScope as l, type ContractParseResult as m, type CreateHumanInputRequestBody as n, DEPLOYMENT_HANDSHAKE_REQUIRED_CAPABILITIES as o, DEPLOYMENT_HANDSHAKE_ROUTE as p, type DeploymentHandshakeData as q, type DeploymentHandshakeRequestBody as r, type DeploymentHandshakeResponse as s, EGRESS_GRANT_CONSUME_ROUTE_SUBPATH as t, EGRESS_GRANT_SCOPE_KINDS as u, EVENT_WAIT_ROUTE_SUBPATH as v, EXECUTION_CONTEXT_ROUTE_SUBPATH as w, type EgressGrant as x, type EgressGrantAuditBody as y, type EgressGrantBodyParseResult as z };