nucleus-core-ts 0.9.781 → 0.9.783

package/dist/src/Services/Integrations/lock.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Making sure one mapping imports at a time, across every replica.
+ *
+ * Two runs of the same mapping overlapping is not a performance problem, it is a
+ * correctness one: both read the same "what is already here", both decide the
+ * same rows are missing, and both act on that decision. Under a `delete` policy
+ * that removes rows the second run has already re-created.
+ *
+ * ## Why not `RedisManager.acquireLock` directly
+ *
+ * That helper stores a literal `'1'`, so `releaseLock` cannot tell whose lock it
+ * is deleting. If run A stalls long enough for its lock to expire and run B takes
+ * it, A finishing normally then deletes B's lock and a third run walks straight
+ * in. The holder here writes a token and checks it before releasing, so a lock it
+ * no longer owns is left alone.
+ *
+ * ## Why it renews
+ *
+ * A fixed TTL has to be either longer than the slowest import — in which case a
+ * crashed pod blocks the mapping for that long — or shorter, in which case a
+ * healthy long import loses its lock halfway. Renewing on a timer gives both: the
+ * TTL stays short, and a holder that dies simply stops renewing.
+ */
+import type { Logger } from '../Logger';
+type RedisResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/** The slice of the Redis manager this needs. */
+export type LockStore = {
+    create<T>(key: string, value: T, ttlSeconds?: number): Promise<RedisResult<'OK'>>;
+    read<T>(key: string): Promise<RedisResult<T | null>>;
+    update<T>(key: string, value: T, preserveTtl?: boolean): Promise<RedisResult<'OK'>>;
+    remove(key: string): Promise<RedisResult<number>>;
+    exists(key: string): Promise<RedisResult<boolean>>;
+};
+export type LockHandle = {
+    /** Stops renewing and releases, but only if this holder still owns the lock. */
+    release: () => Promise<void>;
+    /** False once a renewal has found the lock owned by somebody else. */
+    isHeld: () => boolean;
+    token: string;
+};
+export type AcquireResult = {
+    ok: true;
+    handle: LockHandle;
+} | {
+    ok: false;
+    reason: 'held';
+    heldSince: number | null;
+} | {
+    ok: false;
+    reason: 'unavailable';
+    error: string;
+};
+/** Short by design — a dead holder should block the mapping for seconds, not hours. */
+export declare const LOCK_TTL_SECONDS = 60;
+/** Renew well inside the TTL so one slow renewal does not lose the lock. */
+export declare const RENEW_INTERVAL_MS = 20000;
+export declare const lockKeyFor: (mappingId: string) => string;
+/**
+ * Takes the lock for a mapping, or reports who holds it.
+ *
+ * Redis being unreachable is reported as `unavailable`, NOT as "free". Treating a
+ * broken lock service as an open door is how two runs end up deleting each
+ * other's records — the caller decides whether to proceed, and for a destructive
+ * write mode the answer should be no.
+ */
+export declare function acquireRunLock(store: LockStore, mappingId: string, deps?: {
+    logger?: Logger;
+    now?: () => number;
+    ttlSeconds?: number;
+}): Promise<AcquireResult>;
+export {};

package/dist/src/Services/Integrations/lock.test.d.ts

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

package/dist/src/Services/Integrations/mapping.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Turning a third-party record into one of our rows. Pure — no I/O, no database,
+ * no config. Everything here is a function of its arguments, so the rules that
+ * decide what lands in a column can be tested without a server or a source.
+ */
+import type { FieldMapping, MappedRecord, MappingTransform, RunIssue } from './types';
+/** Reads a possibly-nested value by dot-path (`a.b.c`). */
+export declare function getByPath(obj: unknown, path: string): unknown;
+/**
+ * Pulls the record array out of a response body.
+ *
+ * `rootPath` always wins. Without one we look for the usual envelope keys, then
+ * fall back to a bounded search for the first array of objects anywhere in the
+ * body — plenty of APIs wrap their list under a name nobody would guess.
+ *
+ * A rootPath that points at a single object yields that object as one record,
+ * because "fetch this one thing" is a legitimate endpoint.
+ *
+ * Never throws. An unrecognisable body yields no records, and the caller decides
+ * whether that is an error — for a root endpoint it is; for a child call in a
+ * fan-out it may just mean this particular parent has none.
+ */
+export declare function extractRecords(body: unknown, rootPath?: string | null): unknown[];
+/**
+ * The outcome of one transform.
+ *
+ * A failed conversion is reported rather than silently becoming null. "The HR
+ * system sent `N/A` where a number was expected" and "the field was empty" are
+ * different facts, and only the first one is worth an operator's attention — the
+ * old engine collapsed both to null and neither reached anyone.
+ */
+export type TransformResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    reason: string;
+    raw: unknown;
+};
+/** Applies one transform. `none`/unknown returns the value untouched. */
+export declare function applyTransform(value: unknown, transform?: MappingTransform): TransformResult;
+/**
+ * Maps ONE external record onto a row.
+ *
+ * `parent`, when present, is exposed to mappings under the `__parent` prefix so a
+ * child record fetched per-parent can carry its parent's fields — e.g. the company
+ * name that produced this employee. Without it a fan-out loses the very thing that
+ * distinguishes one batch from the next.
+ */
+export declare function mapRecord(external: unknown, mappings: readonly FieldMapping[], parent?: unknown): {
+    row: Record<string, unknown>;
+    problems: string[];
+};
+/** Maps a batch, carrying dedup keys and per-record problems out with it. */
+export declare function buildMappedRecords(externalRecords: readonly unknown[], mappings: readonly FieldMapping[], dedupTargetField?: string | null, parents?: readonly unknown[]): {
+    records: MappedRecord[];
+    issues: RunIssue[];
+};
+/**
+ * Dot-paths of a record's leaf fields, for the mapping screen's field picker.
+ * Capped in both breadth and depth — this feeds a dropdown, not an analysis.
+ */
+export declare function flattenKeys(obj: unknown, prefix?: string, out?: string[], depth?: number): string[];

package/dist/src/Services/Integrations/mapping.test.d.ts

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

package/dist/src/Services/Integrations/oauth.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Minting and reusing OAuth2 bearer tokens for a source.
+ *
+ * Supports the two grants a server-to-server integration actually uses:
+ * `client_credentials`, and the resource-owner `password` grant that Keycloak
+ * deployments still hand out for service accounts. An access token is short-lived
+ * by design, so it is cached and renewed rather than re-minted per request.
+ *
+ * ## The cache key includes the credentials
+ *
+ * Keying only by source id — which is what the engine this replaces did — means
+ * that after an operator corrects a wrong password, the cached token minted with
+ * the OLD one keeps being used until it expires. The integration goes on failing
+ * for up to an hour after it was fixed, and nothing on screen explains why.
+ * Hashing the credentials into the key makes a corrected credential a cache miss
+ * immediately.
+ *
+ * The hash is one-way: the cache key never holds the secret itself.
+ */
+import { type FetchImpl } from './fetcher';
+export type OAuthGrant = 'password' | 'client_credentials';
+export type OAuthConfig = {
+    sourceId: string;
+    tokenUrl: string;
+    grantType: OAuthGrant;
+    clientId?: string | null;
+    /** Decrypted. */
+    clientSecret?: string | null;
+    username?: string | null;
+    /** Decrypted. */
+    password?: string | null;
+    scope?: string | null;
+    /** How client credentials are presented: an HTTP Basic header, or form fields. */
+    clientAuth?: 'basic' | 'body';
+    tlsVerify?: boolean;
+    timeoutMs?: number;
+};
+export type CachedToken = {
+    accessToken: string;
+    expiresAt: number;
+    refreshToken?: string;
+    refreshExpiresAt?: number;
+    /** Fingerprint of the credentials this token was minted with. */
+    fingerprint: string;
+};
+export type TokenResult = {
+    ok: true;
+    accessToken: string;
+    fromCache: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * One-way fingerprint of everything that changes which token a config produces.
+ *
+ * The token URL is included: pointing a source at a different realm must not
+ * reuse the previous realm's token.
+ */
+export declare function credentialFingerprint(config: OAuthConfig): string;
+/** In-memory token cache. Per process — a token is not worth sharing across pods. */
+export declare class TokenCache {
+    private readonly entries;
+    /**
+     * The stored token for a source, or null when there is none or the credentials
+     * have changed since it was minted. Expiry is NOT checked here — the caller
+     * distinguishes "expired but refreshable" from "unusable", and this cannot.
+     */
+    get(sourceId: string, fingerprint: string): CachedToken | null;
+    set(sourceId: string, token: CachedToken): void;
+    /** Drops a source's token — used by "test connection", which must mint fresh. */
+    invalidate(sourceId: string): void;
+    clear(): void;
+}
+/** Builds the form body and headers for one token request. */
+export declare function buildTokenRequest(config: OAuthConfig, form: URLSearchParams): {
+    headers: Record<string, string>;
+    body: string;
+};
+/**
+ * Returns a usable bearer for a source.
+ *
+ * Order: a cached token that is still valid → a refresh exchange (which does not
+ * re-send the service account's password) → a full grant.
+ */
+export declare function getAccessToken(config: OAuthConfig, cache: TokenCache, deps?: {
+    fetchImpl?: FetchImpl;
+    now?: () => number;
+}): Promise<TokenResult>;

package/dist/src/Services/Integrations/oauth.test.d.ts

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

package/dist/src/Services/Integrations/pagination.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Walking a paged endpoint.
+ *
+ * Pure: given the profile an operator chose, the walk so far, and what the last
+ * response contained, this decides whether to ask for another page and how. No
+ * fetching happens here.
+ *
+ * ## Why the profile is chosen, never guessed
+ *
+ * The old engine issued ONE request and treated whatever came back as the whole
+ * dataset. Against a Spring API that defaults to 20 records per page, importing
+ * a 10.000-row table in wipe-and-replace mode deleted 10.000 rows, wrote 20, and
+ * reported success. Guessing wrong is indistinguishable from a small dataset, so
+ * the profile is a deliberate answer and `none` genuinely means "one request".
+ *
+ * ## Why every stop condition is explicit
+ *
+ * A paging walk that fails to terminate is worse than one that stops early: it
+ * hammers somebody else's production API. Each profile below ends on a positive
+ * signal (a short page, an exhausted total, a missing cursor) and the whole walk
+ * is additionally bounded by {@link MAX_PAGES}.
+ */
+import type { PaginationProfile } from './types';
+/**
+ * Hard ceiling on requests for one endpoint walk.
+ *
+ * Reaching it is reported as a failure rather than treated as the end of the
+ * data — a truncated read that looks complete is exactly what makes a destructive
+ * import destroy records it never saw.
+ */
+export declare const MAX_PAGES = 1000;
+/** Default page size when the operator did not choose one. */
+export declare const DEFAULT_PAGE_SIZE = 200;
+/** How far the walk has got. Owned by the caller, advanced by {@link nextPage}. */
+export type PageState = {
+    /** Pages already fetched. */
+    pagesFetched: number;
+    /** Records already collected across all pages. */
+    recordsFetched: number;
+    /** Cursor used for the page just fetched, for the repeat-cursor check. */
+    cursor?: string | null;
+};
+/** What the last response looked like, as far as paging is concerned. */
+export type PageObservation = {
+    /** Records extracted from this page. */
+    recordCount: number;
+    /** Parsed response body, for reading total/last/cursor paths. */
+    body: unknown;
+    /** Raw `Link` header, for the RFC 8288 profile. */
+    linkHeader?: string | null;
+};
+/** The next request to make, or the reason the walk is over. */
+export type NextRequest = {
+    kind: 'done';
+    reason: string;
+} | {
+    kind: 'params';
+    params: Record<string, string>;
+} | {
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'failed';
+    reason: string;
+};
+export declare const initialState: () => PageState;
+/** Query parameters for the FIRST request of a walk. */
+export declare function firstPageParams(profile: PaginationProfile): Record<string, string>;
+/**
+ * The total the source claims to hold, when the profile names a path to it and
+ * the value is a non-negative number. Returns null when unknown — which is not
+ * an error, only a case where the completeness check cannot run.
+ */
+export declare function reportedTotal(profile: PaginationProfile, body: unknown): number | null;
+/**
+ * Decides the next request after observing a page.
+ *
+ * The caller advances `state` (pagesFetched, recordsFetched, cursor) before the
+ * next call; this function only reads it.
+ */
+export declare function nextPage(profile: PaginationProfile, state: PageState, observed: PageObservation): NextRequest;
+/**
+ * Extracts the `rel="next"` URL from an RFC 8288 `Link` header.
+ *
+ * Tolerant of the shapes seen in the wild: single or double quotes around the
+ * rel value, no quotes at all, extra parameters, and several links in one header.
+ * Returns null when there is no next link — which is how this profile ends.
+ */
+export declare function parseNextLink(header: string | null | undefined): string | null;
+/**
+ * Is what we fetched everything the source says it has?
+ *
+ * Only meaningful when the source reports a total. The gate this feeds refuses a
+ * DESTRUCTIVE run on a mismatch: deleting rows the import never fetched is the
+ * one failure that cannot be undone by running it again.
+ */
+export declare function isComplete(fetched: number, reported: number | null): boolean;

package/dist/src/Services/Integrations/pagination.test.d.ts

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

package/dist/src/Services/Integrations/plan.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Deciding what a run would do — before it does any of it.
+ *
+ * Pure. Given the mapped records, the rows already in the target table, the write
+ * mode and the missing-record policy, this produces the exact list of creates,
+ * updates, deletes and deactivations. The transaction that follows executes this
+ * list and makes no decisions of its own.
+ *
+ * The split matters for two reasons. The preview screen and the real run share
+ * this function, so what an operator is shown is what will happen rather than a
+ * second implementation that drifts. And every rule about destroying data is
+ * testable here without a database.
+ */
+import type { MappedRecord, MissingRecordPolicy, RunIssue, RunPlan, WriteMode } from './types';
+/** A row already in the target table. */
+export type ExistingRow = {
+    id: string;
+    row: Record<string, unknown>;
+};
+export type CreateOp = {
+    data: Record<string, unknown>;
+    sourceIndex: number;
+};
+export type UpdateOp = {
+    id: string;
+    data: Record<string, unknown>;
+    before: Record<string, unknown>;
+    sourceIndex: number;
+};
+/** Exactly what to execute. Nothing here needs interpreting. */
+export type WriteOperations = {
+    creates: CreateOp[];
+    updates: UpdateOp[];
+    /** Rows to remove — from `replace`, or from the `delete` missing policy. */
+    deletes: ExistingRow[];
+    /** Rows to mark inactive because the source no longer carries them. */
+    deactivates: ExistingRow[];
+    issues: RunIssue[];
+    warnings: string[];
+};
+export type PlanInput = {
+    records: readonly MappedRecord[];
+    /** Every row currently in the target table. */
+    existing: readonly ExistingRow[];
+    /** Target column that identifies the same record across runs, if configured. */
+    dedupTargetField: string | null;
+    writeMode: WriteMode;
+    missingPolicy: MissingRecordPolicy;
+    /** Column and value written when the policy is `deactivate`. */
+    missingColumn?: string | null;
+    missingValue?: string | null;
+    /** NOT NULL, no-default columns of the target — a row missing one cannot be written. */
+    requiredFields?: readonly string[];
+};
+/**
+ * Works out every write a run would perform.
+ *
+ * Records are processed in source order so an issue's `sourceIndex` always points
+ * at the record an operator can find in the sample.
+ */
+export declare function planWrites(input: PlanInput): WriteOperations;
+/** Applies the deactivation column/value to a row's update payload. */
+export declare function deactivationPayload(missingColumn: string, missingValue: string): Record<string, unknown>;
+/** Turns the operations into the summary a preview screen renders. */
+export declare function summarize(ops: WriteOperations, meta: {
+    targetEntity: string;
+    writeMode: WriteMode;
+    missingPolicy: MissingRecordPolicy;
+    totalFetched: number;
+    reportedTotal: number | null;
+    existingCount: number;
+    dedupConfigured: boolean;
+    sampleSize?: number;
+}): RunPlan;

package/dist/src/Services/Integrations/plan.test.d.ts

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

package/dist/src/Services/Integrations/revert.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Undoing a run that already succeeded.
+ *
+ * A failed run needs nothing undone — its transaction rolled back. This is for
+ * the other case: the import worked, and afterwards somebody noticed the data was
+ * wrong. Bad records at the source, a mapping pointed at the wrong column, the
+ * wrong endpoint. Until now there was no way back from that at all; a wipe-and-
+ * replace ran and the previous contents were simply gone.
+ *
+ * ## Reversing, not re-importing
+ *
+ * Each before-image is turned back into its own opposite: a row this run created
+ * is deleted, a row it changed is written back to what it was, a row it deleted
+ * is put back. All in one transaction, so a revert is as all-or-nothing as the
+ * run it undoes.
+ *
+ * ## Somebody else's edit is not ours to discard
+ *
+ * Between the run and the revert, a person may have edited one of these rows by
+ * hand. Writing the before-image over that would destroy their work while
+ * appearing to be a safe undo. So a row whose current state no longer matches
+ * what the run left behind is reported as a conflict and skipped — unless the
+ * operator explicitly asks to overwrite it, having been told which rows.
+ */
+import type { PreImage, WriterDeps } from './writer';
+export type RevertOperations = {
+    /** Rows the run created, to be removed again. */
+    deletes: string[];
+    /** Rows to be written back to their previous contents. */
+    restores: {
+        id: string;
+        row: Record<string, unknown>;
+    }[];
+    /** Rows the run deleted, to be inserted again. */
+    reinserts: Record<string, unknown>[];
+    /** Rows changed since the run; not touched. */
+    conflicts: {
+        id: string;
+        reason: string;
+    }[];
+};
+export type RevertPlanInput = {
+    preImages: readonly PreImage[];
+    /** Current contents of every row the run touched, by id. Absent = already gone. */
+    current: ReadonlyMap<string, Record<string, unknown>>;
+    /** Overwrite rows that changed since the run, having reported them first. */
+    force?: boolean;
+    /** Columns excluded from the changed-since check — they move on every write. */
+    ignoreColumns?: readonly string[];
+};
+/**
+ * Works out how to undo a run. Pure — every rule about whose data may be
+ * overwritten is decided here and testable without a database.
+ */
+export declare function planRevert(input: RevertPlanInput): RevertOperations;
+export type RevertResult = {
+    ok: true;
+    deleted: number;
+    restored: number;
+    reinserted: number;
+    conflicts: number;
+} | {
+    ok: false;
+    error: string;
+    conflicts: number;
+};
+/**
+ * Applies a revert plan in one transaction.
+ *
+ * Order mirrors the run it undoes: removals first, so an identifier or unique
+ * value freed here is available to the re-inserts that follow.
+ */
+export declare function applyRevert(deps: WriterDeps, ops: RevertOperations, meta: {
+    targetEntity: string;
+    userId: string;
+}): Promise<RevertResult>;
+/** Ids a caller must read the current state of before planning a revert. */
+export declare function touchedRowIds(preImages: readonly PreImage[]): string[];

package/dist/src/Services/Integrations/revert.test.d.ts

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

package/dist/src/Services/Integrations/runner.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Running an import, start to finish.
+ *
+ * The order below is the whole design. Everything is fetched, mapped, planned and
+ * validated before a single row is written, and the write itself is one
+ * transaction. There is no state in which a run has half-happened.
+ *
+ * ```
+ *   lock          one run per mapping, across replicas
+ *   collect       every endpoint, in dependency order, all pages
+ *   completeness  refuse a destructive run that did not read everything
+ *   map           external records → our columns
+ *   plan          creates / updates / deletes / deactivations
+ *   apply         ONE transaction; any failure unwinds it
+ *   record        before-images, counts, and the run row
+ * ```
+ *
+ * Every step reports progress and checks for cancellation, because a chained
+ * import can legitimately take minutes and an operator who changes their mind
+ * must be able to stop it — not merely close the tab and hope.
+ */
+import type { Logger } from '../Logger';
+import { type EndpointSpec } from './collect';
+import type { FetchImpl, SourceConnection } from './fetcher';
+import { type OAuthConfig, type TokenCache } from './oauth';
+import { type ExistingRow } from './plan';
+import type { FieldMapping, MissingRecordPolicy, RunFailure, RunIssue, RunPlan, RunProgress, WriteMode } from './types';
+import { type PreImage, type WriterDeps } from './writer';
+/** The mapping being run, resolved from the database by the caller. */
+export type MappingSpec = {
+    id: string;
+    name: string;
+    targetEntity: string;
+    fieldMappings: FieldMapping[];
+    dedupTargetField: string | null;
+    writeMode: WriteMode;
+    missingPolicy: MissingRecordPolicy;
+    missingColumn?: string | null;
+    missingValue?: string | null;
+};
+/** Everything a run needs, already read and decrypted. */
+export type RunContext = {
+    mapping: MappingSpec;
+    /** The endpoint this mapping reads, plus every endpoint it depends on. */
+    endpoints: EndpointSpec[];
+    /** Which of `endpoints` the mapping itself maps from. */
+    rootEndpointId: string;
+    source: SourceConnection;
+    /** Present only when the source authenticates with OAuth2. */
+    oauth?: OAuthConfig | null;
+    userId: string;
+    trigger: 'manual' | 'schedule' | 'api';
+};
+/** Persistence and lookups the runner needs. Injected so it can be tested. */
+export type RunRepository = {
+    openRun(input: {
+        mappingId: string;
+        targetEntity: string;
+        writeMode: WriteMode;
+        trigger: string;
+        userId: string;
+    }): Promise<{
+        ok: true;
+        runId: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    closeRun(runId: string, patch: Record<string, unknown>): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    savePreImages(runId: string, images: PreImage[]): Promise<void>;
+    /** True once a cancel request has been recorded for this run. */
+    isCancelRequested(runId: string): Promise<boolean>;
+    /** Every row currently in the target table. */
+    readExistingRows(targetEntity: string): Promise<ExistingRow[]>;
+    /** Distinct values of one column, for an `entity` parameter binding. */
+    readEntityColumn(entity: string, field: string): Promise<unknown[]>;
+    /** NOT NULL, no-default columns of the target. */
+    requiredFields(targetEntity: string): string[];
+};
+export type RunnerDeps = {
+    repo: RunRepository;
+    writer: WriterDeps;
+    logger: Logger;
+    tokenCache: TokenCache;
+    fetchImpl?: FetchImpl;
+    publishProgress?: (progress: RunProgress) => void;
+    /**
+     * Called once the run record exists, before any work starts.
+     *
+     * A caller that answers 202 needs the identifier immediately and must not wait
+     * for the import. Racing a timer against the run would be a guess; this is the
+     * moment the identifier actually becomes real.
+     */
+    onRunOpened?: (runId: string) => void;
+    maxRecordsPerRun?: number;
+    maxConcurrentFanout?: number;
+    retainPreImagesMs?: number;
+    /** External cancellation, e.g. the process shutting down. */
+    abortSignal?: AbortSignal;
+};
+export type RunOutcome = {
+    runId: string | null;
+    status: 'succeeded' | 'failed' | 'cancelled';
+    failure: RunFailure | null;
+    plan: RunPlan | null;
+    created: number;
+    updated: number;
+    deleted: number;
+    deactivated: number;
+    externalCalls: number;
+    issues: RunIssue[];
+};
+/**
+ * Fetches everything, decides everything, then writes it once.
+ *
+ * Returns rather than throws: a failed import is an outcome an operator reads,
+ * not an exception for a route handler to translate.
+ */
+export declare function executeRun(context: RunContext, deps: RunnerDeps, lock: {
+    isHeld: () => boolean;
+}): Promise<RunOutcome>;

package/dist/src/Services/Integrations/runner.test.d.ts

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