@nestjs/workflows 0.0.1

package/dist/core/interfaces/limits.interface.d.ts

@@ -0,0 +1,92 @@
+import type { Duration } from '../time/duration.js';
+/**
+ * A concurrency limit, in the family's words: at most `limit` run at once across every worker, of the whole (a
+ * workflow, a queue), or with `key`, per key. A package takes one, or an array of one without a key and one with,
+ * and checks them with `resolveConcurrency()`. A run holds its slot while its lease is live, not while it waits.
+ *
+ * ```ts
+ * const concurrency: ConcurrencyLimit<Order>[] = [{ limit: 20 }, { limit: 1, key: (order) => order.customerId }];
+ * ```
+ */
+export interface ConcurrencyLimit<I = any> {
+    /** A positive integer: how many may run at once, of the whole, or with `key`, per key. */
+    limit: number;
+    /**
+     * Makes `limit` a limit per key: the key of a run, computed from its (JSON) input when it is created, such as
+     * `(order) => order.customerId`. `null` or `undefined` leaves it out of every key.
+     */
+    key?: (input: I) => string | null | undefined;
+}
+/**
+ * A rate limit, in the family's words: at most `max` starts per window of `duration`, of the whole, or with `key`,
+ * per key. A window opens with the first start after the previous one ended and lasts `duration` (BullMQ's limiter),
+ * so up to `2 * max` can start around a window's end. `resolveRateLimit()` checks one, or an array of one without a
+ * key and one with.
+ *
+ * ```ts
+ * const rateLimit: RateLimit<Order>[] = [{ max: 100, duration: '1m' }, { max: 5, duration: '1m', key: (order) => order.customerId }];
+ * ```
+ */
+export interface RateLimit<I = any> {
+    /** A positive integer: how many may start per `duration`, of the whole, or with `key`, per key. */
+    max: number;
+    /** The window, such as `'1m'`. */
+    duration: Duration;
+    /** Makes the limit a limit per key, as `ConcurrencyLimit.key` does. */
+    key?: (input: I) => string | null | undefined;
+}
+/**
+ * A rate limit's window, resolved: at most `max` starts per `duration` milliseconds.
+ *
+ * ```ts
+ * const window: RateWindow = { max: 10, duration: 60_000 };
+ * ```
+ */
+export interface RateWindow {
+    max: number;
+    duration: number;
+}
+/**
+ * Concurrency limits as `resolveConcurrency()` returns them: the whole's limit and the per-key one (`null`: none),
+ * and the function that computes a run's key.
+ *
+ * ```ts
+ * const { limit, perKey, key } = resolveConcurrency('queue "emails"', definition.concurrency);
+ * ```
+ */
+export interface ResolvedConcurrency<I = any> {
+    /** At most this many of the whole run at once, or `null`. */
+    limit: number | null;
+    /** At most this many per key, or `null`. */
+    perKey: number | null;
+    /** The key of a run, from its input. */
+    key?: (input: I) => string | null | undefined;
+}
+/**
+ * Rate limits as `resolveRateLimit()` returns them: the whole's window and the per-key one (`null`: none), and the
+ * function that computes a run's key.
+ *
+ * ```ts
+ * const { limit, perKey, key } = resolveRateLimit('queue "emails"', definition.rateLimit);
+ * ```
+ */
+export interface ResolvedRateLimit<I = any> {
+    /** The window of the whole, or `null`. */
+    limit: RateWindow | null;
+    /** Each key's window, or `null`. */
+    perKey: RateWindow | null;
+    /** The key of a run, from its input. */
+    key?: (input: I) => string | null | undefined;
+}
+/**
+ * A rate-limit window as a store keeps it: when it ends (epoch milliseconds), and how many starts it holds. A window
+ * that ended is the same as none.
+ *
+ * ```ts
+ * const window: RateWindowState = { windowEnd: now + 60_000, count: 1 };
+ * ```
+ */
+export interface RateWindowState {
+    windowEnd: number;
+    count: number;
+}

package/dist/core/interfaces/limits.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/payload-codec.interface.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Where a payload is stored, which a codec receives with it, the same to encode and to decode: `field` names what
+ * holds it, and the other keys say where that is (ids). A codec that authenticates the payload (`AesGcmPayloadCodec`
+ * does) binds it to its context, and refuses it once it was moved to another place.
+ *
+ * ```ts
+ * const context: PayloadContext = { field: 'data', queue: 'emails', job: 'order-confirmation-42' };
+ * ```
+ */
+export interface PayloadContext {
+    /** The field that holds the payload, such as `'input'` or `'data'`. */
+    readonly field: string;
+    /** Where that field is: the ids of what holds it, such as `instanceId` and `entry`, or `queue` and `job`. */
+    readonly [key: string]: string | undefined;
+}
+/**
+ * Encodes what a package stores for the application before its store sees it, to encrypt or compress it, and decodes
+ * it on the way back. `PayloadCodecs` wraps what it returns in the family's envelope, with its `id`, so a codec that
+ * was replaced keeps decoding what it encoded. `@nestjs/workflows` takes one as `WorkflowPayloadCodec`.
+ *
+ * ```ts
+ * class Base64Codec implements PayloadCodec {
+ *   readonly id = 'base64';
+ *
+ *   encode(value: unknown): string {
+ *     return Buffer.from(JSON.stringify(value)).toString('base64');
+ *   }
+ *
+ *   decode(data: string): unknown {
+ *     return JSON.parse(Buffer.from(data, 'base64').toString());
+ *   }
+ * }
+ * ```
+ */
+export interface PayloadCodec<C extends PayloadContext = PayloadContext> {
+    /**
+     * Stored with every payload the codec encodes, to pick the codec that decodes it: letters, digits, `.`, `_` and
+     * `-`, such as `'aes-256-gcm'` (`plain` is the envelope's own). Keep it when you change the codec's options; change
+     * it with a codec that can't read what this one wrote.
+     */
+    readonly id: string;
+    /**
+     * `value` as a string (it is JSON-safe: what `JSON.parse(JSON.stringify(...))` gives). Synchronous where it can be:
+     * an asynchronous codec delays a write in the application's transaction past its first await, which a driver whose
+     * transactions run synchronously can't take.
+     */
+    encode(value: unknown, context: C): string | Promise<string>;
+    /** The value `encode()` got (or a promise of it), from what it returned. Throw if `data` isn't what it encoded for `context`. */
+    decode(data: string, context: C): unknown;
+}
+/**
+ * An error as the family stores it: JSON-safe, its class's `name` kept apart from what may hold the application's
+ * data (`message`, `stack`), which `PayloadCodecs.encodeError()` encodes. A nested error (workflows' `compensation`)
+ * is another `SerializedError` in a field of its own.
+ *
+ * ```ts
+ * const failure: SerializedError = { name: 'CardDeclinedError', message: 'Card 4242 was declined.' };
+ * ```
+ */
+export interface SerializedError {
+    name: string;
+    message: string;
+    stack?: string;
+}

package/dist/core/interfaces/payload-codec.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/result-waiter-options.interface.d.ts

@@ -0,0 +1,52 @@
+import type { Duration } from '../time/duration.js';
+/**
+ * How something ended, for `ResultWaiter`: its value, or the error its waits reject with (a failure, or "not
+ * found").
+ *
+ * ```ts
+ * const outcome: ResultOutcome<Report> = row.state === 'completed' ? { value: row.result } : { error: new JobFailedError(row) };
+ * ```
+ */
+export type ResultOutcome<T> = {
+    value: T;
+} | {
+    error: unknown;
+};
+/**
+ * What `ResultWaiter` takes: how to read an outcome from the store, and the errors its waits reject with.
+ *
+ * ```ts
+ * const results = new ResultWaiter<unknown>({
+ *   read: async (id) => {
+ *     const job = await store.get(id);
+ *     return !job ? { error: new JobNotFoundError(id) } : job.state === 'completed' ? { value: job.result } : null;
+ *   },
+ *   timeoutError: (id, timeoutMs) => new JobResultTimeoutError(id, timeoutMs),
+ *   closedError: (id) => new Error(`The application shut down while waiting for the result of job "${id}".`),
+ * });
+ * ```
+ */
+export interface ResultWaiterOptions<T> {
+    /**
+     * Reads the outcome from the store: `null` while it hasn't ended. Called when a wait starts, then after a backoff
+     * (25 ms at first, doubling up to a second), until the wait ends; a rejection rejects the wait.
+     */
+    read(id: string): Promise<ResultOutcome<T> | null>;
+    /** The error a wait rejects with past its `timeout`. Default: an `Error` that names `id`. */
+    timeoutError?(id: string, timeoutMs: number): Error;
+    /** The error a wait rejects with once the waiter closed (the application shuts down). Default: an `Error` that names `id`. */
+    closedError?(id: string): Error;
+}
+/**
+ * What `ResultWaiter.wait()` takes.
+ *
+ * ```ts
+ * await results.wait(job.id, { timeout: '30s', signal: request.signal });
+ * ```
+ */
+export interface ResultWaitOptions {
+    /** Stop waiting after this long, in wall-clock time (not a `Clock`'s). Default: no limit. */
+    timeout?: Duration;
+    /** Stop waiting when it aborts: the wait rejects with its reason. */
+    signal?: AbortSignal;
+}

package/dist/core/interfaces/result-waiter-options.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/retry-settings.interface.d.ts

@@ -0,0 +1,71 @@
+import type { Duration } from '../time/duration.js';
+/**
+ * The wait between attempts, in the family's retry vocabulary: `delay`, growing by `factor` per retry up to
+ * `maxDelay`, optionally randomized (`jitter`). Named so it doesn't clash with `@nestjs/resilience`'s
+ * `BackoffOptions`, which owns the unprefixed name.
+ *
+ * ```ts
+ * const backoff: BackoffSettings = { delay: '1s', factor: 2, maxDelay: '5m', jitter: 'full' };
+ * ```
+ */
+export interface BackoffSettings {
+    /** Wait before the first retry. Default `'1s'`. */
+    delay?: Duration;
+    /** Growth per retry; 1 = constant. Default 2. */
+    factor?: number;
+    /** Cap for a single wait. Default `'5m'`. */
+    maxDelay?: Duration;
+    /** Randomize each wait: `'full'` (0 to the wait), `'equal'` (half to all of it) or `'none'`. Default `'none'`. */
+    jitter?: 'full' | 'equal' | 'none';
+}
+/**
+ * How an operation retries, in the family's retry vocabulary: a package takes `retry?: number | false |
+ * RetrySettings` (`5` means `{ attempts: 5 }`, `false` a single attempt) and exports it under its own name
+ * (`WorkflowRetryOptions`); `resolveRetry()` checks it. `attempt` arguments are 1-based: the attempt that just failed.
+ *
+ * ```ts
+ * const retry: RetrySettings = {
+ *   attempts: 5,
+ *   backoff: { delay: '2s', jitter: 'equal' },
+ *   retryIf: (error) => !(error instanceof ValidationError),
+ * };
+ * ```
+ */
+export interface RetrySettings {
+    /** Total attempts, including the first. Default 3. */
+    attempts?: number;
+    /**
+     * Wait between attempts. An object is merged field by field over the default; a function receives the attempt
+     * that just failed (1-based) and its error, and returns the wait.
+     */
+    backoff?: BackoffSettings | ((attempt: number, error: unknown) => Duration);
+    /** Return false to stop retrying. Gets the error and the attempt that just failed (1-based). */
+    retryIf?: (error: unknown, attempt: number) => boolean;
+}
+/**
+ * `BackoffSettings`, checked, with every field set: times in milliseconds.
+ *
+ * ```ts
+ * const backoff: ResolvedBackoff = { delay: 1_000, factor: 2, maxDelay: 300_000, jitter: 'none' };
+ * backoffDelay(backoff, 3); // 4_000
+ * ```
+ */
+export interface ResolvedBackoff {
+    delay: number;
+    factor: number;
+    maxDelay: number;
+    jitter: 'full' | 'equal' | 'none';
+}
+/**
+ * A retry policy as `resolveRetry()` returns it: checked, with every field set. A backoff function's `Duration` is
+ * converted to milliseconds.
+ *
+ * ```ts
+ * const policy: ResolvedRetry = resolveRetry({ attempts: 5 });
+ * ```
+ */
+export interface ResolvedRetry {
+    attempts: number;
+    backoff: ResolvedBackoff | ((attempt: number, error: unknown) => number);
+    retryIf?: (error: unknown, attempt: number) => boolean;
+}

package/dist/core/interfaces/retry-settings.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/schedule-store.interface.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Where schedules live, for the core's `Scheduler`: any store can implement it (SQL, a Redis store as scripts), and
+ * `scheduleStoreContract()` from `@nestjs/workflows/testing` checks one, races included. `InMemoryScheduleStore` is
+ * the in-memory one. A schedule's `spec`, `payload` and `state` are the scheduler's JSON: keep them as they are.
+ *
+ * Three methods need more than a plain read or write: `claimSchedules` (a lock that skips rows other claims hold),
+ * `writeSchedule` (fenced by the lease token) and `saveSchedule` (conditional on a revision). Everything else is safe
+ * to implement naively.
+ *
+ * ```ts
+ * export class RedisScheduleStore implements ScheduleStore {
+ *   async claimSchedules(request: ScheduleClaimRequest): Promise<ScheduleRecord[]> {
+ *     // One script: due ids by wakeAt (ZRANGEBYSCORE), skipping leased ones, leased to request.token.
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+export interface ScheduleStore {
+    /**
+     * Stores a schedule, as one conditional write, and returns it as stored, or `null` when the condition fails. With
+     * `expectRevision: null`, inserts it unless a schedule with the id exists (revision 1, `createdAt = now`); with a
+     * number, replaces every field of the one whose `revision` is that number (revision + 1). Either way sets
+     * `updatedAt = now`; with `releaseLease`, clears its lease, so the worker that holds it can't `writeSchedule()` any
+     * more. Of two concurrent saves expecting the same revision, one lands.
+     */
+    saveSchedule(schedule: ScheduleSave): Promise<ScheduleRecord | null>;
+    /** The schedule, or `null` for an unknown id. */
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** Schedules matching the filter, ordered by `id`; a page of them. */
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
+    /** Deletes the schedule (if its `revision` is still `revision`, when given), and returns whether it did. */
+    deleteSchedule(id: string, revision?: number): Promise<boolean>;
+    /**
+     * Leases up to `limit` due schedules to a worker, most overdue first (`wakeAt`, then `id`). Due: not paused,
+     * `wakeAt <= now`, no lease or an expired one (`leaseUntil < now`), and `target` in `targets`. Each gets
+     * `leaseToken = token`, `leaseOwner = owner` and `leaseUntil`; nothing else changes (not `revision`). Two
+     * concurrent claims never return the same schedule: lock the candidates and skip those another claim holds.
+     */
+    claimSchedules(request: ScheduleClaimRequest): Promise<ScheduleRecord[]>;
+    /**
+     * The lease holder's write: sets `state` and `wakeAt`, `revision + 1` and `updatedAt = now`, and with `release`
+     * clears the lease (`leaseToken`, `leaseUntil`), only while `token` is the schedule's lease token; otherwise writes
+     * nothing and returns `false`. One conditional update.
+     */
+    writeSchedule(id: string, token: string, write: ScheduleWrite): Promise<boolean>;
+}
+/**
+ * A schedule as stored: `ScheduleStore.getSchedule()`, `listSchedules()` and `claimSchedules()` return it.
+ *
+ * ```ts
+ * const due = await store.claimSchedules({ owner, token, now, leaseUntil, limit: 100, targets: ['emails'] });
+ * ```
+ */
+export interface ScheduleRecord {
+    id: string;
+    /** What it starts runs of, such as a workflow's or a queue's name (claims filter on it). */
+    target: string;
+    /** Declared in the code (kept in step with it), rather than saved at runtime. */
+    declared: boolean;
+    /** The scheduler's JSON: when it runs and how. Store it as it is. */
+    spec: unknown;
+    /** What the runs it starts get (JSON: a string with a codec), or `null`. */
+    payload: unknown;
+    paused: boolean;
+    /** When a worker next has something to do for it (`claimSchedules()` looks for `wakeAt <= now`), or `null`. */
+    wakeAt: number | null;
+    /** The scheduler's JSON bookkeeping. Store it as it is. */
+    state: unknown;
+    /** Bumped by every `saveSchedule()` and `writeSchedule()`. */
+    revision: number;
+    leaseOwner: string | null;
+    leaseUntil: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * What `ScheduleStore.saveSchedule()` receives.
+ *
+ * ```ts
+ * await store.saveSchedule({ ...fields, id: 'weekly-digest', expectRevision: current?.revision ?? null, releaseLease: false, now });
+ * ```
+ */
+export interface ScheduleSave {
+    id: string;
+    target: string;
+    declared: boolean;
+    spec: unknown;
+    payload: unknown;
+    paused: boolean;
+    wakeAt: number | null;
+    state: unknown;
+    /** `null`: insert it, if no schedule has the id. A number: replace the one whose `revision` is still this. */
+    expectRevision: number | null;
+    /** Clear the schedule's lease (a change to when it runs: the lease holder's work is outdated). */
+    releaseLease: boolean;
+    now: number;
+}
+/**
+ * What `ScheduleStore.listSchedules()` receives.
+ *
+ * ```ts
+ * await store.listSchedules({ target: 'emails', declared: true, limit: 100, offset: 0 });
+ * ```
+ */
+export interface ScheduleQuery {
+    target?: string;
+    /** Only the declared ones (`true`), or only the others (`false`). */
+    declared?: boolean;
+    limit: number;
+    offset: number;
+}
+/**
+ * What `ScheduleStore.claimSchedules()` receives.
+ *
+ * ```ts
+ * await store.claimSchedules({ owner: 'pod-1', token: randomUUID(), now, leaseUntil: now + 30_000, limit: 100, targets: ['emails'] });
+ * ```
+ */
+export interface ScheduleClaimRequest {
+    owner: string;
+    token: string;
+    now: number;
+    leaseUntil: number;
+    /** At least 1. */
+    limit: number;
+    /** The targets this worker runs (at least one): it starts only their schedules' runs. */
+    targets: string[];
+}
+/**
+ * What `ScheduleStore.writeSchedule()` receives.
+ *
+ * ```ts
+ * await store.writeSchedule(id, token, { now, state, wakeAt: next, release: true });
+ * ```
+ */
+export interface ScheduleWrite {
+    now: number;
+    state: unknown;
+    wakeAt: number | null;
+    /** Hand the schedule back: clear its lease. */
+    release: boolean;
+}

package/dist/core/interfaces/schedule-store.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/interfaces/schedule.interface.d.ts

@@ -0,0 +1,106 @@
+import type { Duration } from '../time/duration.js';
+/**
+ * When a schedule's occurrences are: exactly one of `cron`, `every` or `rrule`, with its time zone and bounds. Times
+ * are wall-clock times in `tz`: on the day clocks go forward, a time that doesn't exist runs that much later (02:30
+ * runs at 03:30); on the day they go back, a time that happens twice runs once, the first time. For a fixed interval
+ * whatever the clocks do, use `every` (or `tz: 'UTC'`).
+ *
+ * ```ts
+ * const timing: ScheduleTiming = { cron: '0 0 8 * * MON', tz: 'Europe/Warsaw' };
+ * ```
+ */
+export interface ScheduleTiming {
+    /**
+     * A cron expression: 5 fields (minute, hour, day of month, month, day of week) or 6 (seconds first), such as
+     * `'0 8 * * MON'` or `'0 0 8 * * MON'`. Ranges, steps, lists, names (`JAN`, `MON-FRI`), `L` (the last day of
+     * the month; `5L` the last Friday), `#` (`1#2`: the second Monday) and `@daily`-style nicknames. When both
+     * the day of month and the day of week are restricted, a day matching either runs, as in cron.
+     */
+    cron?: string;
+    /** A fixed interval of at least a second, counted from `startAt` (default: the Unix epoch), whatever `tz` says. */
+    every?: Duration;
+    /**
+     * An RFC 5545 recurrence rule: FREQ, INTERVAL, COUNT, UNTIL, WKST, BYMONTH, BYMONTHDAY, BYDAY (with ordinals:
+     * `-1FR`), BYHOUR, BYMINUTE and BYSECOND, such as `'FREQ=MONTHLY;BYDAY=-1FR;BYHOUR=17'`. `startAt` is its
+     * DTSTART (default: midnight, 1 January 1970, in `tz`), whose fields fill the parts the rule leaves out (so
+     * give BYHOUR and BYMINUTE), and COUNT counts from it (so COUNT needs a `startAt`).
+     */
+    rrule?: string;
+    /** The IANA time zone of `cron` and `rrule`, such as `'Europe/Warsaw'`. Default `'UTC'`. */
+    tz?: string;
+    /** No occurrence before it. With `every`, the first occurrence; with `rrule`, its DTSTART. */
+    startAt?: Date | number;
+    /** No occurrence after it. */
+    endAt?: Date | number;
+}
+/**
+ * What a schedule does with occurrences no worker was up to start (a deploy, an outage): `'skip'` them (only an
+ * occurrence found within a minute of its time starts), start the latest of them `'once'`, or start `'all'` of
+ * them at once (the latest 100 at most; it needs `overlap: 'allow'`).
+ *
+ * ```ts
+ * const missed: ScheduleMissed = 'once';
+ * ```
+ */
+export type ScheduleMissed = 'skip' | 'once' | 'all';
+/**
+ * What an occurrence does while a run the schedule started is still unfinished: `'skip'` it, `'allow'` it (both run),
+ * `'cancel-previous'` (the running one is cancelled while the new one starts), or `'buffer-one'` (it starts once the
+ * running one ends; one occurrence waits at most, later ones are skipped).
+ *
+ * ```ts
+ * const overlap: ScheduleOverlap = 'buffer-one';
+ * ```
+ */
+export type ScheduleOverlap = 'skip' | 'allow' | 'cancel-previous' | 'buffer-one';
+/**
+ * A schedule's timing and policies, as a package takes them (it adds its own, such as workflows' `priority`):
+ * `parseSchedule()` checks them.
+ *
+ * ```ts
+ * const schedule: ScheduleOptions = { rrule: 'FREQ=WEEKLY;BYDAY=MO;BYHOUR=8', tz: 'Europe/Warsaw', missed: 'once', limit: 52 };
+ * ```
+ */
+export interface ScheduleOptions extends ScheduleTiming {
+    /** The most occurrences it starts, after which it ends. Default: none. */
+    limit?: number;
+    /** Default `'skip'`. */
+    missed?: ScheduleMissed;
+    /** Default `'skip'`. */
+    overlap?: ScheduleOverlap;
+}
+/**
+ * A schedule's options, checked, as `parseSchedule()` returns them and a `ScheduleStore` keeps them (`spec`, JSON):
+ * one of `cron`, `every` (milliseconds) or `rrule`, times in epoch milliseconds, defaults applied. A package adds
+ * fields of its own, which the `Scheduler` keeps and compares with the rest.
+ *
+ * ```ts
+ * const spec: ScheduleSpec = parseSchedule({ every: '15m' });
+ * // { every: 900_000, tz: 'UTC', startAt: null, endAt: null, limit: null, missed: 'skip', overlap: 'skip' }
+ * ```
+ */
+export interface ScheduleSpec {
+    cron?: string;
+    every?: number;
+    rrule?: string;
+    tz: string;
+    startAt: number | null;
+    endAt: number | null;
+    limit: number | null;
+    missed: ScheduleMissed;
+    overlap: ScheduleOverlap;
+}
+/**
+ * An occurrence of a schedule: what a declared schedule's payload function receives. The run it starts has the id
+ * `occurrenceId(id, at)`.
+ *
+ * ```ts
+ * const data = ({ at }: ScheduleOccurrence) => ({ week: isoWeek(new Date(at)) });
+ * ```
+ */
+export interface ScheduleOccurrence {
+    /** The schedule's id. */
+    id: string;
+    /** When the occurrence was due (epoch milliseconds), also when it starts later (`missed`, `'buffer-one'`) or was triggered (then: when). */
+    at: number;
+}

package/dist/core/interfaces/schedule.interface.js

@@ -0,0 +1 @@
+export {};