@oomol-lab/open-flow 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/common/control-api-errors.d.ts

@@ -5,9 +5,16 @@ export declare const controlErrorCode: {
     readonly connectorActionNotFound: 'connector.action-not-found';
     readonly connectorUnconfigured: 'connector.unconfigured';
     readonly connectorUnavailable: 'connector.unavailable';
+    readonly connectorConsoleUnconfigured: 'connector.console-unconfigured';
     readonly engineUnavailable: 'engine.unavailable';
     readonly engineUnsupported: 'engine.unsupported';
+    readonly eventSourceInvalid: 'event-source.invalid';
+    readonly eventSourceIdentityUnavailable: 'event-source.identity-unavailable';
+    readonly eventSourceNotFound: 'event-source.not-found';
+    readonly eventSourceConflict: 'event-source.conflict';
     readonly flowInvalid: 'flow.invalid';
+    readonly flowRepairRequired: 'flow.repair-required';
+    readonly flowUpgradeRequired: 'flow.upgrade-required';
     readonly flowNotFound: 'flow.not-found';
     readonly flowBusy: 'flow.busy';
     readonly flowConflict: 'flow.conflict';
@@ -27,6 +34,7 @@ export declare const controlErrorCode: {
     readonly runNotFound: 'run.not-found';
     readonly runNotTerminal: 'run.not-terminal';
     readonly runOverloaded: 'run.overloaded';
+    readonly runWaitNotFound: 'run.wait-not-found';
     readonly triggerKeyInvalid: 'trigger-key.invalid';
     readonly triggerKeyNotFound: 'trigger-key.not-found';
     readonly triggerNotFound: 'trigger.not-found';
@@ -36,6 +44,18 @@ export declare const controlErrorCode: {
 };
 export type ControlErrorCode = (typeof controlErrorCode)[keyof typeof controlErrorCode];
 export declare const controlErrorMetadata: {
+    readonly "event-source.invalid": {
+        readonly status: 400;
+    };
+    readonly "event-source.identity-unavailable": {
+        readonly status: 409;
+    };
+    readonly "event-source.not-found": {
+        readonly status: 404;
+    };
+    readonly "event-source.conflict": {
+        readonly status: 409;
+    };
     readonly "authentication.required": {
         readonly status: 401;
     };
@@ -54,6 +74,9 @@ export declare const controlErrorMetadata: {
     readonly "connector.unavailable": {
         readonly status: 503;
     };
+    readonly "connector.console-unconfigured": {
+        readonly status: 503;
+    };
     readonly "engine.unavailable": {
         readonly status: 503;
     };
@@ -63,6 +86,12 @@ export declare const controlErrorMetadata: {
     readonly "flow.invalid": {
         readonly status: 400;
     };
+    readonly "flow.repair-required": {
+        readonly status: 409;
+    };
+    readonly "flow.upgrade-required": {
+        readonly status: 409;
+    };
     readonly "flow.not-found": {
         readonly status: 404;
     };
@@ -120,6 +149,9 @@ export declare const controlErrorMetadata: {
     readonly "run.overloaded": {
         readonly status: 429;
     };
+    readonly "run.wait-not-found": {
+        readonly status: 404;
+    };
     readonly "trigger-key.invalid": {
         readonly status: 409;
     };
@@ -139,3 +171,8 @@ export declare const controlErrorMetadata: {
         readonly status: 404;
     };
 };
+export declare class ApiError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(status: number, code: string, message: string);
+}

package/dist/common/control-api.d.ts

@@ -1,11 +1,29 @@
+import type { DraftOperation } from './draftOperations.js';
+export { inspectFlowDraft } from './flowInspection.js';
+export type { DraftOperation } from './draftOperations.js';
+import type { SchemaMismatch } from '../browser/flow-change.js';
+import type { CreateEventSource, UpdateEventSource, EventSource } from './event-sources.js';
+export { decodeEventSource, decodeEventSources, type CreateEventSource, type UpdateEventSource, type EventSource } from './event-sources.js';
+import type { TriggerCatalogCache } from './trigger-catalog.js';
+export { decodeTriggerCatalog, type TriggerCatalog, type TriggerCatalogCache, type TriggerDisplay } from './trigger-catalog.js';
+import type { TriggerConfigOption } from './trigger-config-options.js';
+export type { TriggerConfigOption } from './trigger-config-options.js';
+import type { ResultQuery } from './run-results.js';
+import { decodeResultList, decodeResultRead } from './run-results.js';
+export { readResult, parseResultQuery, decodeResultList, decodeResultRead, type ResultCall, type ResultInfo, type ResultPage, type ResultQuery, } from './run-results.js';
 import type { RunStatus } from './run-lifecycle.js';
-import type { ChangeOperation, InputPortDefinition, JsonValue, PortDefinition, RevisionContent, TriggerKeySnapshot } from '../browser/flow-change.js';
-export type { JsonValue, TriggerKeySnapshot } from '../browser/flow-change.js';
+import type { InputPortDefinition, JsonValue, PortDefinition, RevisionContent, TriggerKeySnapshot, WaitAction } from '../browser/flow-change.js';
+export type { JsonValue, TriggerKeySnapshot, WaitAction } from '../browser/flow-change.js';
 export type { RunStatus } from './run-lifecycle.js';
-export { controlErrorCode, controlErrorMetadata, type ControlErrorCode } from './control-api-errors.js';
+export { ApiError, controlErrorCode, controlErrorMetadata, type ControlErrorCode } from './control-api-errors.js';
 export type { FlowCatalogEvent, FlowChangeEvent } from './flow-notifications.js';
 export type ControlRequest = (path: string, init?: RequestInit) => Promise<Response>;
 export interface Flow {
+    readonly live?: {
+        readonly enabled: boolean;
+        readonly publicationId: string;
+        readonly revisionId: string;
+    };
     readonly createdAt: string;
     readonly draftRevisionId: string;
     readonly flowId: string;
@@ -14,6 +32,12 @@ export interface Flow {
     readonly updatedAt: string;
     readonly version: 1;
 }
+export interface Presentation {
+    readonly revision: number;
+    readonly updatedAt: string;
+    readonly value: Readonly<Record<string, JsonValue>>;
+    readonly version: 1;
+}
 export interface FlowPage {
     readonly flows: readonly Flow[];
     readonly nextCursor?: string;
@@ -35,6 +59,10 @@ export interface TriggerKeySummary {
     readonly type: TriggerKeySnapshot['type'];
 }
 export interface TriggerBinding {
+    readonly listener?: {
+        readonly health: 'healthy' | 'failed' | 'needs_reauth';
+        readonly lastErrorCode?: string;
+    };
     readonly currentPublicationId?: string;
     readonly currentRevisionId?: string;
     readonly endpointUrl?: string;
@@ -72,17 +100,25 @@ export interface PollTriggerTestResult {
     readonly version: 1;
 }
 export interface ConnectorConnection {
+    readonly providerAccountId?: string;
+    readonly builtInAccount?: boolean;
+    readonly alias?: string;
     readonly connectionId: string;
     readonly displayName: string;
     readonly isDefault: boolean;
     readonly serviceId: string;
     readonly status: 'active' | 'disconnected' | 'error' | 'reauth_required';
 }
-export interface ConnectorAction {
+/** Action metadata independent of account availability and selection. */
+export interface ConnectorActionMetadata {
+    /** Upstream operation classification; unknown values remain uncategorized. */
+    readonly operationType?: string;
+    readonly inputSchema?: JsonValue;
+    readonly outputSchema?: JsonValue;
     readonly actionId: string;
     readonly authenticated: boolean;
-    readonly defaultConnection?: ConnectorConnection;
     readonly description: string;
+    readonly homepageUrl?: string;
     readonly icon?: string;
     readonly inputs: Readonly<Record<string, InputPortDefinition>>;
     readonly name: string;
@@ -90,7 +126,13 @@ export interface ConnectorAction {
     readonly serviceId: string;
     readonly serviceName: string;
 }
+/** Existing CLI/MCP representation, including the currently preferred account. */
+export interface ConnectorAction extends ConnectorActionMetadata {
+    readonly defaultConnection?: ConnectorConnection;
+}
 export interface ConnectorProvider {
+    readonly noSetup?: boolean;
+    readonly homepageUrl?: string;
     readonly icon?: string;
     readonly serviceId: string;
     readonly serviceName: string;
@@ -112,18 +154,11 @@ export interface DraftChange {
     readonly revision: RevisionMetadata;
     readonly version: 1;
 }
-export type DraftSync = {
-    readonly kind: 'changes';
-    readonly revisions: readonly {
-        readonly operations: readonly ChangeOperation[];
-        readonly revision: RevisionMetadata;
-    }[];
-    readonly version: 1;
-} | {
+export interface DraftSync {
     readonly draft: Draft;
     readonly kind: 'snapshot';
     readonly version: 1;
-};
+}
 export interface Publication {
     readonly actorId: string;
     readonly closureDigest: string;
@@ -174,6 +209,7 @@ export interface Diagnostic {
     readonly column: number;
     readonly line: number;
     readonly message: string;
+    readonly mismatch?: SchemaMismatch;
     readonly path: string;
     readonly values?: Readonly<Record<string, string | number>>;
 }
@@ -213,14 +249,23 @@ export interface Run {
     readonly status: RunStatus;
     readonly version: 1;
 }
-interface RunDetailsBase extends Run {
+export interface RunWait {
+    readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
+    readonly expiresAt: string;
+    readonly nodeId: string;
+    readonly prompt: string;
+    readonly waitId: string;
+    readonly waitingSince: string;
+}
+type RunDetailsBase = Run & {
     readonly closureDigest: string;
     readonly engineContract: string;
     readonly engineDigest: string;
     readonly eventsExpiresAt?: string;
     readonly modelVersion: number;
     readonly revisionDigest: string;
-}
+    readonly waits: readonly RunWait[];
+};
 export type DraftRun = RunDetailsBase & {
     readonly source: 'draft';
 };
@@ -241,14 +286,8 @@ export interface RunPage {
     readonly runs: readonly Run[];
     readonly version: 1;
 }
-export type RunEventKind = 'node.artifact' | 'node.completed' | 'node.failed' | 'node.log' | 'node.output' | 'node.progress' | 'node.started' | 'run.canceled' | 'run.completed' | 'run.events-truncated' | 'run.failed' | 'run.indeterminate' | 'run.progress' | 'run.queued' | 'run.started';
-export interface RunEvent {
-    readonly createdAt: string;
-    readonly kind: RunEventKind;
-    readonly payload: Readonly<Record<string, JsonValue>>;
-    readonly sequence: number;
-    readonly sourceSequence?: number;
-}
+export type RunEvent = Readonly<ReturnType<typeof decodeRunEvent>>;
+export type RunEventKind = RunEvent['kind'];
 export interface RunEvents {
     readonly done: boolean;
     readonly events: readonly RunEvent[];
@@ -286,17 +325,280 @@ export type RunResult = {
     readonly version: 1;
 };
 interface RunOptions {
+    readonly trigger: {
+        readonly nodeId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+    };
     readonly idempotencyKey?: string;
     readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
 }
 interface PublicationOptions {
     readonly idempotencyKey?: string;
 }
-export declare class ApiError extends Error {
-    readonly code: string;
-    readonly status: number;
-    constructor(status: number, code: string, message: string);
-}
+export declare function decodeRunEvent(value: unknown): {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.queued";
+    readonly payload: {
+        readonly flowId?: undefined;
+        readonly scopeId?: undefined;
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.started";
+    readonly payload: {
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly parentScopeId?: string | undefined;
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.progress";
+    readonly payload: {
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly progress: number;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.waiting";
+    readonly payload: {
+        readonly flowId?: undefined;
+        readonly scopeId?: undefined;
+        readonly progress?: undefined;
+        readonly waitIds: string[];
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "wait.created";
+    readonly payload: {
+        readonly flowId?: undefined;
+        readonly scopeId?: undefined;
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt: string;
+        readonly nodeId: string;
+        readonly waitId: string;
+        readonly waitingSince: string;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.resolved";
+    readonly payload: {
+        readonly flowId?: undefined;
+        readonly scopeId?: undefined;
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action: "approve" | "continue" | "reject";
+        readonly resolvedAt: string;
+        readonly waitId: string;
+        readonly result?: undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.canceled" | "run.completed" | "run.failed" | "run.indeterminate";
+    readonly payload: {
+        readonly flowId?: undefined;
+        readonly scopeId?: undefined;
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly nodeId?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result: JsonValue;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "run.events-truncated";
+    readonly payload: {
+        [k: string]: JsonValue;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.started";
+    readonly payload: {
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly nodeKind?: string | undefined;
+        readonly nodeTitle?: string | undefined;
+        readonly operation?: string | undefined;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.completed";
+    readonly payload: {
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly outputs: {
+            [k: string]: JsonValue;
+        };
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.failed";
+    readonly payload: {
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly error: {
+            readonly code: string;
+            readonly message: string;
+        };
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.log";
+    readonly payload: {
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly level: "debug" | "error" | "info" | "warn";
+        readonly message: string;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.progress";
+    readonly payload: {
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly progress: number;
+    };
+} | {
+    readonly createdAt: string;
+    readonly sequence: number;
+    readonly kind: "node.artifact";
+    readonly payload: {
+        readonly progress?: undefined;
+        readonly waitIds?: undefined;
+        readonly expiresAt?: undefined;
+        readonly waitingSince?: undefined;
+        readonly action?: undefined;
+        readonly resolvedAt?: undefined;
+        readonly waitId?: undefined;
+        readonly result?: undefined;
+        readonly flowId: string;
+        readonly scopeId: string;
+        readonly nodeId: string;
+        readonly executionId: string;
+        readonly artifact: {
+            readonly kind: 'artifact';
+            readonly id: string;
+            readonly name: string;
+            readonly size: number;
+            readonly digest: string;
+            readonly mediaType?: string | undefined;
+        };
+    };
+};
+export type ConditionalResult<T> = {
+    readonly modified: true;
+    readonly data: T;
+    readonly etag: string | null;
+} | {
+    readonly modified: false;
+    readonly etag: string | null;
+};
 export declare class ControlClient {
     private readonly requestControl;
     constructor(requestControl: ControlRequest);
@@ -305,6 +607,15 @@ export declare class ControlClient {
         readonly includeTotal?: boolean;
         readonly limit?: number;
     }): Promise<FlowPage>;
+    listEventSources(flowId?: string, signal?: AbortSignal): Promise<{
+        readonly version: 1;
+        readonly sources: readonly EventSource[];
+        readonly teamId?: string | null;
+    }>;
+    listEventSourceConnections(teamId: string | null, signal?: AbortSignal): Promise<readonly ConnectorConnection[]>;
+    createEventSource(input: CreateEventSource): Promise<EventSource>;
+    updateEventSource(sourceId: string, input: UpdateEventSource): Promise<EventSource>;
+    deleteEventSource(sourceId: string, expectedRevision: number): Promise<void>;
     listVariables(): Promise<{
         readonly variables: readonly Variable[];
         readonly version: 1;
@@ -316,10 +627,15 @@ export declare class ControlClient {
     getFlow(flowId: string): Promise<Flow>;
     renameFlow(flowId: string, name: string): Promise<Flow>;
     deleteFlow(flowId: string): Promise<Flow>;
-    listTriggerKeys(signal?: AbortSignal): Promise<readonly TriggerKeySummary[]>;
+    listTriggerKeys(signal?: AbortSignal, locale?: string): Promise<readonly TriggerKeySummary[]>;
     listTriggerDefinitions(signal?: AbortSignal): Promise<readonly TriggerKeySnapshot[]>;
+    readCatalog<T>(query: {
+        readonly path: string;
+        readonly decode: (data: unknown) => T;
+    }, etag: string | null, signal?: AbortSignal): Promise<ConditionalResult<T>>;
+    getTriggerCatalog(locale: string, cached?: TriggerCatalogCache, signal?: AbortSignal): Promise<TriggerCatalogCache>;
     getTriggerKey(key: string, signal?: AbortSignal): Promise<TriggerKeySnapshot>;
-    listFlowTriggerBindings(flowId: string): Promise<readonly TriggerBinding[]>;
+    listFlowTriggerBindings(flowId: string, signal?: AbortSignal): Promise<readonly TriggerBinding[]>;
     getFlowTriggerBinding(flowId: string, triggerNodeId: string): Promise<TriggerBindingDetail>;
     listFlowTriggerActivities(flowId: string, triggerNodeId: string, options?: {
         readonly cursor?: string;
@@ -328,40 +644,71 @@ export declare class ControlClient {
     pauseFlowTrigger(flowId: string, triggerNodeId: string): Promise<TriggerBinding>;
     resumeFlowTrigger(flowId: string, triggerNodeId: string): Promise<TriggerBinding>;
     testFlowPollTrigger(flowId: string, triggerNodeId: string): Promise<PollTriggerTestResult>;
+    getEditor(flowId: string): Promise<{
+        readonly flow: Flow;
+        readonly draft: Draft;
+        readonly live: Live;
+        readonly presentation: Presentation;
+        readonly version: 1;
+    }>;
+    getPresentation(flowId: string): Promise<Presentation>;
     getDraft(flowId: string): Promise<Draft>;
-    syncDraft(flowId: string, fromRevisionId?: string): Promise<DraftSync>;
+    syncDraft(flowId: string): Promise<DraftSync>;
     getRevision(flowId: string, revisionId: string): Promise<Draft>;
-    listConnectorProviders(signal?: AbortSignal, flowId?: string): Promise<readonly ConnectorProvider[]>;
-    listConnectorActions(serviceId?: string, signal?: AbortSignal, flowId?: string): Promise<readonly ConnectorAction[]>;
-    searchConnectorActions(query: string, signal?: AbortSignal, flowId?: string): Promise<readonly ConnectorAction[]>;
-    getConnectorAction(actionId: string, signal?: AbortSignal, flowId?: string): Promise<ConnectorAction>;
-    listConnectorConnections(serviceId: string, signal?: AbortSignal, flowId?: string): Promise<readonly ConnectorConnection[]>;
-    createConnectorConnectionPage(serviceId: string, flowId?: string): Promise<string>;
-    changeDraft(flowId: string, expectedRevisionId: string, operations: readonly ChangeOperation[]): Promise<DraftChange>;
+    listTriggerConfigOptions(flowId: string, nodeId: string, field: string, signal?: AbortSignal): Promise<readonly TriggerConfigOption[]>;
+    listConnectorProviders(signal?: AbortSignal, flowId?: string, locale?: string): Promise<readonly ConnectorProvider[]>;
+    listConnectorActions(serviceId?: string, signal?: AbortSignal, flowId?: string, locale?: string): Promise<readonly ConnectorAction[]>;
+    searchConnectorActions(query: string, signal?: AbortSignal, flowId?: string, locale?: string): Promise<readonly ConnectorAction[]>;
+    getConnectorAction(actionId: string, signal?: AbortSignal, flowId?: string, locale?: string, fresh?: boolean): Promise<ConnectorAction>;
+    listAllConnectorConnections(signal?: AbortSignal, flowId?: string, fresh?: boolean): Promise<readonly ConnectorConnection[]>;
+    listConnectorConnections(serviceId: string, signal?: AbortSignal, flowId?: string, fresh?: boolean): Promise<readonly ConnectorConnection[]>;
+    createConnectorConnectionPage(serviceId: string, flowId?: string, teamId?: string): Promise<string>;
+    changeDraft(flowId: string, expectedRevisionId: string, operations: readonly DraftOperation[], changeId?: string): Promise<DraftChange>;
+    repairDraft(flowId: string, expectedRevisionId: string, changeId?: string): Promise<DraftChange>;
     checkFlow(flowId: string, revisionId: string): Promise<FlowCheck>;
-    getLive(flowId: string): Promise<Live>;
+    getLive(flowId: string, signal?: AbortSignal): Promise<Live>;
     listPublications(flowId: string, options?: {
         readonly cursor?: string;
         readonly includeTotal?: boolean;
         readonly limit?: number;
-    }): Promise<PublicationPage>;
-    createDraftRun(flowId: string, revisionId: string, options?: RunOptions): Promise<DraftRun>;
-    createLiveRun(publicationId: string, options?: RunOptions): Promise<LiveRun>;
+    }, signal?: AbortSignal): Promise<PublicationPage>;
+    createDraftRun(flowId: string, revisionId: string, options: RunOptions): Promise<DraftRun>;
+    createLiveRun(publicationId: string, options: RunOptions): Promise<LiveRun>;
+    setFlowEnabled(flowId: string, publicationId: string, enabled: boolean): Promise<Flow>;
     publishFlow(flowId: string, revisionId: string, expectedLivePublicationId: string | null, options?: PublicationOptions): Promise<PublishOperation>;
-    getPublishOperation(flowId: string, operationId: string): Promise<PublishOperation>;
+    getPublishOperation(flowId: string, operationId: string, signal?: AbortSignal): Promise<PublishOperation>;
     rollbackFlow(flowId: string, publicationId: string, expectedLivePublicationId: string, options?: PublicationOptions): Promise<Publication>;
-    getRun(runId: string): Promise<RunDetails>;
+    getRun(runId: string, signal?: AbortSignal): Promise<RunDetails>;
     listRuns(flowId: string, options?: {
+        readonly createdBefore?: string;
+        readonly createdFrom?: string;
         readonly cursor?: string;
         readonly limit?: number;
+        readonly pendingWait?: boolean;
+        readonly runId?: string;
+        readonly source?: Run['source'];
         readonly status?: RunStatus;
     }): Promise<RunPage>;
     getRunEvents(runId: string, options?: {
         readonly after?: number;
         readonly limit?: number;
-    }): Promise<RunEvents>;
-    getRunResult(runId: string): Promise<RunResult>;
+    }, signal?: AbortSignal): Promise<RunEvents>;
+    listRunResults(runId: string, after?: string, signal?: AbortSignal): Promise<ReturnType<typeof decodeResultList>>;
+    readRunResult(runId: string, resultId: string, options?: ResultQuery, signal?: AbortSignal): Promise<ReturnType<typeof decodeResultRead>>;
+    downloadRunResult(runId: string, resultId: string, signal?: AbortSignal): Promise<Blob>;
+    getRunResult(runId: string, signal?: AbortSignal): Promise<RunResult>;
     cancelRun(runId: string): Promise<RunCancellation>;
+    resolveRunWait(runId: string, waitId: string, action: WaitAction): Promise<{
+        readonly action: WaitAction | null;
+        readonly resolutionAccepted: boolean;
+        readonly resolvedAt: string | null;
+        readonly runId: string;
+        readonly status: RunStatus;
+        readonly version: 1;
+        readonly waitId: string;
+    }>;
     private connectorActions;
+    protected connectorRequest<Value>(path: string, _kind: 'providers' | 'actions' | 'connections', signal: AbortSignal | undefined, decode: (value: unknown) => Value, _fresh?: boolean): Promise<Value>;
+    protected response(path: string, init: RequestInit, allowNotModified?: boolean): Promise<Response>;
     protected request<Value = unknown>(path: string, init?: RequestInit): Promise<Value>;
 }