@powerhousedao/reactor-workflow 6.2.3-dev.79 → 6.2.3-dev.81
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +24 -2
- package/dist/index.d.ts +152 -4
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +636 -127
- package/dist/index.js.map +1 -1
- package/dist/{piece-registry-BbeuE8TB.d.ts → piece-registry-ByALLpvA.d.ts} +23 -4
- package/dist/piece-registry-ByALLpvA.d.ts.map +1 -0
- package/dist/{telemetry-CJd29LsN.js → telemetry-DE0ALzOJ.js} +83 -13
- package/dist/telemetry-DE0ALzOJ.js.map +1 -0
- package/dist/testing.d.ts +1 -1
- package/dist/testing.js +1 -1
- package/dist/worker-entry.js +189 -11
- package/dist/worker-entry.js.map +1 -1
- package/package.json +7 -7
- package/dist/piece-registry-BbeuE8TB.d.ts.map +0 -1
- package/dist/telemetry-CJd29LsN.js.map +0 -1
package/README.md
CHANGED
|
@@ -277,13 +277,21 @@ returns it when it settles: a step, a trigger hook, an editor's options or
|
|
|
277
277
|
describe. A run holds no child between steps. Trigger hooks have children of
|
|
278
278
|
their own, so a burst of runs can't delay a poll, and so does the editor (one
|
|
279
279
|
child, which exits when idle). A child is retired when it
|
|
280
|
-
dies or times out,
|
|
280
|
+
dies or times out, past 80% of
|
|
281
281
|
its heap budget, after `PH_WORKFLOWS_WORKER_MAX_REQUESTS` requests, or after a
|
|
282
282
|
minute idle above `PH_WORKFLOWS_WORKER_MIN`.
|
|
283
283
|
|
|
284
284
|
Piece code is trusted: what a piece keeps in module state carries over to the
|
|
285
285
|
next request its child serves, whichever workflow sent it.
|
|
286
286
|
|
|
287
|
+
Certificate checks stay on in every child (`worker/tls-guard.ts`). Pieces
|
|
288
|
+
bundled with an old pieces-common set `NODE_TLS_REJECT_UNAUTHORIZED=0` before
|
|
289
|
+
every request, which would switch verification off process-wide; the guard
|
|
290
|
+
gives every `tls.connect` an explicit `rejectUnauthorized: true` unless the
|
|
291
|
+
caller explicitly asks for `false`, so fetch, https and the HTTP clients
|
|
292
|
+
pieces bundle all verify. The worker still reports a request that set the
|
|
293
|
+
variable (`tlsPoisoned`), but no longer retires the child for it.
|
|
294
|
+
|
|
287
295
|
That entry is `src/worker/entry.ts`: the piece worker from `src/pieces`, plus
|
|
288
296
|
`ctx.reactor` (`src/worker/reactor.ts`), which needs `@powerhousedao/reactor`
|
|
289
297
|
and so lives outside the piece layer. For an action, trigger or option resolver
|
|
@@ -295,6 +303,15 @@ the request settles. The boot document models reach the child on fork as
|
|
|
295
303
|
up with a `model-entries` host call the first time a piece asks for it. Either
|
|
296
304
|
way the model is imported on first use.
|
|
297
305
|
|
|
306
|
+
`ctx.reactor.query` is served the same way, by the host's optional
|
|
307
|
+
`queryIndex` dep (`WorkflowRuntimeHostDeps`): a read of a read-model index the
|
|
308
|
+
host registers as a GraphQL subgraph, run in the host process as the run user,
|
|
309
|
+
so the index's own access rules decide as they do over HTTP. A host that hands
|
|
310
|
+
over no `queryIndex` refuses the method by name, and a run with no user is
|
|
311
|
+
refused under enforcement like every other read. Switchboard answers it from
|
|
312
|
+
the GraphQL manager (`executeSubgraph`), so a piece never needs the
|
|
313
|
+
switchboard's URL or a bearer of its own to read an index.
|
|
314
|
+
|
|
298
315
|
## Blocks
|
|
299
316
|
|
|
300
317
|
A step names its block the way Activepieces does, with three fields:
|
|
@@ -510,6 +527,9 @@ they are true.
|
|
|
510
527
|
is not rerunnable; fire the workflow again instead.
|
|
511
528
|
- A step that DECLARES a `retry` block overrides `defaultRetry`, whatever the
|
|
512
529
|
block resolves to — `{maxAttempts: 1}` is an author saying "not this one".
|
|
530
|
+
- A step with no `retry` takes the workflow's `defaultRetry`, else its action's
|
|
531
|
+
default retry. A `defaultRetry` that retries nothing (the document's initial
|
|
532
|
+
`{maxAttempts: 1}`) counts as unset, so the action's applies.
|
|
513
533
|
- An **INDETERMINATE** step is never retried and never replayed: a retry would
|
|
514
534
|
be a second write. A rerun does execute it again, so it can write twice. See
|
|
515
535
|
**Indeterminate steps** below.
|
|
@@ -832,7 +852,9 @@ releases what an earlier enable registered. The reason reads
|
|
|
832
852
|
|
|
833
853
|
**Actions**
|
|
834
854
|
|
|
835
|
-
- `errorHandlingOptions`
|
|
855
|
+
- `errorHandlingOptions.retryOnFailure` with `defaultValue: true` becomes the
|
|
856
|
+
action's default retry (3 attempts, exponential from 5s) unless the action
|
|
857
|
+
declares a `defaultRetry`. `continueOnFailure` is ignored.
|
|
836
858
|
- `test` is never called.
|
|
837
859
|
- `requireAuth` defaults to `false` in the descriptor; upstream defaults to
|
|
838
860
|
`true`.
|
package/dist/index.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { C as
|
|
2
|
-
import { ActionBase, TriggerBase } from "@powerhousedao/pieces-framework";
|
|
1
|
+
import { C as PropertySettingDef, E as ReactorTap, F as BlockMatch, I as BlockResolution, L as PieceOrigin, M as EgressPolicy, T as WorkflowRunResult, b as WorkflowTelemetry, f as SecretStat, g as ModelManifestSource, h as IPieceWorker, i as ReplayedStep, k as PieceResolver, l as ConnectionRequest, n as packagePieces, p as SecretStore, r as CORE_PIECE_NAME, s as AttachmentPort, t as PieceRegistry, v as PieceWorkerResult, w as StepExecutionRecord, x as WorkflowTelemetryOptions, y as TELEMETRY_SCOPE } from "./piece-registry-ByALLpvA.js";
|
|
2
|
+
import { ActionBase, IndexQueryRequest, IndexQueryResult, TriggerBase } from "@powerhousedao/pieces-framework";
|
|
3
3
|
import { ILogger, OperationWithContext } from "document-model";
|
|
4
4
|
import "@powerhousedao/pieces-framework/workflow";
|
|
5
5
|
import { BlockIdentity, BlockRef } from "@powerhousedao/pieces-framework/block-type";
|
|
@@ -46,6 +46,70 @@ export declare const WORKFLOW_PACKAGE_NAME = "@powerhousedao/workflow";
|
|
|
46
46
|
//#region src/pieces/activepieces/registry-source.d.ts
|
|
47
47
|
export declare function setPieceRegistryUrl(url: string | undefined): void;
|
|
48
48
|
//#endregion
|
|
49
|
+
//#region src/reactor/oauth-apps.d.ts
|
|
50
|
+
/** The connection config key naming an app of the registry. */
|
|
51
|
+
export declare const OAUTH_APP = "oauth_app";
|
|
52
|
+
/**
|
|
53
|
+
* The connection config key for the scopes to ask for instead of the piece's
|
|
54
|
+
* own: a list, or one space-separated string. A read-only integration asks
|
|
55
|
+
* for `calendar.readonly` where the piece would ask to edit too.
|
|
56
|
+
*/
|
|
57
|
+
export declare const OAUTH_SCOPES = "oauth_scopes";
|
|
58
|
+
type OAuthClientKind = "web" | "desktop";
|
|
59
|
+
interface OAuthAppClient {
|
|
60
|
+
appId: string;
|
|
61
|
+
kind: OAuthClientKind;
|
|
62
|
+
clientId: string;
|
|
63
|
+
clientSecretRef: string;
|
|
64
|
+
}
|
|
65
|
+
interface OAuthAppRegistry {
|
|
66
|
+
client(appId: string, kind: OAuthClientKind): OAuthAppClient | undefined;
|
|
67
|
+
clients(appId: string): OAuthAppClient[];
|
|
68
|
+
}
|
|
69
|
+
/** One app as a host configures it: per client kind, the provider's client file. */
|
|
70
|
+
interface OAuthAppDefinition {
|
|
71
|
+
id: string;
|
|
72
|
+
/** Paths to the provider's downloaded client files (Google's client_secret_*.json). */
|
|
73
|
+
clients: Partial<Record<OAuthClientKind, string>>;
|
|
74
|
+
}
|
|
75
|
+
export declare class StaticOAuthAppRegistry implements OAuthAppRegistry {
|
|
76
|
+
private readonly entries;
|
|
77
|
+
constructor(entries: readonly OAuthAppClient[]);
|
|
78
|
+
client(appId: string, kind: OAuthClientKind): OAuthAppClient | undefined;
|
|
79
|
+
clients(appId: string): OAuthAppClient[];
|
|
80
|
+
}
|
|
81
|
+
/** Desktop for a callback to this machine, web for one the provider reaches over the internet. */
|
|
82
|
+
export declare function clientKindFor(redirectUri: string): OAuthClientKind;
|
|
83
|
+
/**
|
|
84
|
+
* Config key the runtime writes after a sign-in: the scopes the provider
|
|
85
|
+
* granted (its token response's `scope`, else the ones asked for). A
|
|
86
|
+
* connection whose `oauth_scopes` reach beyond them needs a new sign-in.
|
|
87
|
+
*/
|
|
88
|
+
export declare const OAUTH_GRANTED_SCOPES = "oauth_granted_scopes";
|
|
89
|
+
/** What a sign-in was granted: the token's own `scope`, else what the connection asked for. */
|
|
90
|
+
export declare function grantedScopes(tokenScope: string | undefined, config: Record<string, unknown>): string[] | undefined;
|
|
91
|
+
/** The scopes a connection asks for instead of the piece's, or undefined to keep the piece's. */
|
|
92
|
+
export declare function scopesOverride(config: Record<string, unknown>): string[] | undefined;
|
|
93
|
+
/**
|
|
94
|
+
* The client id and secret in a provider's client file: Google's
|
|
95
|
+
* `{ installed | web: { client_id, client_secret } }`, or the two keys at the
|
|
96
|
+
* top level.
|
|
97
|
+
*/
|
|
98
|
+
export declare function parseClientFile(text: string): {
|
|
99
|
+
clientId: string;
|
|
100
|
+
clientSecret: string;
|
|
101
|
+
};
|
|
102
|
+
/**
|
|
103
|
+
* Reads each configured client file and keeps its secret in the store under a
|
|
104
|
+
* fixed label: created the first time, rotated when the file changed, left
|
|
105
|
+
* alone otherwise. A client whose file cannot be read is skipped with the
|
|
106
|
+
* reason, so one bad file does not take the others down.
|
|
107
|
+
*/
|
|
108
|
+
export declare function loadOAuthApps(definitions: readonly OAuthAppDefinition[], store: SecretStore, options?: {
|
|
109
|
+
read?: (path: string) => Promise<string>;
|
|
110
|
+
onSkip?: (appId: string, kind: OAuthClientKind, reason: string) => void;
|
|
111
|
+
}): Promise<StaticOAuthAppRegistry>;
|
|
112
|
+
//#endregion
|
|
49
113
|
//#region src/reactor/run-scope.d.ts
|
|
50
114
|
interface ReactorConnectionScope {
|
|
51
115
|
access: "read" | "write";
|
|
@@ -86,12 +150,14 @@ interface WorkflowRuntimeHostDeps {
|
|
|
86
150
|
authEnforcement?: boolean;
|
|
87
151
|
hostPrincipal?: Principal;
|
|
88
152
|
hostIdentity?: HostIdentity;
|
|
153
|
+
queryIndex?(request: IndexQueryRequest, runUser: RunUser | null, signal?: AbortSignal): Promise<IndexQueryResult>;
|
|
89
154
|
modelManifest?(): ModelManifestEntry[];
|
|
90
155
|
modelEntries?(documentType: string): ModelManifestEntry[];
|
|
91
156
|
webhooks?: IWebhookScope;
|
|
92
157
|
attachments?: AttachmentClientLike;
|
|
93
158
|
canReadAttachmentRef?(request: AttachmentReadRequest): Promise<boolean>;
|
|
94
159
|
secrets?: SecretStore;
|
|
160
|
+
oauthApps?: readonly OAuthAppDefinition[];
|
|
95
161
|
secretsKeyFile?: string | false;
|
|
96
162
|
logger?: ILogger;
|
|
97
163
|
telemetry?: WorkflowTelemetryOptions;
|
|
@@ -19151,6 +19217,7 @@ interface TriggerSupervisorOptions {
|
|
|
19151
19217
|
parks?: ParkState;
|
|
19152
19218
|
resolveAuth: (connectionId: string | null | undefined, request?: ConnectionRequest) => Promise<unknown>;
|
|
19153
19219
|
fire: (workflowId: string, payload: unknown, kind: string, runId: string) => void;
|
|
19220
|
+
pollHeld?: (workflowId: string) => boolean;
|
|
19154
19221
|
cacheDir: string;
|
|
19155
19222
|
resolver?: PieceResolver;
|
|
19156
19223
|
worker?: IPieceWorker;
|
|
@@ -19203,6 +19270,13 @@ declare class TriggerSupervisor {
|
|
|
19203
19270
|
/** A disable clears the park. With no binding in memory to release a PARKED
|
|
19204
19271
|
* row through onDisable (a boot), the row is turned DISABLED here. */
|
|
19205
19272
|
releasePark(workflowId: string, flipRow: boolean): Promise<void>;
|
|
19273
|
+
/**
|
|
19274
|
+
* Makes an armed trigger due now and runs the due check at once, so a
|
|
19275
|
+
* schedule fires and a poll polls without waiting for its interval ("sync
|
|
19276
|
+
* now"). The next one follows the interval from there. False when the
|
|
19277
|
+
* workflow has no armed trigger (disabled, parked, erroring, unknown).
|
|
19278
|
+
*/
|
|
19279
|
+
pollNow(workflowId: string): Promise<boolean>;
|
|
19206
19280
|
/** A re-publish past the parked version: on this lane, a park older than
|
|
19207
19281
|
* `publishedVersion` goes and a row it parked is ENABLED again, as it was
|
|
19208
19282
|
* before (only an ENABLED row is ever parked); a park as new stands. The
|
|
@@ -19343,6 +19417,27 @@ interface WebhookEndpointRecord {
|
|
|
19343
19417
|
armed: boolean;
|
|
19344
19418
|
createdAt: string;
|
|
19345
19419
|
}
|
|
19420
|
+
/**
|
|
19421
|
+
* One workflow's trigger as the runtime holds it. `trigger` is null when the
|
|
19422
|
+
* runtime holds no trigger row (never armed, or a webhook/schedule kind);
|
|
19423
|
+
* `park` is set while a failed run keeps the trigger unarmed, until the
|
|
19424
|
+
* workflow is re-enabled or re-published.
|
|
19425
|
+
*/
|
|
19426
|
+
type WorkflowHealth = {
|
|
19427
|
+
trigger: {
|
|
19428
|
+
/** ENABLED | DISABLED | ERROR | PARKED */
|
|
19429
|
+
status: string;
|
|
19430
|
+
lastError: string | null;
|
|
19431
|
+
lastPollAt: string | null;
|
|
19432
|
+
nextPollAt: string | null;
|
|
19433
|
+
consecutiveFailures: number;
|
|
19434
|
+
} | null;
|
|
19435
|
+
park: {
|
|
19436
|
+
reason: string;
|
|
19437
|
+
parkedAt: string;
|
|
19438
|
+
publishedVersion: number;
|
|
19439
|
+
} | null;
|
|
19440
|
+
};
|
|
19346
19441
|
export declare class WorkflowRuntimeService {
|
|
19347
19442
|
private readonly host;
|
|
19348
19443
|
private readonly logger;
|
|
@@ -19363,6 +19458,7 @@ export declare class WorkflowRuntimeService {
|
|
|
19363
19458
|
private secretsPromise?;
|
|
19364
19459
|
private oauthAttemptsPromise?;
|
|
19365
19460
|
private tokenRefresher?;
|
|
19461
|
+
private oauthAppsPromise?;
|
|
19366
19462
|
private readonly registry;
|
|
19367
19463
|
private readonly seedPromise;
|
|
19368
19464
|
private seedError?;
|
|
@@ -19374,7 +19470,22 @@ export declare class WorkflowRuntimeService {
|
|
|
19374
19470
|
private openStore;
|
|
19375
19471
|
secrets(): Promise<SecretStore>;
|
|
19376
19472
|
private secretProvider;
|
|
19473
|
+
private callerAddress;
|
|
19474
|
+
createSecret(input: {
|
|
19475
|
+
value: string;
|
|
19476
|
+
label?: string;
|
|
19477
|
+
ownerId: string;
|
|
19478
|
+
}, ctx?: WorkflowCaller): Promise<SecretStat>;
|
|
19479
|
+
private assertCanManageSecret;
|
|
19480
|
+
canManageSecret(stat: SecretStat, ctx: WorkflowCaller | undefined): Promise<boolean>;
|
|
19481
|
+
rotateSecret(ref: string, value: string, ctx: WorkflowCaller | undefined): Promise<SecretStat>;
|
|
19482
|
+
deleteSecret(ref: string, ctx: WorkflowCaller | undefined): Promise<void>;
|
|
19483
|
+
secretStat(ref: string, ctx: WorkflowCaller | undefined): Promise<SecretStat | null>;
|
|
19484
|
+
listSecrets(ctx: WorkflowCaller | undefined): Promise<SecretStat[]>;
|
|
19485
|
+
private readableSecrets;
|
|
19377
19486
|
private oauthAttempts;
|
|
19487
|
+
/** The host's OAuth2 apps, their client secrets loaded into the store once. */
|
|
19488
|
+
private oauthApps;
|
|
19378
19489
|
private oauthRefresher;
|
|
19379
19490
|
/** The seeding failure a restart is needed to clear, or undefined while the
|
|
19380
19491
|
* registry is seeded. Resolves once seeding has finished either way. */
|
|
@@ -19461,6 +19572,19 @@ export declare class WorkflowRuntimeService {
|
|
|
19461
19572
|
private closed;
|
|
19462
19573
|
private throwIfClosed;
|
|
19463
19574
|
shutdown(): void;
|
|
19575
|
+
/**
|
|
19576
|
+
* Runs a workflow's trigger now, as its schedule or poll would (a sync
|
|
19577
|
+
* now): a schedule fires the workflow, a polling trigger polls its source.
|
|
19578
|
+
* Never a backfill's pace. False when it has no armed trigger.
|
|
19579
|
+
*/
|
|
19580
|
+
pollNow(workflowId: string, ctx?: WorkflowCaller): Promise<boolean>;
|
|
19581
|
+
/**
|
|
19582
|
+
* How one workflow's trigger stands, for host-side code that keeps
|
|
19583
|
+
* workflows running (a processor reconciling the workflows it built): the
|
|
19584
|
+
* trigger row, and the park that holds it unarmed. Not caller-filtered:
|
|
19585
|
+
* GraphQL callers go through triggerStates.
|
|
19586
|
+
*/
|
|
19587
|
+
workflowHealth(workflowId: string): Promise<WorkflowHealth>;
|
|
19464
19588
|
triggerStates(ctx?: WorkflowCaller): Promise<TriggerStateRow[]>;
|
|
19465
19589
|
private webhookEndpoints?;
|
|
19466
19590
|
private webhookScope?;
|
|
@@ -19488,6 +19612,7 @@ export declare class WorkflowRuntimeService {
|
|
|
19488
19612
|
private readonly models;
|
|
19489
19613
|
private modelEntries;
|
|
19490
19614
|
private declaredReactor;
|
|
19615
|
+
private blockDefaults;
|
|
19491
19616
|
private callerRunUser;
|
|
19492
19617
|
private reactorScope;
|
|
19493
19618
|
private stepReactorAccess;
|
|
@@ -19563,6 +19688,20 @@ export declare class WorkflowRuntimeService {
|
|
|
19563
19688
|
fire(workflowId: string, triggerPayload?: unknown, triggerKind?: string, resume?: RunResume, ctx?: WorkflowCaller, enqueuedRunId?: string): Promise<PersistedRunResult>;
|
|
19564
19689
|
private runFired;
|
|
19565
19690
|
private readonly runGate;
|
|
19691
|
+
private readonly unsettledFirings;
|
|
19692
|
+
private readonly runLimits;
|
|
19693
|
+
/**
|
|
19694
|
+
* Whether a due poll of this workflow's trigger should wait: its runs are
|
|
19695
|
+
* serialised (QUEUE, SINGLETON, a bounded PARALLEL) and every slot is taken
|
|
19696
|
+
* by a firing that has not settled. A polling trigger that hands out work
|
|
19697
|
+
* advances its own position when polled (the backfill's for-every moves its
|
|
19698
|
+
* cursor), so a poll now would only add a firing that waits in the queue,
|
|
19699
|
+
* where it can expire past `runTimeoutSeconds` or be skipped by a park,
|
|
19700
|
+
* with the position already gone. The supervisor leaves the poll due and
|
|
19701
|
+
* looks again on its next tick.
|
|
19702
|
+
*/
|
|
19703
|
+
private pollHeld;
|
|
19704
|
+
private settleFiring;
|
|
19566
19705
|
private readonly heldReplies;
|
|
19567
19706
|
/** Why a trigger's firing of a PARKED workflow is refused; undefined when
|
|
19568
19707
|
* it is not parked, or when an operator started the run. */
|
|
@@ -19749,9 +19888,18 @@ export declare function publishRunUser(client: Pick<IReactorClient, "getOperatio
|
|
|
19749
19888
|
//#region src/reactor/workflow-triggers-read-model.d.ts
|
|
19750
19889
|
export declare const WORKFLOW_TRIGGERS_READ_MODEL = "workflow-triggers";
|
|
19751
19890
|
export declare const WORKFLOW_TRIGGERS_READ_MODEL_STAGE: ReadModelRegistrationStage;
|
|
19752
|
-
|
|
19891
|
+
/**
|
|
19892
|
+
* What a processor on the runtime's host reads through
|
|
19893
|
+
* `getReadModel(WORKFLOW_TRIGGERS_READ_MODEL)`: whether a workflow's trigger
|
|
19894
|
+
* is armed, failing or parked. The model exists only where the runtime runs.
|
|
19895
|
+
*/
|
|
19896
|
+
interface WorkflowHealthReader {
|
|
19897
|
+
health(workflowId: string): Promise<WorkflowHealth>;
|
|
19898
|
+
}
|
|
19899
|
+
export declare class WorkflowTriggersReadModel extends BaseReadModel implements WorkflowHealthReader {
|
|
19753
19900
|
private readonly runtime;
|
|
19754
19901
|
constructor(db: Kysely<DocumentViewDatabase>, operationIndex: IOperationIndex, writeCache: IWriteCache, consistencyTracker: IConsistencyTracker, runtime: WorkflowRuntimeService);
|
|
19902
|
+
health(workflowId: string): Promise<WorkflowHealth>;
|
|
19755
19903
|
protected commitOperations(items: OperationWithContext[]): Promise<void>;
|
|
19756
19904
|
}
|
|
19757
19905
|
//#endregion
|
|
@@ -19782,6 +19930,6 @@ interface WebhookPayload {
|
|
|
19782
19930
|
body: unknown;
|
|
19783
19931
|
}
|
|
19784
19932
|
//#endregion
|
|
19785
|
-
export { type AcquireSingletonOptions, type AttachmentClientLike, type AttachmentReadRequest, type BlockResolutionRecord, CORE_PIECE_NAME, type ConnectionCheckResult, type ConnectionSummary, type HostIdentity, type OAuthAttemptStatus, type OAuthAttemptView, type OAuthStart, type OutputTree, type OutputTreeNode, type PersistedRunResult, PieceRegistry, type PieceStoreRow, type PieceTriggerBinding, type RunPage, type RunRecord, type RunRow, type RunsArgs, type RunsPageArgs, type ScheduleTriggerBinding, type StepExecutionRow, type StepTestResult, TELEMETRY_SCOPE, type TriggerBinding, type TriggerDedupeRow, type TriggerStateRow, type WebhookConfig, type WebhookPayload, type WorkflowAccessOptions, type WorkflowCaller, type WorkflowRuntimeDB, type WorkflowRuntimeHostDeps, type WorkflowSingletonLease, type WorkflowSingletonLoss, type WorkflowTelemetryOptions, packagePieces };
|
|
19933
|
+
export { type AcquireSingletonOptions, type AttachmentClientLike, type AttachmentReadRequest, type BlockResolutionRecord, CORE_PIECE_NAME, type ConnectionCheckResult, type ConnectionSummary, type HostIdentity, type OAuthAppClient, type OAuthAppDefinition, type OAuthAppRegistry, type OAuthAttemptStatus, type OAuthAttemptView, type OAuthClientKind, type OAuthStart, type OutputTree, type OutputTreeNode, type PersistedRunResult, PieceRegistry, type PieceStoreRow, type PieceTriggerBinding, type RunPage, type RunRecord, type RunRow, type RunsArgs, type RunsPageArgs, type ScheduleTriggerBinding, type StepExecutionRow, type StepTestResult, TELEMETRY_SCOPE, type TriggerBinding, type TriggerDedupeRow, type TriggerStateRow, type WebhookConfig, type WebhookPayload, type WorkflowAccessOptions, type WorkflowCaller, type WorkflowHealth, type WorkflowHealthReader, type WorkflowRuntimeDB, type WorkflowRuntimeHostDeps, type WorkflowSingletonLease, type WorkflowSingletonLoss, type WorkflowTelemetryOptions, packagePieces };
|
|
19786
19934
|
export {};
|
|
19787
19935
|
//# sourceMappingURL=index.d.ts.map
|