@abyss-project/extract 0.0.0-stage → 1.0.0

package/src/api/extraction.application.api.test.ts

@@ -0,0 +1,55 @@
+// Type-level compile test for the APPLICATION extract client (#581).
+// No jest runner in this SDK package; compile guard only (mirrors
+// probe-scan.application.api.test.ts). Run: npx tsc --noEmit, or `npm run build`.
+
+import * as api from './extraction.application.api';
+import type { IExtractApplicationBody } from '../types';
+
+const _run: typeof api.runExtractionApplication = api.runExtractionApplication;
+void _run;
+
+type Body = Parameters<typeof api.runExtractionApplication>[1];
+declare const pdf: Buffer;
+
+// What the route accepts: a PDF, mode auto|hint, and the optional fields.
+const _minimal: Body = { pdf, mode: 'auto' };
+const _full: Body = {
+  pdf,
+  mode: 'hint',
+  hint: { bank: 'bnp' },
+  pdf_filename: 'invoice.pdf',
+  user_external_id: 'u-1',
+  user_metadata: { a: 1 },
+  archive: true,
+  force: false,
+  improvementConsent: true,
+};
+const _named: IExtractApplicationBody = _minimal;
+void _minimal;
+void _full;
+void _named;
+
+// What the route refuses with a 4xx must not compile.
+// @ts-expect-error the route only accepts a multipart PDF
+const _noPdf: Body = { mode: 'auto' };
+// @ts-expect-error storage_file_id is refused by the application route
+const _storage: Body = { pdf, mode: 'auto', storage_file_id: 'f' };
+// @ts-expect-error template_id is refused by the application route
+const _templateId: Body = { pdf, mode: 'auto', template_id: 't' };
+// @ts-expect-error template is refused by the application route
+const _template: Body = { pdf, mode: 'auto', template: {} };
+// @ts-expect-error plan_preset_id is refused by the application route
+const _preset: Body = { pdf, mode: 'auto', plan_preset_id: 'p' };
+// @ts-expect-error mode template is refused by the application route
+const _modeTemplate: Body = { pdf, mode: 'template' };
+// @ts-expect-error the application route is synchronous only
+const _processing: Body = { pdf, mode: 'auto', processing: 'queue' };
+void _noPdf;
+void _storage;
+void _templateId;
+void _template;
+void _preset;
+void _modeTemplate;
+void _processing;
+
+export {};

package/src/api/extraction.application.api.ts

@@ -0,0 +1,73 @@
+// ──────────────────────────────────────────────
+// AbyssExtract APPLICATION extract API — POST
+// /extract/application/:applicationId/extract. Mirrors
+// apps/api/src/api/controllers/extraction-extract-application.controller.ts
+// EXACTLY — the application counterpart of extraction.api.ts's `extractSync`,
+// for inter-service callers (e.g. AbyssBanking) authenticating with a project
+// API key instead of a personal/org session.
+//
+// Reuses extraction.api.ts's `buildExtractMultipart` (the same global
+// `FormData` + `Blob` multipart body as the personal client) and the
+// response TYPE verbatim (`IExtractSyncResponse`) — never redefined here.
+// The request body is `IExtractApplicationBody`, a narrower type than the
+// personal client's `IExtractBody`: it types exactly what this route accepts
+// (#581) — see extraction.request.ts. There is NO scope query param: unlike
+// the personal/org route's `?organization_id=`, an application caller's scope
+// is entirely its `:applicationId` URL segment, resolved server-side by
+// ApplicationMiddleware (round-trips to abyss-main).
+//
+// `authHeaderApplication` is kept LOCAL and unexported, same convention as the
+// personal client's own `authHeader` — it sends `API_KEY_APPLICATION_HEADER`
+// (`abyss-api-key-application`) instead of the personal `abyss-api-key`.
+//
+// The endpoint is SYNCHRONOUS (the machine caller gets the extraction inline —
+// no queue), so the return is always the `IExtractSyncResponse` shape.
+// ──────────────────────────────────────────────
+
+import { AbyssExtractCore, API_KEY_APPLICATION_HEADER } from '..';
+import type { IExtractApplicationBody } from '../types';
+import type { IExtractSyncResponse } from '../types';
+import { buildExtractMultipart, ExtractCallOptions } from './extraction.api';
+
+function authHeaderApplication(applicationApiKey?: string): Record<string, string> {
+  return applicationApiKey ? { [API_KEY_APPLICATION_HEADER]: applicationApiKey } : {};
+}
+
+/**
+ * `POST /extract/application/:applicationId/extract` — run one synchronous
+ * extraction OWNED by `applicationId` and BILLED to its resolved owning
+ * organization. The route accepts only a multipart PDF upload: send
+ * `body.pdf`, with `body.mode` `auto` or `hint`; `body.plan` (inline, single
+ * pass, no OCR, no template pass) and `body.improvementConsent` travel as
+ * multipart fields. The route refuses `storage_file_id`, `plan_preset_id`,
+ * `template_id` and `template` with a 4xx. A body without `pdf` never reaches
+ * the route at all: `IExtractApplicationBody` requires it, and this client's
+ * `buildExtractMultipart` throws locally ("buildExtractMultipart requires
+ * body.pdf") before any request is sent (#581). The memory watchdog may still
+ * answer 503 on a well-formed call, before the route reads the body.
+ * `options` forwards a Stripe-style
+ * `Idempotency-Key` header (24h replay window) when set — replayed only for
+ * the IDENTICAL request; the same key sent with another document or another
+ * body answers 422 `IDEMPOTENCY_KEY_REUSED` (see `ExtractCallOptions`).
+ */
+export const runExtractionApplication = async (
+  applicationId: string,
+  body: IExtractApplicationBody,
+  options: ExtractCallOptions = {},
+  applicationApiKey?: string,
+): Promise<IExtractSyncResponse> => {
+  const extraHeaders: Record<string, string> = {};
+  if (options.idempotencyKey) {
+    extraHeaders['Idempotency-Key'] = options.idempotencyKey;
+  }
+  const url = `extract/application/${applicationId}/extract`;
+
+  const form = buildExtractMultipart(body);
+  return (
+    await AbyssExtractCore.axios.post<IExtractSyncResponse>(url, form, {
+      headers: { ...authHeaderApplication(applicationApiKey), ...extraHeaders },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+    })
+  ).data;
+};

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export * from './extraction.api';
+export * from './extraction.application.api';
+export * from './extraction-settings.api';
+export * from './extraction-plan-preset.api';

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

@@ -0,0 +1 @@
+export * from './extract.constants';

package/src/index.ts

@@ -0,0 +1,305 @@
+import axios from 'axios';
+import axiosRetry, { IAxiosRetryConfig, isNetworkOrIdempotentRequestError } from 'axios-retry';
+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';
+
+export * from './api';
+export * from './types';
+export * from './utils';
+export * from './constants';
+
+const DEFAULT_BASE_URL = 'https://extract-api.abyss-project.fr/api/';
+
+export const API_KEY_HEADER = 'abyss-api-key';
+export const API_KEY_APPLICATION_HEADER = 'abyss-api-key-application';
+export const ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+
+const NUMBER_RETRY_API = 10;
+const BASE_DELAY_BETWEEN_RETRY = 5000;
+const RETRY_CODES = [
+  502, // Bad Gateway
+  503, // Service Unavailable
+];
+
+type CoreConfig = {
+  token?: string;
+  apiKey?: string;
+  adminToken?: string;
+  baseURL?: string;
+};
+
+type AbyssExtractCoreSDK = {
+  extract: {
+    health: typeof extractionApi.health;
+    stats: typeof extractionApi.stats;
+    changelog: typeof extractionApi.changelog;
+    detect: typeof extractionApi.detect;
+    detectBulk: typeof extractionApi.detectBulk;
+    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;
+      get: typeof extractionApi.getFile;
+      patch: typeof extractionApi.patchFile;
+      listExtractions: typeof extractionApi.listFileExtractions;
+      downloadBundle: typeof extractionApi.downloadFileBundle;
+      /** Download the ORIGINAL source file (proxy-streamed; 423 while AV scan pending). */
+      downloadSource: typeof extractionApi.downloadFileSource;
+    };
+    extractions: {
+      get: typeof extractionApi.getExtraction;
+      patch: typeof extractionApi.patchExtraction;
+      searchRecords: typeof extractionApi.searchExtractionRecords;
+      export: typeof extractionApi.exportExtraction;
+      asyncExport: typeof extractionApi.asyncExportExtraction;
+      getExportJob: typeof extractionApi.getExportJob;
+      diff: typeof extractionApi.diffExtractions;
+      /** Opt a specific extraction in/out of the improvement-training dataset. */
+      toggleTraining: typeof extractionApi.toggleExtractionTraining;
+      /** Lazy fetch of one trace step's full IO payload (P3). */
+      stepIo: typeof extractionApi.getStepIo;
+    };
+    templates: {
+      list: typeof extractionApi.listTemplates;
+      get: typeof extractionApi.getTemplate;
+      create: typeof extractionApi.createTemplate;
+      update: typeof extractionApi.updateTemplate;
+      patchMeta: typeof extractionApi.patchTemplateMeta;
+      /** DESTRUCTIVE: template + versions + witness PDFs. Archive via patchMeta instead. */
+      delete: typeof extractionApi.deleteTemplate;
+      listVersions: typeof extractionApi.listTemplateVersions;
+      /** Presigned download URL for a version's witness PDF (404 when none). */
+      getWitnessUrl: typeof extractionApi.getTemplateWitnessUrl;
+      /** Delete a version's witness PDF and free the billed storage. */
+      deleteWitness: typeof extractionApi.deleteTemplateWitness;
+      exportCollection: typeof extractionApi.exportTemplateCollection;
+      importCollection: typeof extractionApi.importTemplateCollection;
+    };
+    jobs: {
+      get: typeof extractionApi.getJob;
+      retry: typeof extractionApi.retryJob;
+      cancel: typeof extractionApi.cancelJob;
+    };
+    feedback: {
+      submit: typeof extractionApi.submitFeedback;
+      list: typeof extractionApi.listFeedback;
+      get: typeof extractionApi.getFeedback;
+      patch: typeof extractionApi.patchFeedback;
+    };
+    usage: {
+      list: typeof extractionApi.listUsage;
+      summary: typeof extractionApi.summaryUsage;
+      byConfig: typeof extractionApi.usageByConfig;
+    };
+    share: {
+      mint: typeof extractionApi.mintShareExtraction;
+      revoke: typeof extractionApi.revokeShareExtraction;
+      public: { get: typeof extractionApi.getSharedExtractionPublic };
+    };
+    // Webhook delivery history.
+    webhookDeliveries: {
+      list: typeof extractionApi.listWebhookDeliveries;
+      get: typeof extractionApi.getWebhookDelivery;
+      replay: typeof extractionApi.replayWebhookDelivery;
+    };
+    // Webhook subscriptions (managed registrations).
+    webhook: {
+      paginate: typeof extractionApi.paginateExtractionWebhook;
+      get: typeof extractionApi.getExtractionWebhook;
+      create: typeof extractionApi.createExtractionWebhook;
+      update: typeof extractionApi.updateExtractionWebhook;
+      delete: typeof extractionApi.deleteExtractionWebhook;
+      resetSecret: typeof extractionApi.resetSecretExtractionWebhook;
+    };
+    // Per-scope improvement-consent settings (P4).
+    settings: {
+      get: typeof extractionSettingsApi.getExtractionSettings;
+      upsert: typeof extractionSettingsApi.upsertExtractionSettings;
+    };
+    // Provider/interpreter capabilities (V2-P1).
+    modes: { list: typeof extractionPlanPresetApi.listModes };
+    // Saved extraction plan presets CRUD (V2-P1).
+    plans: {
+      list: typeof extractionPlanPresetApi.listExtractionPlanPresets;
+      get: typeof extractionPlanPresetApi.getExtractionPlanPreset;
+      create: typeof extractionPlanPresetApi.createExtractionPlanPreset;
+      update: typeof extractionPlanPresetApi.updateExtractionPlanPreset;
+      delete: typeof extractionPlanPresetApi.deleteExtractionPlanPreset;
+      setDefault: typeof extractionPlanPresetApi.setDefaultExtractionPlanPreset;
+    };
+  };
+};
+
+export class AbyssExtractCore {
+  private static config = {
+    token: '',
+    apiKey: '',
+    adminToken: '',
+    baseURL: DEFAULT_BASE_URL,
+  };
+  static axios = axios.create({
+    baseURL: this.config.baseURL,
+    withCredentials: true,
+  });
+
+  private static _sdk: AbyssExtractCoreSDK | null = null;
+
+  public static get sdk(): AbyssExtractCoreSDK {
+    if (!AbyssExtractCore._sdk) {
+      AbyssExtractCore._sdk = AbyssExtractCore.buildSDK();
+    }
+    return AbyssExtractCore._sdk;
+  }
+
+  private static buildSDK(): AbyssExtractCoreSDK {
+    return {
+      extract: {
+        health: extractionApi.health,
+        stats: extractionApi.stats,
+        changelog: extractionApi.changelog,
+        detect: extractionApi.detect,
+        detectBulk: extractionApi.detectBulk,
+        run: extractionApi.extractSync,
+        runQueue: extractionApi.extractQueue,
+        runBulk: extractionApi.extractBulk,
+        application: {
+          run: extractionApplicationApi.runExtractionApplication,
+        },
+        files: {
+          list: extractionApi.listFiles,
+          listShared: extractionApi.listSharedFiles,
+          get: extractionApi.getFile,
+          patch: extractionApi.patchFile,
+          listExtractions: extractionApi.listFileExtractions,
+          downloadBundle: extractionApi.downloadFileBundle,
+          downloadSource: extractionApi.downloadFileSource,
+        },
+        extractions: {
+          get: extractionApi.getExtraction,
+          patch: extractionApi.patchExtraction,
+          searchRecords: extractionApi.searchExtractionRecords,
+          export: extractionApi.exportExtraction,
+          asyncExport: extractionApi.asyncExportExtraction,
+          getExportJob: extractionApi.getExportJob,
+          diff: extractionApi.diffExtractions,
+          toggleTraining: extractionApi.toggleExtractionTraining,
+          stepIo: extractionApi.getStepIo,
+        },
+        templates: {
+          list: extractionApi.listTemplates,
+          get: extractionApi.getTemplate,
+          create: extractionApi.createTemplate,
+          update: extractionApi.updateTemplate,
+          patchMeta: extractionApi.patchTemplateMeta,
+          delete: extractionApi.deleteTemplate,
+          listVersions: extractionApi.listTemplateVersions,
+          getWitnessUrl: extractionApi.getTemplateWitnessUrl,
+          deleteWitness: extractionApi.deleteTemplateWitness,
+          exportCollection: extractionApi.exportTemplateCollection,
+          importCollection: extractionApi.importTemplateCollection,
+        },
+        jobs: {
+          get: extractionApi.getJob,
+          retry: extractionApi.retryJob,
+          cancel: extractionApi.cancelJob,
+        },
+        feedback: {
+          submit: extractionApi.submitFeedback,
+          list: extractionApi.listFeedback,
+          get: extractionApi.getFeedback,
+          patch: extractionApi.patchFeedback,
+        },
+        usage: {
+          list: extractionApi.listUsage,
+          summary: extractionApi.summaryUsage,
+          byConfig: extractionApi.usageByConfig,
+        },
+        share: {
+          mint: extractionApi.mintShareExtraction,
+          revoke: extractionApi.revokeShareExtraction,
+          public: { get: extractionApi.getSharedExtractionPublic },
+        },
+        webhookDeliveries: {
+          list: extractionApi.listWebhookDeliveries,
+          get: extractionApi.getWebhookDelivery,
+          replay: extractionApi.replayWebhookDelivery,
+        },
+        webhook: {
+          paginate: extractionApi.paginateExtractionWebhook,
+          get: extractionApi.getExtractionWebhook,
+          create: extractionApi.createExtractionWebhook,
+          update: extractionApi.updateExtractionWebhook,
+          delete: extractionApi.deleteExtractionWebhook,
+          resetSecret: extractionApi.resetSecretExtractionWebhook,
+        },
+        settings: {
+          get: extractionSettingsApi.getExtractionSettings,
+          upsert: extractionSettingsApi.upsertExtractionSettings,
+        },
+        modes: { list: extractionPlanPresetApi.listModes },
+        plans: {
+          list: extractionPlanPresetApi.listExtractionPlanPresets,
+          get: extractionPlanPresetApi.getExtractionPlanPreset,
+          create: extractionPlanPresetApi.createExtractionPlanPreset,
+          update: extractionPlanPresetApi.updateExtractionPlanPreset,
+          delete: extractionPlanPresetApi.deleteExtractionPlanPreset,
+          setDefault: extractionPlanPresetApi.setDefaultExtractionPlanPreset,
+        },
+      },
+    };
+  }
+
+  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
+    axiosRetry(AbyssExtractCore.axios, {
+      retries: NUMBER_RETRY_API,
+      retryDelay: (retryCount) => retryCount * BASE_DELAY_BETWEEN_RETRY,
+      retryCondition: (error) =>
+        isNetworkOrIdempotentRequestError(error) ||
+        RETRY_CODES.includes(error.response?.status || 502),
+      ...axiosRetryConfig,
+    });
+  }
+
+  public static setConfig(config: CoreConfig): void {
+    AbyssExtractCore._sdk = null;
+
+    AbyssExtractCore.config = { ...AbyssExtractCore.config, ...config };
+
+    if (config.baseURL) {
+      AbyssExtractCore.axios.defaults.baseURL = config.baseURL;
+    }
+
+    if (config.token) {
+      AbyssExtractCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+    }
+
+    if (config.apiKey) {
+      AbyssExtractCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
+    }
+
+    if (config.adminToken) {
+      AbyssExtractCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+    }
+  }
+
+  public static getConfig(): CoreConfig {
+    return AbyssExtractCore.config;
+  }
+}

package/src/types/enum/api-error.enum.ts

@@ -0,0 +1,33 @@
+export enum ErrorType {
+  apiError = 'api_error',
+  authError = 'authentication_error',
+  resourceError = 'resource_error',
+}
+
+export enum Code {
+  // HTTP Error
+  tokenFailure = 'token_authentication_failure',
+  authenticationFailure = 'authentication_credentials_failure',
+  accessNotAllowed = 'access_not_allowed',
+  notFound = 'not_found',
+  validationError = 'resource_validation_error',
+  constraintError = 'resource_constraint_error',
+  internalServerError = 'internal_server_error',
+  serviceUnavailable = 'service_unavailable',
+  invalidData = 'invalid_data',
+  notImplemented = 'not_implemented',
+  retrospectiveCannotBeModifiedWhenCompleted = 'retrospective_cannot_be_modified_when_completed',
+  retrospectiveActionNotAllowedInPhase = 'retrospective_action_not_allowed_in_phase',
+  retrospectiveVoteBudgetExhausted = 'retrospective_vote_budget_exhausted',
+  retrospectiveActionLimitReached = 'retrospective_action_limit_reached',
+  atlasDocumentLimitReached = 'atlas_document_limit_reached',
+  boardCardDocumentLimitReached = 'board_card_document_limit_reached',
+  boardCardMoveInvalidDestination = 'board_card_move_invalid_destination',
+  boardCardLinkLimitReached = 'board_card_link_limit_reached',
+  boardCardLinkAlreadyExists = 'board_card_link_already_exists',
+  boardCardLinkToSelf = 'board_card_link_to_self',
+  shortLinkProtected = 'short_link_protected',
+  drawImageLimitReached = 'draw_image_limit_reached',
+  drawImageOwnerRequired = 'draw_image_owner_required',
+  drawImageNotInDraw = 'draw_image_not_in_draw',
+}

package/src/types/enum/combine-strategy.enum.ts

@@ -0,0 +1,7 @@
+// Combine strategy enum — mirror apps/api plan.types.ts exactly.
+
+export enum CombineStrategy {
+  MAX_CONFIDENCE = 'maxConfidence',
+  FIRST_WINS = 'firstWins',
+  VOTE = 'vote',
+}

package/src/types/enum/document-type.enum.ts

@@ -0,0 +1,11 @@
+// Document types supported by AbyssExtract. bank_statement is the legacy bank-statement profile.
+export enum DocumentType {
+  BANK_STATEMENT = 'bank_statement',
+  INVOICE = 'invoice',
+  RECEIPT = 'receipt',
+  ID_CARD = 'id_card',
+  RIB = 'rib',
+  FINANCIAL_STATEMENT = 'financial_statement',
+  PAYSLIP = 'payslip',
+  GENERIC = 'generic',
+}