@abyss-project/tools 3.0.0 → 3.1.0

package/src/api/probe-scan.api.ts

@@ -6,13 +6,20 @@
 // add no extra path segment (`@Controller({ prefixPath: '/scan' })`), so
 // these calls hit `scan`/`scan/:id` directly — no `probe/` prefix.
 //
-// File-upload dual environment handling (browser `FormData`/`Blob` vs Node
-// `Buffer`/stream + the `form-data` package) mirrors this package's own
-// extraction.api.ts (`detect`/`postExtract`): AbyssProbe is meant to be
-// called from the abyss-main UI (a browser) as well as from Node services
-// (abyss-storage, external integrators). `form-data` is lazy-`require`d
-// (never statically imported) so a browser bundle never tries to resolve
-// the Node-only package.
+// Multipart bodies are built with the global `FormData` + `Blob` — the same
+// code in a browser and on Node, mirroring this package's own
+// extraction.api.ts. axios serializes a spec-compliant FormData on both and
+// sets the multipart boundary itself, so no content-type header is ever set by
+// hand. AbyssProbe is called from the abyss-main UI (a browser) as well as
+// from Node services (abyss-storage, external integrators).
+//
+// A Node caller holding a file ON DISK passes `await fs.openAsBlob(path)`,
+// which requires Node >= 19.8 — hence `engines.node` in package.json.
+// `FormData` and `Blob` alone would only need Node 18, but openAsBlob is this
+// client's documented way to send a file, and promising 18.x only to fail at
+// runtime is worse than refusing the install. A caller that already holds its
+// bytes passes a `Buffer`/`Uint8Array` and has no such constraint (see
+// {@link ProbeScanFileInput}).
 //
 // `authHeader`/`serializeProbeQuery` are kept LOCAL and unexported (not a
 // shared utils file) — same convention as every other extract/*.api.ts file
@@ -61,60 +68,65 @@ function serializeProbeQuery<T extends object>(query: T): Record<string, unknown
   return out;
 }
 
-/** Anything `sdk.probe.scan` accepts as the file to submit. */
-export type ProbeScanFileInput = Buffer | Uint8Array | NodeJS.ReadableStream | Blob;
-
-function isBrowserEnv(): boolean {
-  return typeof window !== 'undefined' && typeof FormData !== 'undefined';
-}
-
-async function loadNodeFormData(): Promise<any> {
-  // Indirect eval so bundlers (esbuild/vite/webpack) do not try to resolve
-  // the Node-only "form-data" package when this file is included in a
-  // browser bundle. The require only ever runs at runtime on Node.
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
-  const nodeRequire: NodeRequire = new Function('return require')();
-  return nodeRequire('form-data');
-}
+/**
+ * Anything `sdk.probe.scan` accepts as the file to submit.
+ *
+ * `Blob` covers the browser's `File` (a `Blob` subclass) and, on Node, a
+ * FILE-BACKED blob from `await fs.openAsBlob(path)` (Node >= 19.8): its bytes
+ * are read from disk as the request body is written, so scanning a file at the
+ * 2 GiB ceiling never holds the file in memory. `Uint8Array` (and therefore
+ * `Buffer`) is for a caller that already holds the bytes.
+ *
+ * A Node `Readable` is NOT accepted. The body is a spec `FormData`, whose
+ * parts must have a known length, so a stream could only be honoured by
+ * buffering it whole — precisely what a 2 GiB scan must not do. A caller
+ * holding a path passes `await fs.openAsBlob(path)` instead.
+ */
+export type ProbeScanFileInput = Blob | Uint8Array;
 
-export interface BuiltScanForm {
-  form: unknown;
-  headers: Record<string, string>;
+/**
+ * The file as one multipart part.
+ *
+ * A `Blob` is used as-is, keeping whatever streaming its implementation gives
+ * (a file-backed `openAsBlob` reads from disk lazily); raw bytes are wrapped
+ * in a `Blob` carrying `mimeType`. `Buffer` is never named here — this code
+ * also runs in a browser bundle, where the global does not exist — and
+ * `Buffer` is a `Uint8Array` subclass, so the check below already covers it.
+ *
+ * Anything else is refused with an actionable message. Until 2.12.0 the same
+ * call died on Node with `ReferenceError: require is not defined`, thrown by a
+ * `form-data` loader before any request was made (#519): it named neither the
+ * cause nor the fix.
+ */
+function toScanFilePart(file: ProbeScanFileInput, mimeType?: string): Blob {
+  if (file instanceof Blob) return file;
+  if (file instanceof Uint8Array) return new Blob([file], { type: mimeType ?? '' });
+
+  const isStream = typeof (file as { pipe?: unknown } | null | undefined)?.pipe === 'function';
+  throw new TypeError(
+    `A probe scan file must be a Blob (a browser File, or fs.openAsBlob(path) on Node), ` +
+      `a Buffer or a Uint8Array — received ${isStream ? 'a stream' : typeof file}. ` +
+      `On Node, pass \`await fs.openAsBlob(path)\`: a file-backed Blob is streamed from ` +
+      `disk, so the file is never buffered in memory.`,
+  );
 }
 
 /**
  * Exported (not just this file's own `scan` internals) so
  * probe-scan.application.api.ts reuses this EXACT multipart-building logic
- * (browser `FormData`/`Blob` vs Node `Buffer`/stream + lazy-required
- * `form-data`) rather than duplicating it — the file-upload contract is
- * identical for a personal/org caller and an application caller; only the
- * URL/auth differ (see that file's header comment).
+ * rather than duplicating it — the file-upload contract is identical for a
+ * personal/org caller and an application caller; only the URL/auth differ
+ * (see that file's header comment).
+ *
+ * Returns the form alone: axios sets the multipart content type, boundary
+ * included, so there is no header for the caller to merge in.
  */
-export async function buildScanForm(
-  file: ProbeScanFileInput,
-  options: IScanOptions,
-): Promise<BuiltScanForm> {
-  const filename = options.filename ?? 'file';
-
-  if (isBrowserEnv()) {
-    const form = new FormData();
-    const blob =
-      file instanceof Blob ? file : new Blob([file as BlobPart], { type: options.mimeType });
-    form.append('file', blob, filename);
-    if (options.context) form.append('context', JSON.stringify(options.context));
-    if (options.callbackUrl) form.append('callbackUrl', options.callbackUrl);
-    return { form, headers: {} };
-  }
-
-  const FormDataCtor = await loadNodeFormData();
-  const form = new FormDataCtor();
-  const filePart =
-    Buffer.isBuffer(file) || file instanceof Uint8Array ? Buffer.from(file as Uint8Array) : file;
-  form.append('file', filePart, { filename, contentType: options.mimeType });
+export function buildScanForm(file: ProbeScanFileInput, options: IScanOptions): FormData {
+  const form = new FormData();
+  form.append('file', toScanFilePart(file, options.mimeType), options.filename ?? 'file');
   if (options.context) form.append('context', JSON.stringify(options.context));
   if (options.callbackUrl) form.append('callbackUrl', options.callbackUrl);
-  const headers = typeof form.getHeaders === 'function' ? form.getHeaders() : {};
-  return { form, headers };
+  return form;
 }
 
 /**
@@ -134,11 +146,11 @@ export const scan = async (
   options: IScanOptions = {},
   apiKey?: string,
 ): Promise<IScanResponse> => {
-  const { form, headers } = await buildScanForm(file, options);
+  const form = buildScanForm(file, options);
   return (
     await AbyssToolsCore.axios.post<IScanResponse>('scan', form, {
       params: serializeProbeQuery({ mode: options.mode, organizationId: options.organizationId }),
-      headers: { ...headers, ...authHeader(apiKey) },
+      headers: authHeader(apiKey),
       maxBodyLength: Infinity,
       maxContentLength: Infinity,
     })

package/src/api/probe-scan.application.api.test.ts

@@ -18,4 +18,18 @@ void _scanAsync;
 void _getScan;
 void _listScans;
 
+// The application client takes the SAME file input as the personal one (it
+// reuses buildScanForm verbatim) — abyss-storage, its main caller, hands over
+// `await fs.openAsBlob(path)`. A stream is refused at compile time (#519); see
+// probe-scan.api.test.ts for the full input matrix.
+declare const blob: Blob;
+declare const stream: NodeJS.ReadableStream;
+
+const _fromBlob: Parameters<typeof api.scanSyncApplication>[1] = blob;
+// @ts-expect-error a Readable stream is not an accepted scan input since 2.12.0
+const _fromStream: Parameters<typeof api.scanSyncApplication>[1] = stream;
+
+void _fromBlob;
+void _fromStream;
+
 export {};

package/src/api/probe-scan.application.api.ts

@@ -8,9 +8,9 @@
 // (abyss-storage, external integrations) authenticating with a project API
 // key instead of a personal/org session.
 //
-// Reuses probe-scan.api.ts's `buildScanForm` (same dual-environment
-// multipart handling — browser `FormData`/`Blob` vs Node `Buffer`/stream +
-// lazy-required `form-data`) and every request/response TYPE verbatim
+// Reuses probe-scan.api.ts's `buildScanForm` (the global `FormData` + `Blob`,
+// one code path for the browser and for Node — see that file's header for what
+// a Node caller passes) and every request/response TYPE verbatim
 // (`IScanOptions`, `IListScansQuery`, `IScanResponse`, `IScanSyncResponse`,
 // `IScanAsyncResponse`, `IGetScanResponse`, `IPaginateScanResponse`) — never
 // redefined here. `organizationId` is `Omit`'d from every option/query type
@@ -79,11 +79,11 @@ export const scanApplication = async (
   options: Omit<IScanOptions, 'organizationId'> = {},
   applicationApiKey?: string,
 ): Promise<IScanResponse> => {
-  const { form, headers } = await buildScanForm(file, options);
+  const form = buildScanForm(file, options);
   return (
     await AbyssToolsCore.axios.post<IScanResponse>(`application/${applicationId}/scan`, form, {
       params: serializeProbeQuery({ mode: options.mode }),
-      headers: { ...headers, ...authHeaderApplication(applicationApiKey) },
+      headers: authHeaderApplication(applicationApiKey),
       maxBodyLength: Infinity,
       maxContentLength: Infinity,
     })

package/src/api/retrospective.api.ts

@@ -23,7 +23,9 @@ export const getRetrospective = async (
   params: IGetRetrospectiveParams,
 ): Promise<IGetRetrospectiveResponse> => {
   return (
-    await AbyssToolsCore.axios.get<IGetRetrospectiveResponse>(`retrospective/${params.retrospectiveId}`)
+    await AbyssToolsCore.axios.get<IGetRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+    )
   ).data;
 };
 
@@ -52,7 +54,8 @@ export const paginateRetrospective = async (
 export const createRetrospective = async (
   body: ICreateRetrospectiveBody,
 ): Promise<ICreateRetrospectiveResponse> => {
-  return (await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body)).data;
+  return (await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body))
+    .data;
 };
 
 export const createForOrganizationRetrospective = async (
@@ -113,9 +116,9 @@ export const transferRetrospective = async (
   ).data;
 };
 
-export const countOrganizationRetrospective = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
+export const countOrganizationRetrospective = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
   return (
     await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `retrospective/organization/${params.organizationId}/count`,

package/src/api/short-link.admin.api.ts

@@ -15,12 +15,17 @@ export const shortLinkAdminApi = {
   paginate: async (
     query: IPaginateShortLinkAdminQuery,
   ): Promise<IPaginateShortLinkAdminResponse> => {
-    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkAdminResponse>('/admin/short-link/paginate', { params: query });
+    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkAdminResponse>(
+      '/admin/short-link/paginate',
+      { params: query },
+    );
     return response.data;
   },
 
   get: async (params: IGetShortLinkAdminParams): Promise<IGetShortLinkAdminResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`);
+    const response = await AbyssToolsCore.axios.get<IGetShortLinkAdminResponse>(
+      `/admin/short-link/${params.shortLinkId}`,
+    );
     return response.data;
   },
 
@@ -28,12 +33,17 @@ export const shortLinkAdminApi = {
     params: IUpdateShortLinkAdminParams,
     body: IUpdateShortLinkAdminBody,
   ): Promise<IUpdateShortLinkAdminResponse> => {
-    const response = await AbyssToolsCore.axios.put<IUpdateShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`, body);
+    const response = await AbyssToolsCore.axios.put<IUpdateShortLinkAdminResponse>(
+      `/admin/short-link/${params.shortLinkId}`,
+      body,
+    );
     return response.data;
   },
 
   delete: async (params: IDeleteShortLinkAdminParams): Promise<IDeleteShortLinkAdminResponse> => {
-    const response = await AbyssToolsCore.axios.delete<IDeleteShortLinkAdminResponse>(`/admin/short-link/${params.shortLinkId}`);
+    const response = await AbyssToolsCore.axios.delete<IDeleteShortLinkAdminResponse>(
+      `/admin/short-link/${params.shortLinkId}`,
+    );
     return response.data;
   },
 };

package/src/api/short-link.api.ts

@@ -27,12 +27,17 @@ import type {
 
 export const shortLinkApi = {
   get: async (params: IGetShortLinkParams): Promise<IGetShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetShortLinkResponse>(`/short-link/${params.shortLinkId}`);
+    const response = await AbyssToolsCore.axios.get<IGetShortLinkResponse>(
+      `/short-link/${params.shortLinkId}`,
+    );
     return response.data;
   },
 
   paginate: async (query: IPaginateShortLinkQuery): Promise<IPaginateShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkResponse>('/short-link/paginate', { params: query });
+    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkResponse>(
+      '/short-link/paginate',
+      { params: query },
+    );
     return response.data;
   },
 
@@ -40,9 +45,12 @@ export const shortLinkApi = {
     params: IPaginateProjectShortLinkParams,
     query: IPaginateShortLinkQuery,
   ): Promise<IPaginateShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkResponse>(`/short-link/project/${params.projectId}/paginate`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IPaginateShortLinkResponse>(
+      `/short-link/project/${params.projectId}/paginate`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
@@ -55,7 +63,10 @@ export const shortLinkApi = {
     params: ICreateForOrganizationShortLinkParams,
     body: ICreateShortLinkBody,
   ): Promise<ICreateShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.post<ICreateShortLinkResponse>(`/short-link/organization/${params.organizationId}`, body);
+    const response = await AbyssToolsCore.axios.post<ICreateShortLinkResponse>(
+      `/short-link/organization/${params.organizationId}`,
+      body,
+    );
     return response.data;
   },
 
@@ -63,12 +74,17 @@ export const shortLinkApi = {
     params: IUpdateShortLinkParams,
     body: IUpdateShortLinkBody,
   ): Promise<IUpdateShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.put<IUpdateShortLinkResponse>(`/short-link/${params.shortLinkId}`, body);
+    const response = await AbyssToolsCore.axios.put<IUpdateShortLinkResponse>(
+      `/short-link/${params.shortLinkId}`,
+      body,
+    );
     return response.data;
   },
 
   delete: async (params: IDeleteShortLinkParams): Promise<IDeleteShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.delete<IDeleteShortLinkResponse>(`/short-link/${params.shortLinkId}`);
+    const response = await AbyssToolsCore.axios.delete<IDeleteShortLinkResponse>(
+      `/short-link/${params.shortLinkId}`,
+    );
     return response.data;
   },
 
@@ -76,9 +92,12 @@ export const shortLinkApi = {
     params: IGetStatsShortLinkParams,
     query?: IGetStatsShortLinkQuery,
   ): Promise<IGetStatsShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetStatsShortLinkResponse>(`/short-link/${params.shortLinkId}/stats`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IGetStatsShortLinkResponse>(
+      `/short-link/${params.shortLinkId}/stats`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
@@ -86,9 +105,12 @@ export const shortLinkApi = {
     params: IGetClicksShortLinkParams,
     query?: IGetClicksShortLinkQuery,
   ): Promise<IGetClicksShortLinkResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetClicksShortLinkResponse>(`/short-link/${params.shortLinkId}/clicks`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IGetClicksShortLinkResponse>(
+      `/short-link/${params.shortLinkId}/clicks`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
@@ -114,9 +136,9 @@ export const shortLinkApi = {
     return response.data;
   },
 
-  countOrganization: async (
-    params: { organizationId: string },
-  ): Promise<ICountOrganizationResponse> => {
+  countOrganization: async (params: {
+    organizationId: string;
+  }): Promise<ICountOrganizationResponse> => {
     const response = await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `/short-link/organization/${params.organizationId}/count`,
     );

package/src/api/short-link.public.api.ts

@@ -19,7 +19,10 @@ export const shortLinkPublicApi = {
   createAnonymous: async (
     body: ICreateAnonymousShortLinkPublicBody,
   ): Promise<ICreateShortLinkPublicResponse> => {
-    const response = await AbyssToolsCore.axios.post<ICreateShortLinkPublicResponse>('/short-link/public', body);
+    const response = await AbyssToolsCore.axios.post<ICreateShortLinkPublicResponse>(
+      '/short-link/public',
+      body,
+    );
     return response.data;
   },
 
@@ -27,9 +30,12 @@ export const shortLinkPublicApi = {
     params: IRedirectShortLinkPublicParams,
     query?: IRedirectShortLinkPublicQuery,
   ): Promise<IRedirectShortLinkPublicResponse> => {
-    const response = await AbyssToolsCore.axios.get<IRedirectShortLinkPublicResponse>(`/short-link/public/redirect/${params.slug}`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IRedirectShortLinkPublicResponse>(
+      `/short-link/public/redirect/${params.slug}`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
@@ -37,9 +43,12 @@ export const shortLinkPublicApi = {
     params: IGetStatsShortLinkPublicParams,
     query?: IGetStatsShortLinkPublicQuery,
   ): Promise<IGetStatsShortLinkPublicResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetStatsShortLinkPublicResponse>(`/short-link/public/${params.shortLinkId}/stats`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IGetStatsShortLinkPublicResponse>(
+      `/short-link/public/${params.shortLinkId}/stats`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
@@ -47,14 +56,19 @@ export const shortLinkPublicApi = {
     params: IGetClicksShortLinkPublicParams,
     query?: IGetClicksShortLinkPublicQuery,
   ): Promise<IGetClicksShortLinkPublicResponse> => {
-    const response = await AbyssToolsCore.axios.get<IGetClicksShortLinkPublicResponse>(`/short-link/public/${params.shortLinkId}/clicks`, {
-      params: query,
-    });
+    const response = await AbyssToolsCore.axios.get<IGetClicksShortLinkPublicResponse>(
+      `/short-link/public/${params.shortLinkId}/clicks`,
+      {
+        params: query,
+      },
+    );
     return response.data;
   },
 
   renew: async (params: IRenewShortLinkPublicParams): Promise<IRenewShortLinkPublicResponse> => {
-    const response = await AbyssToolsCore.axios.post<IRenewShortLinkPublicResponse>(`/short-link/public/${params.shortLinkId}/renew`);
+    const response = await AbyssToolsCore.axios.post<IRenewShortLinkPublicResponse>(
+      `/short-link/public/${params.shortLinkId}/renew`,
+    );
     return response.data;
   },
 };

package/src/api/tag.api.ts

@@ -63,7 +63,9 @@ export const getTagStats = async (query?: ITagStatsQuery): Promise<ITagStatsResp
   return (await AbyssToolsCore.axios.get<ITagStatsResponse>('tag/stats', { params: query })).data;
 };
 
-export const getEntityTags = async (params: IGetEntityTagsParams): Promise<IGetEntityTagsResponse> => {
+export const getEntityTags = async (
+  params: IGetEntityTagsParams,
+): Promise<IGetEntityTagsResponse> => {
   return (
     await AbyssToolsCore.axios.get<IGetEntityTagsResponse>(
       `${params.entityType}/${params.entityId}/tags`,

package/src/constants/atlas.constants.ts

@@ -1,2 +1,2 @@
 export const MAX_DOCUMENTS_PER_ATLAS_PAGE = 20;
-export const MAX_ATLAS_DOCUMENT_SIZE_OCTET = 20 * 1024 * 1024; // 20 MB
+export const MAX_ATLAS_DOCUMENT_SIZE_OCTET = 100 * 1024 * 1024; // 100 MB

package/src/constants/extract.constants.ts

@@ -0,0 +1,109 @@
+import { DocumentType } from '../types/enum/document-type.enum';
+import { ExtractFieldFormat } from '../types/enum/extract-field-format.enum';
+import { ExtractFieldKey } from '../types/enum/extract-field-key.enum';
+
+const { AMOUNT, DATE, PERCENT, BOOLEAN, TEXT } = ExtractFieldFormat;
+
+// ──────────────────────────────────────────────
+// EXTRACT_PUBLISHABLE_FIELDS — the fields the built-in algorithmic
+// interpreter of AbyssExtract can publish, per document type, with the format
+// of their value. A field listed here may be absent from a given result (not
+// found, or below its publish floor); a field not listed here is never
+// published for that type by that interpreter. A learned template
+// (spatial-template interpreter) publishes the keys its client defined, on any
+// type.
+//
+// One exception: a valid machine-readable zone publishes its fields and
+// `mrzValid` whatever the document type (listed here under `id_card` only).
+//
+// `generic` is absent: its fields are defined by the client. The extraction API
+// tests that this list equals what its engine serves, type by type.
+// ──────────────────────────────────────────────
+export const EXTRACT_PUBLISHABLE_FIELDS: Readonly<
+  Record<
+    Exclude<DocumentType, DocumentType.GENERIC>,
+    Readonly<Partial<Record<ExtractFieldKey, ExtractFieldFormat>>>
+  >
+> = Object.freeze({
+  [DocumentType.BANK_STATEMENT]: Object.freeze({
+    [ExtractFieldKey.IBAN]: TEXT,
+    [ExtractFieldKey.BIC]: TEXT,
+    [ExtractFieldKey.BANK_NAME]: TEXT,
+    [ExtractFieldKey.OPENING_BALANCE]: AMOUNT,
+    [ExtractFieldKey.CLOSING_BALANCE]: AMOUNT,
+    [ExtractFieldKey.PERIOD_START]: DATE,
+    [ExtractFieldKey.PERIOD_END]: DATE,
+    [ExtractFieldKey.CURRENCY]: TEXT,
+  }),
+  [DocumentType.INVOICE]: Object.freeze({
+    [ExtractFieldKey.TOTAL_TTC]: AMOUNT,
+    [ExtractFieldKey.TOTAL_HT]: AMOUNT,
+    [ExtractFieldKey.TOTAL_VAT]: AMOUNT,
+    [ExtractFieldKey.INVOICE_DATE]: DATE,
+    [ExtractFieldKey.DUE_DATE]: DATE,
+    [ExtractFieldKey.INVOICE_NUMBER]: TEXT,
+    [ExtractFieldKey.SUPPLIER]: TEXT,
+    [ExtractFieldKey.SUPPLIER_LEGAL_NAME]: TEXT,
+    [ExtractFieldKey.MARKETPLACE]: TEXT,
+    [ExtractFieldKey.SIRET]: TEXT,
+    [ExtractFieldKey.SIREN]: TEXT,
+    [ExtractFieldKey.VAT_NUMBER]: TEXT,
+    [ExtractFieldKey.IBAN]: TEXT,
+    [ExtractFieldKey.BIC]: TEXT,
+    [ExtractFieldKey.CURRENCY]: TEXT,
+  }),
+  [DocumentType.RECEIPT]: Object.freeze({
+    [ExtractFieldKey.TOTAL]: AMOUNT,
+    [ExtractFieldKey.VAT]: AMOUNT,
+    [ExtractFieldKey.DATE]: DATE,
+    [ExtractFieldKey.MERCHANT]: TEXT,
+    [ExtractFieldKey.CURRENCY]: TEXT,
+  }),
+  [DocumentType.ID_CARD]: Object.freeze({
+    [ExtractFieldKey.LAST_NAME]: TEXT,
+    [ExtractFieldKey.FIRST_NAMES]: TEXT,
+    [ExtractFieldKey.BIRTH_DATE]: DATE,
+    [ExtractFieldKey.EXPIRY_DATE]: DATE,
+    [ExtractFieldKey.ISSUE_DATE]: DATE,
+    [ExtractFieldKey.DOCUMENT_NUMBER]: TEXT,
+    [ExtractFieldKey.SEX]: TEXT,
+    [ExtractFieldKey.NATIONALITY]: TEXT,
+    [ExtractFieldKey.ISSUING_COUNTRY]: TEXT,
+    [ExtractFieldKey.DOCUMENT_KIND]: TEXT,
+    [ExtractFieldKey.MRZ_VALID]: BOOLEAN,
+  }),
+  [DocumentType.RIB]: Object.freeze({
+    [ExtractFieldKey.IBAN]: TEXT,
+    [ExtractFieldKey.BIC]: TEXT,
+    [ExtractFieldKey.HOLDER_NAME]: TEXT,
+    [ExtractFieldKey.BANK_NAME]: TEXT,
+  }),
+  [DocumentType.FINANCIAL_STATEMENT]: Object.freeze({
+    [ExtractFieldKey.COMPANY]: TEXT,
+    [ExtractFieldKey.SIREN]: TEXT,
+    [ExtractFieldKey.REGISTRATION_NUMBER]: TEXT,
+    [ExtractFieldKey.FISCAL_YEAR_END]: DATE,
+    [ExtractFieldKey.TOTAL_ACTIF]: AMOUNT,
+    [ExtractFieldKey.TOTAL_PASSIF]: AMOUNT,
+    [ExtractFieldKey.FIXED_ASSETS]: AMOUNT,
+    [ExtractFieldKey.CURRENT_ASSETS]: AMOUNT,
+    [ExtractFieldKey.CREDITORS_WITHIN_ONE_YEAR]: AMOUNT,
+    [ExtractFieldKey.NET_CURRENT_LIABILITIES]: AMOUNT,
+    [ExtractFieldKey.TOTAL_ASSETS_LESS_CURRENT_LIABILITIES]: AMOUNT,
+    [ExtractFieldKey.NET_ASSETS]: AMOUNT,
+    [ExtractFieldKey.CALLED_UP_SHARE_CAPITAL]: AMOUNT,
+    [ExtractFieldKey.PROFIT_AND_LOSS_ACCOUNT]: AMOUNT,
+    [ExtractFieldKey.TOTAL_SHAREHOLDERS_FUNDS]: AMOUNT,
+    [ExtractFieldKey.CURRENCY]: TEXT,
+  }),
+  [DocumentType.PAYSLIP]: Object.freeze({
+    [ExtractFieldKey.EMPLOYER]: TEXT,
+    [ExtractFieldKey.PERIOD]: TEXT,
+    [ExtractFieldKey.GROSS_CENTS]: AMOUNT,
+    [ExtractFieldKey.NET_CENTS]: AMOUNT,
+    [ExtractFieldKey.NET_TAXABLE_CENTS]: AMOUNT,
+    [ExtractFieldKey.PAS_AMOUNT_CENTS]: AMOUNT,
+    [ExtractFieldKey.PAS_RATE_PCT]: PERCENT,
+    [ExtractFieldKey.CURRENCY]: TEXT,
+  }),
+});

package/src/constants/index.ts

@@ -3,3 +3,4 @@ export * from './board.constants';
 export * from './short-link.constants';
 export * from './tag.constants';
 export * from './beam.constants';
+export * from './extract.constants';

package/src/index.ts

@@ -28,6 +28,7 @@ import * as metricsApi from './api/metrics.api';
 import * as organizationApi from './api/organization.api';
 import * as tagApi from './api/tag.api';
 import * as extractionApi from './api/extraction.api';
+import * as extractionApplicationApi from './api/extraction.application.api';
 import * as extractionSettingsApi from './api/extraction-settings.api';
 import * as extractionPlanPresetApi from './api/extraction-plan-preset.api';
 import * as monitorApi from './api/monitor.api';
@@ -254,6 +255,7 @@ type AbyssToolsCoreSDK = {
     getUploadPreSignedUrl: typeof atlasDocumentApi.getUploadPreSignedUrlAtlasDocument;
     paginate: typeof atlasDocumentApi.paginateAtlasDocument;
     list: typeof atlasDocumentApi.listAtlasDocument;
+    getPublicAccessId: typeof atlasDocumentApi.getPublicAccessIdAtlasDocument;
   };
   shortLink: {
     get: typeof shortLinkApiModule.shortLinkApi.get;
@@ -405,6 +407,19 @@ type AbyssToolsCoreSDK = {
     run: typeof extractionApi.extractSync;
     runQueue: typeof extractionApi.extractQueue;
     runBulk: typeof extractionApi.extractBulk;
+    /**
+     * Application/API-key-auth counterpart — for a backend satellite (e.g.
+     * AbyssBanking) triggering a SYNCHRONOUS extraction server-side with its
+     * APPLICATION api key: the run is OWNED by the application and BILLED to
+     * its resolved owning organization (never an end user). Hits
+     * `/extract/application/:applicationId/extract`, authenticated with the
+     * `abyss-api-key-application` header ({@link API_KEY_APPLICATION_HEADER})
+     * instead of the personal `abyss-api-key`. Does NOT change the personal `run`.
+     */
+    application: {
+      /** `POST /extract/application/:applicationId/extract` — synchronous; owned + billed to the app's org. */
+      run: typeof extractionApplicationApi.runExtractionApplication;
+    };
     files: {
       list: typeof extractionApi.listFiles;
       listShared: typeof extractionApi.listSharedFiles;
@@ -696,6 +711,7 @@ export class AbyssToolsCore {
         getUploadPreSignedUrl: atlasDocumentApi.getUploadPreSignedUrlAtlasDocument,
         paginate: atlasDocumentApi.paginateAtlasDocument,
         list: atlasDocumentApi.listAtlasDocument,
+        getPublicAccessId: atlasDocumentApi.getPublicAccessIdAtlasDocument,
       },
       shortLink: {
         get: shortLinkApiModule.shortLinkApi.get,
@@ -823,6 +839,9 @@ export class AbyssToolsCore {
         run: extractionApi.extractSync,
         runQueue: extractionApi.extractQueue,
         runBulk: extractionApi.extractBulk,
+        application: {
+          run: extractionApplicationApi.runExtractionApplication,
+        },
         files: {
           list: extractionApi.listFiles,
           listShared: extractionApi.listSharedFiles,