@ablehi/server-contract 0.2.1 → 0.2.3

package/dist/edge-BTl-jgfc.d.ts

@@ -0,0 +1,949 @@
+declare const SERVER_CONTRACT_VERSION = "0.2.3";
+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 INTERNAL_FILES_ROUTE_PREFIX = "/internal/files";
+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 FileRefData = {
+    file_id: string;
+    name: string;
+    mime_type?: string;
+    size_bytes: number;
+    created_at: string;
+    expires_at: string;
+    sha256?: string;
+    source?: string;
+};
+declare const internalFilesPath: () => string;
+declare const internalFileStatPath: (fileId: string, scope: FileRuntimeScope) => string;
+declare const internalFileContentPath: (fileId: string, scope: FileRuntimeScope) => string;
+declare function parseFileRefData(data: unknown): ContractParseResult<FileRefData>;
+
+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 FlowActionGrantBody 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_CONTENT_ROUTE_SUBPATH as P, FILE_STAT_ROUTE_SUBPATH as Q, FLOW_INTERPRETER_CONTRACT_VERSION as R, FLOW_IR_SCHEMA_VERSION as S, type TriggerBinding as T, FLOW_RUN_EGRESS_GRANT_ROUTE_SUBPATH as U, FLOW_RUN_RESULT_ROUTE_SUBPATH as V, FLOW_RUN_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as W, type FileRefData as X, type FileRuntimeLimits as Y, type FileRuntimeScope as Z, type FileRuntimeScopeKind as _, type FlowIrValidationResult as a, type PartiallyRenderedValue as a$, type FlowDefinition as a0, type FlowExecutionContextFileRuntime as a1, type FlowInterpreterContractVersion as a2, type FlowIrValidationCode as a3, type FlowIrValidationIssue as a4, type FlowRunResultData as a5, type FlowRunResultRequestBody as a6, type FlowRuntimeCredentialBody as a7, HANDLER_BUNDLES_ROUTE_SUBPATH as a8, HANDSHAKE_CAPABILITY_MISSING as a9, type HumanInputResponse as aA, type HumanInputSpec as aB, type HumanTextInput as aC, INTERNAL_EGRESS_GRANTS_ROUTE_PREFIX as aD, INTERNAL_FILES_ROUTE_PREFIX as aE, INTERNAL_FLOW_RUNS_ROUTE_PREFIX as aF, INTERNAL_FLOW_VERSIONS_ROUTE_PREFIX as aG, INTERNAL_INSTALLATIONS_ROUTE_PREFIX as aH, INTERNAL_POLLING_TRIGGER_INSTANCES_ROUTE_PREFIX as aI, INTERNAL_TOOL_INVOCATIONS_ROUTE_PREFIX as aJ, INTERNAL_WEBHOOK_TRIGGER_INSTANCES_ROUTE_PREFIX as aK, type IntegrationTriggerBinding as aL, type JsonArray as aM, type ManualTriggerBinding as aN, type NodeCommon as aO, type Operand as aP, POLLING_TRIGGER_CONTEXT_ROUTE_SUBPATH as aQ, POLLING_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH as aR, POLLING_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH as aS, POLLING_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as aT, POLLING_TRIGGER_TICK_EVENTS_ROUTE_SUBPATH as aU, type PackagePollingTriggerRuntimeDescriptor as aV, type PackageWebhookTriggerRuntimeDescriptor as aW, type ParsedFlowRunResultBody as aX, type PartiallyRenderedHumanInputDelivery as aY, type PartiallyRenderedMapping as aZ, type PartiallyRenderedTemplatePart as a_, HANDSHAKE_CONTRACT_VERSION_MISMATCH as aa, HANDSHAKE_DISPATCH_NAMESPACE_MISMATCH as ab, HANDSHAKE_REQUEST_INVALID as ac, HANDSHAKE_SECRET_MISMATCH as ad, HANDSHAKE_SECRET_UNCONFIGURED as ae, HUMAN_INPUTS_ROUTE_SUBPATH as af, HUMAN_INPUT_ACKNOWLEDGE_ROUTE_SUBPATH as ag, HUMAN_INPUT_EXPIRE_ROUTE_SUBPATH as ah, HUMAN_INPUT_REQUEST_ROUTE_SUBPATH as ai, HUMAN_INPUT_RESOLVED_EVENT_PREFIX as aj, type HandlerBundle as ak, type HandlerBundleModule as al, type HandlerBundlesData as am, type HandlerBundlesParseResult as an, type HumanChoiceInput as ao, type HumanFormField as ap, type HumanFormInput as aq, type HumanInputActor as ar, type HumanInputChoice as as, type HumanInputDelivery as at, type HumanInputDeliveryAction as au, type HumanInputNode as av, type HumanInputOutput as aw, type HumanInputPrompt as ax, type HumanInputRequestView as ay, type HumanInputResolvedEvent as az, type JsonObject as b, deploymentHandshakeProbePayload as b$, type PollingPublishBody as b0, type PollingPublishEvent as b1, type PollingRuntimeCredentialBody as b2, type PollingTriggerContext as b3, type PollingTriggerGrantBody as b4, type PublishPollingTickEventResult as b5, type PublishPollingTickEventsData as b6, RUNTIME_CREDENTIAL_SESSION_SCOPE_KINDS as b7, type RegisterFlowRunWaitBody as b8, type RegisterFlowRunWaitData as b9, WEBHOOK_PROTOCOL_ADAPTER_BUNDLE_ROUTE_SUBPATH as bA, WEBHOOK_PROTOCOL_ADAPTER_MODULE as bB, WEBHOOK_TRIGGER_CONTEXT_ROUTE_SUBPATH as bC, WEBHOOK_TRIGGER_DELIVERY_ROUTE_SUBPATH as bD, WEBHOOK_TRIGGER_EGRESS_GRANT_ROUTE_SUBPATH as bE, WEBHOOK_TRIGGER_EVENTS_ROUTE_SUBPATH as bF, WEBHOOK_TRIGGER_HANDLER_BUNDLES_ROUTE_SUBPATH as bG, WEBHOOK_TRIGGER_REARM_ROUTE_SUBPATH as bH, WEBHOOK_TRIGGER_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as bI, WFP_USER_RUNTIME_MANIFEST_FORMAT_VERSION as bJ, WFP_USER_RUNTIME_UNKNOWN_SOURCE_REVISION as bK, type WaitEventNode as bL, type WebhookDelivery as bM, type WebhookProtocolAdapterBundleData as bN, type WebhookProtocolAdapterModule as bO, type WebhookPublishEvent as bP, type WebhookPublishEventsBody as bQ, type WebhookPublishEventsData as bR, type WebhookRearmBody as bS, type WebhookRearmData as bT, type WebhookRuntimeCredentialBody as bU, type WebhookTriggerGrantBody as bV, type WebhookTriggerVerificationMethod as bW, type WebhookWatcherContext as bX, type WfpUserRuntimeManifest as bY, contractParseFail as bZ, contractParseOk as b_, type RenderedFlowComposition as ba, type RenderedHumanInputPrompt as bb, type RuntimeCredentialSession as bc, type RuntimeCredentialSessionNetwork as bd, type RuntimeCredentialSessionScopeKind as be, type RuntimeNetwork as bf, type RuntimeNetworkModel as bg, SERVER_CONTRACT_VERSION as bh, STEP_RESULT_ROUTE_SUBPATH as bi, type ScheduleTriggerBinding as bj, type ServerContractVersion as bk, type SingleToolGrantBody as bl, type SleepNode as bm, type StepRecordBody as bn, type StepRecordBodyParseResult as bo, type StepRecordData as bp, type StepRecordResult as bq, TOOL_HANDLER_BUNDLES_ROUTE_SUBPATH as br, TOOL_INVOCATION_EGRESS_GRANT_ROUTE_SUBPATH as bs, TOOL_INVOCATION_RUNTIME_CREDENTIAL_ROUTE_SUBPATH as bt, type TextExpression as bu, type ToolHandlerBundlesData as bv, type TriggerConnectionInfo as bw, type TriggerHandlerBundlesData as bx, type TriggerHandlerModule as by, type ValueExpression as bz, type FlowCompositionSpec as c, pollingTriggerEgressGrantPath as c$, deploymentHandshakeResponseProofPayload as c0, egressGrantAuditPath as c1, egressGrantConsumePath as c2, eventWaitPath as c3, executionContextPath as c4, flowRunEgressGrantPath as c5, flowRunResultPath as c6, flowRunRuntimeCredentialPath as c7, flowScriptProtocolAdapterModuleName as c8, handlerBundlesPath as c9, parseHandlerBundle as cA, parseHandlerBundlesData as cB, parseHumanInputAcknowledgeData as cC, parseHumanInputCreateData as cD, parseHumanInputRequestViewData as cE, parsePollingPublishBody as cF, parsePollingRuntimeCredentialBody as cG, parsePollingTriggerContext as cH, parsePollingTriggerGrantBody as cI, parsePublishPollingTickEventsData as cJ, parseRegisterFlowRunWaitBody as cK, parseRegisterFlowRunWaitData as cL, parseRuntimeCredentialSessionCredential as cM, parseRuntimeNetwork as cN, parseSingleToolGrantBody as cO, parseSingleToolRuntimeCredentialBody as cP, parseStepRecordBody as cQ, parseStepRecordData as cR, parseToolHandlerBundlesData as cS, parseTriggerHandlerBundlesData as cT, parseWebhookDelivery as cU, parseWebhookPublishEventsBody as cV, parseWebhookRearmBody as cW, parseWebhookRuntimeCredentialBody as cX, parseWebhookTriggerGrantBody as cY, parseWebhookWatcherContext as cZ, pollingTriggerContextPath as c_, humanInputAcknowledgePath as ca, humanInputExpirePath as cb, humanInputRequestPath as cc, humanInputResolvedEventType as cd, humanInputsPath as ce, internalFileContentPath as cf, internalFileStatPath as cg, internalFilesPath as ch, isJsonRecord as ci, isValidRequestDigest as cj, parseCompleteFlowRunWaitBody as ck, parseContextStateCleanupRequestBody as cl, parseContextStateCleanupResponseData as cm, parseContextStateScope as cn, parseCreateHumanInputBody as co, parseEgressGrantAuditBody as cp, parseEgressGrantConsumeBody as cq, parseEgressGrantConsumeData as cr, parseEgressGrantData as cs, parseExecutionContextData as ct, parseFileRefData as cu, parseFileRuntimeLimits as cv, parseFlowActionGrantBody as cw, parseFlowRunResultBody as cx, parseFlowRunResultData as cy, parseFlowRuntimeCredentialBody as cz, type AblehiFailure as d, pollingTriggerHandlerBundlesPath as d0, pollingTriggerRuntimeCredentialPath as d1, pollingTriggerTickEventsPath as d2, requestHasMultipartFileParts as d3, stepResultPath as d4, toolHandlerBundlesPath as d5, toolInvocationEgressGrantPath as d6, toolInvocationRuntimeCredentialPath as d7, webhookProtocolAdapterBundlePath as d8, webhookTriggerContextPath as d9, webhookTriggerDeliveryPath as da, webhookTriggerEgressGrantPath as db, webhookTriggerEventsPath as dc, webhookTriggerHandlerBundlesPath as dd, webhookTriggerRearmPath as de, webhookTriggerRuntimeCredentialPath as df, wfpUserRuntimeManifestPath as dg, 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 };