@nestjs/workflows 0.0.1

package/dist/services/workflow-registry.service.d.ts

@@ -0,0 +1,56 @@
+import { type Type } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import type { WorkflowRunner } from '../interfaces/workflow-runner.interface.js';
+import type { WorkflowDeclaredSchedule, WorkflowMetadata } from '../interfaces/workflow-decorator-options.interface.js';
+import type { WorkflowConcurrencyLimit, WorkflowRateLimitRule } from '../interfaces/workflow-store.interface.js';
+export interface WorkflowDefinition extends WorkflowMetadata {
+    key: string;
+    instance: WorkflowRunner;
+    type: Type<unknown>;
+}
+export declare const workflowKey: (name: string, version: number) => string;
+/**
+ * Internal: `WorkflowsCqrsModule` calls it from its publisher's constructor, before any
+ * definition loads. Without it, a workflow mapped from CQRS events fails the startup check.
+ */
+export declare const ROUTE_EVENTS: unique symbol;
+/** Finds every `@Workflow()` provider, wherever it is registered. */
+export declare class WorkflowRegistry {
+    private readonly discovery;
+    private definitions?;
+    private declared?;
+    private eventsRouted;
+    constructor(discovery: DiscoveryService);
+    /** `name@version` keys this process can run. */
+    keys(): string[];
+    /** The workflow versions this process can run, for claims. */
+    versions(): Array<{
+        name: string;
+        version: number;
+    }>;
+    /** The concurrency limits of the workflows this process runs, for claims: each name's highest registered version's. */
+    limits(): WorkflowConcurrencyLimit[];
+    /** The rate limits of the workflows this process runs, for claims: each name's highest registered version's. */
+    rateLimits(): WorkflowRateLimitRule[];
+    /** The workflow names this process registers. */
+    names(): string[];
+    /**
+     * The schedules the workflows this process runs declare, by id: each name's highest registered version's. Throws
+     * for an id two workflows declare.
+     */
+    schedules(): Map<string, WorkflowDeclaredSchedule & {
+        workflow: string;
+    }>;
+    [ROUTE_EVENTS](): void;
+    get(name: string, version: number): WorkflowDefinition | undefined;
+    /** Highest registered version of `name`. */
+    latest(name: string): WorkflowDefinition | undefined;
+    /**
+     * Name and version for a `start()` call. A class only identifies the
+     * workflow by name: like a name, it starts the highest version registered in
+     * this application, so a controller that passes the version 1 class starts
+     * version 2 once it is deployed. `version` pins one explicitly.
+     */
+    resolve(workflow: Type<unknown> | string, version?: number): WorkflowMetadata;
+    private load;
+}

package/dist/services/workflow-registry.service.js

@@ -0,0 +1,172 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { WorkflowNotFoundError } from '../errors/workflow-not-found.error.js';
+import { WORKFLOW_EVENT_ROUTES_METADATA, WORKFLOW_METADATA } from '../workflows.constants.js';
+export const workflowKey = (name, version) => `${name}@${version}`;
+/**
+ * Internal: `WorkflowsCqrsModule` calls it from its publisher's constructor, before any
+ * definition loads. Without it, a workflow mapped from CQRS events fails the startup check.
+ */
+export const ROUTE_EVENTS = Symbol('WorkflowRegistry.routeEvents');
+/** Finds every `@Workflow()` provider, wherever it is registered. */
+let WorkflowRegistry = class WorkflowRegistry {
+    constructor(discovery) {
+        this.discovery = discovery;
+        this.eventsRouted = false;
+    }
+    /** `name@version` keys this process can run. */
+    keys() {
+        return [...this.load().keys()];
+    }
+    /** The workflow versions this process can run, for claims. */
+    versions() {
+        return [...this.load().values()].map(({ name, version }) => ({ name, version }));
+    }
+    /** The concurrency limits of the workflows this process runs, for claims: each name's highest registered version's. */
+    limits() {
+        return this.names().flatMap((name) => {
+            const concurrency = this.latest(name).concurrency;
+            return concurrency ? [{ workflow: name, limit: concurrency.limit, perKey: concurrency.perKey }] : [];
+        });
+    }
+    /** The rate limits of the workflows this process runs, for claims: each name's highest registered version's. */
+    rateLimits() {
+        return this.names().flatMap((name) => {
+            const rateLimit = this.latest(name).rateLimit;
+            return rateLimit ? [{ workflow: name, limit: rateLimit.limit, perKey: rateLimit.perKey }] : [];
+        });
+    }
+    /** The workflow names this process registers. */
+    names() {
+        return [...new Set([...this.load().values()].map((def) => def.name))];
+    }
+    /**
+     * The schedules the workflows this process runs declare, by id: each name's highest registered version's. Throws
+     * for an id two workflows declare.
+     */
+    schedules() {
+        if (this.declared) {
+            return this.declared;
+        }
+        const declared = new Map();
+        for (const name of this.names()) {
+            for (const schedule of this.latest(name).schedules ?? []) {
+                const other = declared.get(schedule.id);
+                if (other) {
+                    throw new Error(`Schedule "${schedule.id}" is declared by two workflows ("${other.workflow}" and "${name}"). Give each schedule its own id.`);
+                }
+                declared.set(schedule.id, { ...schedule, workflow: name });
+            }
+        }
+        return (this.declared = declared);
+    }
+    [ROUTE_EVENTS]() {
+        this.eventsRouted = true;
+    }
+    get(name, version) {
+        return this.load().get(workflowKey(name, version));
+    }
+    /** Highest registered version of `name`. */
+    latest(name) {
+        let latest;
+        for (const def of this.load().values()) {
+            if (def.name === name && (!latest || def.version > latest.version)) {
+                latest = def;
+            }
+        }
+        return latest;
+    }
+    /**
+     * Name and version for a `start()` call. A class only identifies the
+     * workflow by name: like a name, it starts the highest version registered in
+     * this application, so a controller that passes the version 1 class starts
+     * version 2 once it is deployed. `version` pins one explicitly.
+     */
+    resolve(workflow, version) {
+        let name;
+        let fallback;
+        if (typeof workflow === 'string') {
+            name = workflow;
+        }
+        else {
+            const meta = Reflect.getMetadata(WORKFLOW_METADATA, workflow);
+            if (!meta) {
+                throw new WorkflowNotFoundError(`${workflow.name} is not decorated with @Workflow().`);
+            }
+            name = meta.name;
+            // A class this process does not register (an API pod starting work for
+            // a worker pod) still knows its own version and timeout.
+            fallback = meta;
+        }
+        if (version !== undefined) {
+            if (!Number.isInteger(version) || version < 1) {
+                throw new TypeError(`Invalid version ${version} for workflow "${name}". Use a positive integer.`);
+            }
+            const known = this.get(name, version) ?? (fallback?.version === version ? fallback : undefined);
+            const latest = this.latest(name);
+            return {
+                name,
+                version,
+                timeout: known?.timeout,
+                concurrency: latest?.concurrency ?? fallback?.concurrency ?? known?.concurrency,
+                rateLimit: latest?.rateLimit ?? fallback?.rateLimit ?? known?.rateLimit,
+            };
+        }
+        const def = this.latest(name);
+        if (def) {
+            return { name: def.name, version: def.version, timeout: def.timeout, concurrency: def.concurrency, rateLimit: def.rateLimit };
+        }
+        if (fallback !== undefined) {
+            return { name, version: fallback.version, timeout: fallback.timeout, concurrency: fallback.concurrency, rateLimit: fallback.rateLimit };
+        }
+        throw new WorkflowNotFoundError(`Workflow "${name}" is not registered in this application. Register it, or pass { version } to start it from a process that does not run it.`);
+    }
+    load() {
+        if (this.definitions) {
+            return this.definitions;
+        }
+        const definitions = new Map();
+        for (const wrapper of this.discovery.getProviders()) {
+            const type = (!wrapper.metatype || wrapper.inject ? wrapper.instance?.constructor : wrapper.metatype);
+            const meta = type && Reflect.getMetadata(WORKFLOW_METADATA, type);
+            if (!meta) {
+                continue;
+            }
+            if (!wrapper.isDependencyTreeStatic() || wrapper.isTransient) {
+                throw new Error(`Workflow ${type.name} must be a singleton; request-scoped and transient workflows are not supported.`);
+            }
+            const key = workflowKey(meta.name, meta.version);
+            const existing = definitions.get(key);
+            if (existing && existing.type !== type) {
+                throw new Error(`Workflow "${key}" is defined twice (${existing.type.name} and ${type.name}). Bump the version of one of them.`);
+            }
+            const instance = wrapper.instance;
+            if (typeof instance?.run !== 'function') {
+                throw new Error(`Workflow ${type.name} must have a run(ctx, input) method.`);
+            }
+            // The main entry never imports @nestjs/cqrs: the decorators leave metadata, and the
+            // subpath's module marks the registry. Mapped events with no publisher would start nothing.
+            if (!this.eventsRouted && Reflect.getOwnMetadata(WORKFLOW_EVENT_ROUTES_METADATA, type)) {
+                throw new Error(`Workflow ${type.name} is started or signalled by CQRS events (@StartOn(), @SignalOn()), but ` +
+                    'WorkflowsCqrsModule is not imported, so publishing those events would start and signal nothing. ' +
+                    "Import WorkflowsCqrsModule from '@nestjs/workflows/cqrs' next to CqrsModule.forRoot().");
+            }
+            definitions.set(key, { ...meta, key, instance, type });
+        }
+        return (this.definitions = definitions);
+    }
+};
+WorkflowRegistry = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DiscoveryService])
+], WorkflowRegistry);
+export { WorkflowRegistry };

package/dist/services/workflow-scheduler.service.d.ts

@@ -0,0 +1,54 @@
+import { type OnApplicationBootstrap } from '@nestjs/common';
+import type { DeclaredSchedule, ScheduleProduction } from '../core/interfaces/scheduler-options.interface.js';
+import type { ScheduleRecord } from '../core/interfaces/schedule-store.interface.js';
+import { Scheduler } from '../core/scheduling/scheduler.js';
+import { WorkflowEvents } from '../events/workflow-events.service.js';
+import type { WorkflowMetadata } from '../interfaces/workflow-decorator-options.interface.js';
+import type { WorkflowInstance } from '../interfaces/workflow-instance.interface.js';
+import type { WorkflowSchedule } from '../interfaces/workflow-schedule.interface.js';
+import type { WorkflowsModuleOptions } from '../interfaces/workflows-module-options.interface.js';
+import { WorkflowStorage } from '../storage/workflow.storage.js';
+import type { WorkflowScheduleSpec } from '../utils/schedule-spec.util.js';
+import { WorkflowRegistry } from './workflow-registry.service.js';
+/**
+ * @internal Workflows' schedules on the core's `Scheduler`: this process's workflows are its targets, their declared
+ * schedules its declarations, and an occurrence starts an instance. The `Scheduler` keeps the declared ones in step
+ * with the code and starts the occurrences that are due, for the worker; `WorkflowSchedules` is the public side.
+ */
+export declare class WorkflowScheduler implements OnApplicationBootstrap {
+    private readonly storage;
+    private readonly registry;
+    private readonly events;
+    private readonly logger;
+    private readonly clock;
+    /** The schedules' engine, over the registered store's schedules. */
+    readonly engine: Scheduler<WorkflowScheduleSpec>;
+    private declarations?;
+    constructor(storage: WorkflowStorage, options: WorkflowsModuleOptions, registry: WorkflowRegistry, events: WorkflowEvents);
+    /** Read at each call, never in the constructor: sources register while providers are created. */
+    private get store();
+    onApplicationBootstrap(): Promise<void>;
+    /** @internal Called by the worker: starts the due occurrences of the schedules of the workflows it runs. */
+    produce(owner: string, leaseMs: number): Promise<ScheduleProduction>;
+    /** The declaration of a schedule the workflows this process runs declare, or `undefined`. */
+    declaration(id: string): DeclaredSchedule<WorkflowScheduleSpec> | undefined;
+    /**
+     * Starts the instance of an occurrence (or of a trigger, `at` being now): the one `create()` stored, and whether it
+     * created it. An input or a key that can't be computed skips the occurrence (`null`), logged: retrying would fail
+     * the same way. With `rethrow`, that throws instead.
+     */
+    startOccurrence(record: ScheduleRecord, spec: WorkflowScheduleSpec, declared: DeclaredSchedule<WorkflowScheduleSpec> | undefined, workflow: WorkflowMetadata, at: number, now: number, rethrow?: boolean): Promise<{
+        instance: WorkflowInstance;
+        created: boolean;
+    } | null>;
+    /** How `WorkflowSchedules` shows a stored schedule. */
+    view(record: ScheduleRecord): WorkflowSchedule;
+    /** How `WorkflowSchedules` shows a schedule as stored: without its input, if no codec can read it any more. */
+    readableView(record: ScheduleRecord): Promise<WorkflowSchedule>;
+    /** The schedules the workflows this process runs declare (each name's highest registered version's), for the `Scheduler`. */
+    private declared;
+    private fire;
+    /** The unfinished instances the schedule started. */
+    private running;
+    private skipped;
+}

package/dist/services/workflow-scheduler.service.js

@@ -0,0 +1,173 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { occurrenceId } from '../core/scheduling/schedule-spec.js';
+import { Scheduler } from '../core/scheduling/scheduler.js';
+import { systemClock } from '../core/time/clock.js';
+import { WorkflowStateError } from '../errors/workflow-state.error.js';
+import { WorkflowEvents } from '../events/workflow-events.service.js';
+import { ENGINE_STORE, PAYLOAD_CODECS, WorkflowStorage } from '../storage/workflow.storage.js';
+import { newInstance } from '../utils/new-instance.util.js';
+import { workflowScheduleStore } from '../utils/schedule-store.util.js';
+import { WORKFLOWS_MODULE_OPTIONS } from '../workflows.module-definition.js';
+import { WorkflowRegistry } from './workflow-registry.service.js';
+/** The unfinished instances a schedule's overlap looks at, at most. */
+const RUNNING_PAGE = 100;
+const UNFINISHED = ['pending', 'running', 'suspended', 'compensating'];
+/**
+ * @internal Workflows' schedules on the core's `Scheduler`: this process's workflows are its targets, their declared
+ * schedules its declarations, and an occurrence starts an instance. The `Scheduler` keeps the declared ones in step
+ * with the code and starts the occurrences that are due, for the worker; `WorkflowSchedules` is the public side.
+ */
+let WorkflowScheduler = class WorkflowScheduler {
+    constructor(storage, options, registry, events) {
+        this.storage = storage;
+        this.registry = registry;
+        this.events = events;
+        this.logger = new Logger('Workflows');
+        this.clock = options.clock ?? systemClock;
+        this.engine = new Scheduler({
+            // Read at each call, never in the constructor: sources register while providers are created.
+            store: workflowScheduleStore(() => storage.source),
+            clock: this.clock,
+            codecs: storage[PAYLOAD_CODECS],
+            payloadContext: (schedule) => ({ field: 'input', schedule }),
+            targets: () => registry.names(),
+            declared: () => this.declared(),
+            fire: (occurrence) => this.fire(occurrence),
+            running: (schedule) => this.running(schedule.id),
+            cancel: (id, reason, now) => this.store.requestCancel(id, { reason, now, terminate: false }),
+            skipped: (schedule, skip, now) => this.skipped(schedule, skip, now),
+            conflictError: (message) => new WorkflowStateError(message),
+            labels: { target: (name) => `workflow "${name}"`, targets: 'workflows', payload: 'input', upsert: 'WorkflowSchedules.upsert()' },
+            logger: this.logger,
+        });
+    }
+    /** Read at each call, never in the constructor: sources register while providers are created. */
+    get store() {
+        return this.storage[ENGINE_STORE];
+    }
+    async onApplicationBootstrap() {
+        // A definition error (an id two workflows declare) fails the startup; the store's errors don't.
+        this.registry.schedules();
+        try {
+            await this.engine.synced();
+        }
+        catch (error) {
+            this.logger.error('Saving the schedules the workflows declare failed; the worker tries again before it starts any.', error);
+        }
+    }
+    /** @internal Called by the worker: starts the due occurrences of the schedules of the workflows it runs. */
+    produce(owner, leaseMs) {
+        return this.engine.produce(owner, leaseMs);
+    }
+    /** The declaration of a schedule the workflows this process runs declare, or `undefined`. */
+    declaration(id) {
+        return this.declared().get(id);
+    }
+    /**
+     * Starts the instance of an occurrence (or of a trigger, `at` being now): the one `create()` stored, and whether it
+     * created it. An input or a key that can't be computed skips the occurrence (`null`), logged: retrying would fail
+     * the same way. With `rethrow`, that throws instead.
+     */
+    async startOccurrence(record, spec, declared, workflow, at, now, rethrow = false) {
+        const id = occurrenceId(record.id, at);
+        let data;
+        try {
+            // A declared schedule's input is its code's (the stored one is for reading), an upserted one's is stored.
+            const source = declared ? declared.payload : record.payload;
+            const input = typeof source === 'function' ? source({ id: record.id, at }) : source;
+            data = newInstance(workflow, id, input ?? undefined, {
+                caller: `Schedule "${record.id}"`,
+                now,
+                priority: spec.priority === 0 ? undefined : spec.priority,
+                scheduleId: record.id,
+                scheduledAt: at,
+            });
+        }
+        catch (error) {
+            if (rethrow) {
+                throw error;
+            }
+            this.logger.error(`Schedule "${record.id}" couldn't start its occurrence of ${new Date(at).toISOString()}: ${error?.message ?? String(error)}`);
+            return null;
+        }
+        const stored = await this.store.create(data);
+        if (!stored.created && (stored.instance.workflow !== data.workflow || stored.instance.scheduleId !== record.id)) {
+            this.logger.warn(`Schedule "${record.id}" didn't start its occurrence of ${new Date(at).toISOString()}: instance "${id}" exists and isn't the schedule's.`);
+        }
+        return stored;
+    }
+    /** How `WorkflowSchedules` shows a stored schedule. */
+    view(record) {
+        const spec = record.spec;
+        const { nextAt, runs, bufferedAt } = this.engine.progress(record);
+        return {
+            id: record.id,
+            workflow: record.target,
+            version: spec.version,
+            declared: record.declared,
+            ...(spec.cron !== undefined ? { cron: spec.cron } : {}),
+            ...(spec.every !== undefined ? { every: spec.every } : {}),
+            ...(spec.rrule !== undefined ? { rrule: spec.rrule } : {}),
+            tz: spec.tz,
+            startAt: spec.startAt,
+            endAt: spec.endAt,
+            limit: spec.limit,
+            missed: spec.missed,
+            overlap: spec.overlap,
+            priority: spec.priority,
+            ...(spec.inputFn || record.payload === null ? {} : { input: record.payload }),
+            paused: record.paused,
+            nextAt,
+            runs,
+            bufferedAt,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    /** How `WorkflowSchedules` shows a schedule as stored: without its input, if no codec can read it any more. */
+    async readableView(record) {
+        return this.view(await this.engine.readable(record));
+    }
+    /** The schedules the workflows this process runs declare (each name's highest registered version's), for the `Scheduler`. */
+    declared() {
+        this.declarations ??= new Map([...this.registry.schedules()].map(([id, schedule]) => [
+            id,
+            { id, target: schedule.workflow, version: this.registry.latest(schedule.workflow).version, spec: schedule.spec, payload: schedule.input },
+        ]));
+        return this.declarations;
+    }
+    async fire({ schedule, spec, declared, at, now }) {
+        const workflow = this.registry.resolve(schedule.target, spec.version ?? undefined);
+        const started = await this.startOccurrence(schedule, spec, declared, workflow, at, now);
+        return started && { created: started.created };
+    }
+    /** The unfinished instances the schedule started. */
+    async running(schedule) {
+        // Read as stored: only the ids count, and an instance no codec can read any more still runs.
+        const instances = await this.store.inner.list({ scheduleId: schedule, status: UNFINISHED, limit: RUNNING_PAGE, offset: 0 });
+        return instances.map((instance) => instance.id);
+    }
+    skipped(schedule, skip, now) {
+        const workflow = this.registry.resolve(schedule.target, schedule.spec.version ?? undefined);
+        this.events.emit({ type: 'schedule-skipped', id: schedule.id, workflow: workflow.name, version: workflow.version, at: now, ...skip });
+    }
+};
+WorkflowScheduler = __decorate([
+    Injectable(),
+    __param(1, Inject(WORKFLOWS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [WorkflowStorage, Object, WorkflowRegistry,
+        WorkflowEvents])
+], WorkflowScheduler);
+export { WorkflowScheduler };

package/dist/services/workflow-schedules.service.d.ts

@@ -0,0 +1,60 @@
+import type { WorkflowStartResult } from '../interfaces/workflow-client.interface.js';
+import type { UpsertWorkflowScheduleOptions, WorkflowSchedule, WorkflowScheduleListFilter, WorkflowSchedulePreviewOptions, WorkflowSchedulePreviewSpec } from '../interfaces/workflow-schedule.interface.js';
+import type { WorkflowsModuleOptions } from '../interfaces/workflows-module-options.interface.js';
+import { WorkflowRegistry } from './workflow-registry.service.js';
+import { WorkflowScheduler } from './workflow-scheduler.service.js';
+import { WorkflowWorker } from './workflow-worker.service.js';
+/**
+ * Schedules that start workflow instances: a cron expression, an interval or an RFC 5545 rule, in a time zone.
+ * Declare them with `@Workflow(name, { schedules })`, or save them at runtime with `upsert()`; every worker that
+ * runs the workflow starts their occurrences, each exactly once. Also `WorkflowClient.schedules`.
+ */
+export declare class WorkflowSchedules {
+    private readonly registry;
+    private readonly scheduler;
+    private readonly worker;
+    private readonly clock;
+    constructor(options: WorkflowsModuleOptions, registry: WorkflowRegistry, scheduler: WorkflowScheduler, worker: WorkflowWorker);
+    /** The core's engine of schedules, over the registered store's. */
+    private get engine();
+    /**
+     * Creates or replaces the schedule with this id, and returns it. A schedule whose timing (`cron`, `every`,
+     * `rrule`, `tz`, `startAt`, `endAt`) changes starts over from now, with its first occurrence after now; one
+     * whose timing doesn't keeps its next occurrence, whatever else changes. Its runs, and whether it is paused,
+     * carry over. Throws `WorkflowStateError` for a schedule a workflow declares (change it in the code), and a
+     * `TypeError` for invalid options.
+     */
+    upsert<W>(id: string, schedule: UpsertWorkflowScheduleOptions<W>): Promise<WorkflowSchedule>;
+    /** The schedule, or `null` for an unknown id. */
+    get(id: string): Promise<WorkflowSchedule | null>;
+    /** Schedules by id, all or a workflow's; at most `limit` (default 100). */
+    list(filter?: WorkflowScheduleListFilter): Promise<WorkflowSchedule[]>;
+    /**
+     * Deletes the schedule, and returns whether it existed. The instances it started keep running. Throws
+     * `WorkflowStateError` for a schedule a workflow declares: remove it from the code, or `pause()` it.
+     */
+    remove(id: string): Promise<boolean>;
+    /**
+     * Stops starting occurrences until `resume()`, at once: a worker that is starting the schedule's occurrences at
+     * that moment starts only those it had already decided on. The instances it started keep running. A declared
+     * schedule stays paused across deploys. Throws `WorkflowNotFoundError` for an unknown id.
+     */
+    pause(id: string): Promise<WorkflowSchedule>;
+    /**
+     * Starts occurrences again, from the first one after now: those due while it was paused are passed over,
+     * whatever `missed` says. Throws `WorkflowNotFoundError` for an unknown id.
+     */
+    resume(id: string): Promise<WorkflowSchedule>;
+    /**
+     * Starts an instance of the schedule now, whatever its `overlap`, even while it is paused, and outside its
+     * `limit`; its id is `<schedule id>@<ISO time of now>`, and it counts as the schedule's for the overlap of the
+     * occurrences after it. Throws `WorkflowNotFoundError` for an unknown id.
+     */
+    trigger(id: string): Promise<WorkflowStartResult>;
+    /**
+     * The times (epoch milliseconds) of the next occurrences after `from` (default: now), at most `count` (default
+     * 10), as a schedule saved at `from` would start them: of a stored schedule (by id, within what its `limit` has
+     * left, paused or not), or of a spec, which isn't saved. Throws `WorkflowNotFoundError` for an unknown id.
+     */
+    preview(schedule: string | WorkflowSchedulePreviewSpec, options?: WorkflowSchedulePreviewOptions): Promise<number[]>;
+}