@abyss-project/tools 1.0.0 → 1.0.1

package/src/api/rcb.api.ts

@@ -0,0 +1,829 @@
+// ──────────────────────────────────────────────
+// RCB (bank statement extraction) — user-facing API.
+//
+// Sync helper accepts an inline PDF buffer (multipart) or a storage_file_id.
+// Queue helper enqueues for async processing + webhook delivery.
+// ──────────────────────────────────────────────
+
+import { AbyssToolsCore } from '..';
+import {
+  IExtractRcbBody,
+  IExtractBulkRcbBody,
+  IDetectBulkRcbBody,
+  IListFilesRcbQuery,
+  IPatchFileRcbBody,
+  IPatchExtractionRcbBody,
+  ISearchExtractionRecordsRcbQuery,
+  IExportExtractionRcbQuery,
+  IAsyncExportExtractionRcbBody,
+  IListUsageRcbQuery,
+  ISummaryUsageRcbQuery,
+  IListWebhookDeliveriesRcbQuery,
+  IReplayWebhookDeliveryRcbBody,
+  IMintShareExtractionRcbBody,
+} from '../types';
+import {
+  IExtractSyncRcbResponse,
+  IExtractQueueRcbResponse,
+  IExtractBulkRcbResponse,
+  IDetectRcbResponse,
+  IDetectBulkRcbResponse,
+  IListFilesRcbResponse,
+  IGetFileRcbResponse,
+  IListFileExtractionsRcbResponse,
+  IGetExtractionRcbResponse,
+  ISearchExtractionRecordsRcbResponse,
+  IDiffExtractionsRcbResponse,
+  IAsyncExportRcbResponse,
+  IGetExportJobRcbResponse,
+  ICreateTemplateRcbResponse,
+  IUpdateTemplateRcbResponse,
+  IListTemplatesRcbResponse,
+  IGetTemplateRcbResponse,
+  IListTemplateVersionsRcbResponse,
+  IRcbTemplateCollection,
+  IImportTemplateCollectionRcbResponse,
+  IGetJobRcbResponse,
+  ICreateFeedbackRcbResponse,
+  IListFeedbackRcbResponse,
+  IGetFeedbackRcbResponse,
+  IHealthRcbResponse,
+  IStatsRcbResponse,
+  ISummaryUsageRcbResponse,
+  IGetQuotaRcbResponse,
+  IListWebhookDeliveriesRcbResponse,
+  IGetWebhookDeliveryRcbResponse,
+  IGetSharedExtractionRcbResponse,
+  IMintShareExtractionRcbResponse,
+  IChangelogRcbResponse,
+} from '../types';
+import {
+  ICreateTemplateRcbBody,
+  IUpdateTemplateRcbBody,
+  IPatchTemplateMetaRcbBody,
+  ICreateFeedbackRcbBody,
+  IPatchFeedbackRcbBody,
+  IListFeedbackRcbQuery,
+  IListSharedFilesRcbQuery,
+  IPaginateRcbWebhookQuery,
+  ICreateRcbWebhookBody,
+  IUpdateRcbWebhookBody,
+  IRcbWebhookScopeQuery,
+} from '../types';
+import type {
+  IPaginateRcbWebhookResponse,
+  IGetRcbWebhookResponse,
+  ICreateRcbWebhookResponse,
+  IUpdateRcbWebhookResponse,
+  IDeleteRcbWebhookResponse,
+  IResetSecretRcbWebhookResponse,
+} from '../types';
+
+const DEFAULT_API_KEY_HEADER = 'x-api-key';
+
+function authHeader(apiKey?: string): Record<string, string> {
+  return apiKey ? { [DEFAULT_API_KEY_HEADER]: apiKey } : {};
+}
+
+async function loadFormData(): Promise<any> {
+  if (typeof FormData !== 'undefined' && typeof window !== 'undefined') {
+    return FormData;
+  }
+  // Use 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 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');
+}
+
+function serializeParams<T extends object>(o: T): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(o as Record<string, unknown>)) {
+    if (v === undefined || v === null) continue;
+    out[k] = v instanceof Date ? v.toISOString() : v;
+  }
+  return out;
+}
+
+// ─── EXTRACT ─────────────────────────────────
+
+/**
+ * Optional per-call extras for extract endpoints. `idempotencyKey` is a
+ * Stripe-style replay key (24h window) sent as the `Idempotency-Key` header —
+ * not part of the request body.
+ */
+export interface ExtractCallOptions {
+  idempotencyKey?: string;
+}
+
+export const extractSyncRcb = async (
+  body: IExtractRcbBody,
+  apiKey?: string,
+  opts: ExtractCallOptions = {},
+): Promise<IExtractSyncRcbResponse> => {
+  return postExtract(
+    { ...body, processing: 'sync' },
+    apiKey,
+    opts,
+  ) as Promise<IExtractSyncRcbResponse>;
+};
+
+export const extractQueueRcb = async (
+  body: IExtractRcbBody,
+  apiKey?: string,
+  opts: ExtractCallOptions = {},
+): Promise<IExtractQueueRcbResponse> => {
+  return postExtract(
+    { ...body, processing: 'queue' },
+    apiKey,
+    opts,
+  ) as Promise<IExtractQueueRcbResponse>;
+};
+
+const postExtract = async (
+  body: IExtractRcbBody,
+  apiKey?: string,
+  opts: ExtractCallOptions = {},
+): Promise<unknown> => {
+  const extraHeaders: Record<string, string> = {};
+  if (opts.idempotencyKey) {
+    extraHeaders['Idempotency-Key'] = opts.idempotencyKey;
+  }
+  if (body.pdf) {
+    const isBrowser = typeof window !== 'undefined' && typeof FormData !== 'undefined';
+    const filename = body.pdf_filename ?? 'rcb.pdf';
+    if (isBrowser) {
+      const form = new FormData();
+      const blob = new Blob([body.pdf as Uint8Array], { type: 'application/pdf' });
+      form.append('file', blob, filename);
+      appendIf(form, 'mode', body.mode);
+      if (body.hint) form.append('hint', JSON.stringify(body.hint));
+      appendIf(form, 'template_id', body.template_id);
+      if (body.template) form.append('template', JSON.stringify(body.template));
+      appendIf(form, 'user_external_id', body.user_external_id);
+      if (body.user_metadata) form.append('user_metadata', JSON.stringify(body.user_metadata));
+      if (typeof body.archive === 'boolean') form.append('archive', String(body.archive));
+      if (typeof body.force === 'boolean') form.append('force', String(body.force));
+      if (body.processing) form.append('processing', body.processing);
+      return (
+        await AbyssToolsCore.axios.post(`rcb/extract`, form, {
+          headers: { ...authHeader(apiKey), ...extraHeaders },
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity,
+        })
+      ).data;
+    }
+    const FormDataCtor = await loadFormData();
+    const form = new FormDataCtor();
+    const buf = Buffer.isBuffer(body.pdf) ? body.pdf : Buffer.from(body.pdf);
+    form.append('file', buf, {
+      filename,
+      contentType: 'application/pdf',
+    });
+    appendIf(form, 'mode', body.mode);
+    if (body.hint) form.append('hint', JSON.stringify(body.hint));
+    appendIf(form, 'template_id', body.template_id);
+    if (body.template) form.append('template', JSON.stringify(body.template));
+    appendIf(form, 'user_external_id', body.user_external_id);
+    if (body.user_metadata) form.append('user_metadata', JSON.stringify(body.user_metadata));
+    if (typeof body.archive === 'boolean') form.append('archive', String(body.archive));
+    if (typeof body.force === 'boolean') form.append('force', String(body.force));
+    if (body.processing) form.append('processing', body.processing);
+    return (
+      await AbyssToolsCore.axios.post(`rcb/extract`, form, {
+        headers: {
+          ...(typeof form.getHeaders === 'function' ? form.getHeaders() : {}),
+          ...authHeader(apiKey),
+          ...extraHeaders,
+        },
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+      })
+    ).data;
+  }
+  // Strip `pdf` from the JSON body (only used for multipart upload above).
+  const jsonBody: Omit<IExtractRcbBody, 'pdf'> = { ...body };
+  delete (jsonBody as { pdf?: unknown }).pdf;
+  return (
+    await AbyssToolsCore.axios.post(`rcb/extract`, jsonBody, {
+      headers: { ...authHeader(apiKey), ...extraHeaders },
+    })
+  ).data;
+};
+
+function appendIf(form: any, key: string, value: unknown): void {
+  if (value === undefined || value === null) return;
+  form.append(key, String(value));
+}
+
+export const extractBulkRcb = async (
+  body: IExtractBulkRcbBody,
+  apiKey?: string,
+): Promise<IExtractBulkRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IExtractBulkRcbResponse>(`rcb/extract/bulk`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+// ─── DETECT ──────────────────────────────────
+
+export const detectRcb = async (
+  pdf: Buffer | Uint8Array,
+  pdfFilename = 'rcb.pdf',
+  apiKey?: string,
+): Promise<IDetectRcbResponse> => {
+  const isBrowser = typeof window !== 'undefined' && typeof FormData !== 'undefined';
+  if (isBrowser) {
+    const form = new FormData();
+    const blob = new Blob([pdf as Uint8Array], { type: 'application/pdf' });
+    form.append('file', blob, pdfFilename);
+    return (
+      await AbyssToolsCore.axios.post<IDetectRcbResponse>(`rcb/detect`, form, {
+        headers: authHeader(apiKey),
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+      })
+    ).data;
+  }
+  const FormDataCtor = await loadFormData();
+  const form = new FormDataCtor();
+  const buf = Buffer.isBuffer(pdf) ? pdf : Buffer.from(pdf);
+  form.append('file', buf, { filename: pdfFilename, contentType: 'application/pdf' });
+  return (
+    await AbyssToolsCore.axios.post<IDetectRcbResponse>(`rcb/detect`, form, {
+      headers: {
+        ...(typeof form.getHeaders === 'function' ? form.getHeaders() : {}),
+        ...authHeader(apiKey),
+      },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+    })
+  ).data;
+};
+
+export const detectBulkRcb = async (
+  body: IDetectBulkRcbBody,
+  apiKey?: string,
+): Promise<IDetectBulkRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IDetectBulkRcbResponse>(`rcb/detect/bulk`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+// ─── FILES ───────────────────────────────────
+
+export const listFilesRcb = async (
+  query: IListFilesRcbQuery = {},
+  apiKey?: string,
+): Promise<IListFilesRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListFilesRcbResponse>(`rcb/files`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const getFileRcb = async (fileId: string, apiKey?: string): Promise<IGetFileRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetFileRcbResponse>(`rcb/files/${fileId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const listFileExtractionsRcb = async (
+  fileId: string,
+  query: { limit?: number; offset?: number } = {},
+  apiKey?: string,
+): Promise<IListFileExtractionsRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListFileExtractionsRcbResponse>(
+      `rcb/files/${fileId}/extractions`,
+      { params: serializeParams(query), headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const patchFileRcb = async (
+  fileId: string,
+  body: IPatchFileRcbBody,
+  apiKey?: string,
+): Promise<IGetFileRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.patch<IGetFileRcbResponse>(`rcb/files/${fileId}`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const downloadFileBundleRcb = async (
+  fileId: string,
+  query: { format?: 'csv' | 'json' } = {},
+  apiKey?: string,
+): Promise<Buffer> => {
+  const res = await AbyssToolsCore.axios.get(`rcb/files/${fileId}/bundle`, {
+    params: serializeParams(query),
+    responseType: 'arraybuffer',
+    headers: authHeader(apiKey),
+  });
+  return Buffer.from(res.data as ArrayBuffer);
+};
+
+// ─── EXTRACTIONS ─────────────────────────────
+
+export const getExtractionRcb = async (
+  extractionId: string,
+  apiKey?: string,
+): Promise<IGetExtractionRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetExtractionRcbResponse>(`rcb/extractions/${extractionId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const patchExtractionRcb = async (
+  extractionId: string,
+  body: IPatchExtractionRcbBody,
+  apiKey?: string,
+): Promise<IGetExtractionRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.patch<IGetExtractionRcbResponse>(
+      `rcb/extractions/${extractionId}`,
+      body,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const searchExtractionRecordsRcb = async (
+  extractionId: string,
+  query: ISearchExtractionRecordsRcbQuery = {},
+  apiKey?: string,
+): Promise<ISearchExtractionRecordsRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<ISearchExtractionRecordsRcbResponse>(
+      `rcb/extractions/${extractionId}/records`,
+      { params: serializeParams(query), headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const exportExtractionRcb = async (
+  extractionId: string,
+  query: IExportExtractionRcbQuery,
+  apiKey?: string,
+): Promise<{ body: string; contentType: string }> => {
+  const res = await AbyssToolsCore.axios.get(`rcb/extractions/${extractionId}/export`, {
+    params: serializeParams(query),
+    responseType: 'text',
+    transformResponse: (d) => d,
+    headers: authHeader(apiKey),
+  });
+  return {
+    body: typeof res.data === 'string' ? res.data : String(res.data),
+    contentType: String(res.headers?.['content-type'] ?? 'application/octet-stream'),
+  };
+};
+
+export const asyncExportExtractionRcb = async (
+  extractionId: string,
+  body: IAsyncExportExtractionRcbBody,
+  apiKey?: string,
+): Promise<IAsyncExportRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IAsyncExportRcbResponse>(
+      `rcb/extractions/${extractionId}/export/async`,
+      body,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const getExportJobRcb = async (
+  jobId: string,
+  apiKey?: string,
+): Promise<IGetExportJobRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetExportJobRcbResponse>(`rcb/exports/jobs/${jobId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const diffExtractionsRcb = async (
+  extractionId: string,
+  otherId: string,
+  apiKey?: string,
+): Promise<IDiffExtractionsRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IDiffExtractionsRcbResponse>(
+      `rcb/extractions/${extractionId}/diff/${otherId}`,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+// ─── TEMPLATES ───────────────────────────────
+
+export const listTemplatesRcb = async (apiKey?: string): Promise<IListTemplatesRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListTemplatesRcbResponse>(`rcb/templates`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const createTemplateRcb = async (
+  body: ICreateTemplateRcbBody,
+  apiKey?: string,
+): Promise<ICreateTemplateRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateTemplateRcbResponse>(`rcb/templates`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const getTemplateRcb = async (
+  templateId: string,
+  apiKey?: string,
+): Promise<IGetTemplateRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetTemplateRcbResponse>(`rcb/templates/${templateId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const updateTemplateRcb = async (
+  templateId: string,
+  body: IUpdateTemplateRcbBody,
+  apiKey?: string,
+): Promise<IUpdateTemplateRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateTemplateRcbResponse>(
+      `rcb/templates/${templateId}`,
+      body,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const patchTemplateMetaRcb = async (
+  templateId: string,
+  body: IPatchTemplateMetaRcbBody,
+  apiKey?: string,
+): Promise<void> => {
+  await AbyssToolsCore.axios.patch(`rcb/templates/${templateId}/meta`, body, {
+    headers: authHeader(apiKey),
+  });
+};
+
+export const deleteTemplateRcb = async (templateId: string, apiKey?: string): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`rcb/templates/${templateId}`, {
+    headers: authHeader(apiKey),
+  });
+};
+
+export const listTemplateVersionsRcb = async (
+  templateId: string,
+  apiKey?: string,
+): Promise<IListTemplateVersionsRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListTemplateVersionsRcbResponse>(
+      `rcb/templates/${templateId}/versions`,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const exportTemplateCollectionRcb = async (
+  ids: string[] | null,
+  apiKey?: string,
+): Promise<IRcbTemplateCollection> => {
+  const res = await AbyssToolsCore.axios.get<IRcbTemplateCollection>(`rcb/templates/export`, {
+    params: ids && ids.length ? { ids: ids.join(',') } : {},
+    headers: authHeader(apiKey),
+    responseType: 'json',
+  });
+  return res.data;
+};
+
+export const importTemplateCollectionRcb = async (
+  doc: IRcbTemplateCollection,
+  apiKey?: string,
+): Promise<IImportTemplateCollectionRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IImportTemplateCollectionRcbResponse>(
+      `rcb/templates/import`,
+      doc,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+// ─── JOBS ────────────────────────────────────
+
+export const getJobRcb = async (jobId: string, apiKey?: string): Promise<IGetJobRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetJobRcbResponse>(`rcb/jobs/${jobId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const retryJobRcb = async (jobId: string, apiKey?: string): Promise<void> => {
+  await AbyssToolsCore.axios.post(`rcb/jobs/${jobId}/retry`, undefined, {
+    headers: authHeader(apiKey),
+  });
+};
+
+export const cancelJobRcb = async (jobId: string, apiKey?: string): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`rcb/jobs/${jobId}`, { headers: authHeader(apiKey) });
+};
+
+// ─── FEEDBACK ────────────────────────────────
+
+export const submitFeedbackRcb = async (
+  body: ICreateFeedbackRcbBody,
+  apiKey?: string,
+): Promise<ICreateFeedbackRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateFeedbackRcbResponse>(`rcb/feedback`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const listFeedbackRcb = async (
+  query: IListFeedbackRcbQuery = {},
+  apiKey?: string,
+): Promise<IListFeedbackRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListFeedbackRcbResponse>(`rcb/feedback`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const getFeedbackRcb = async (
+  feedbackId: string,
+  apiKey?: string,
+): Promise<IGetFeedbackRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetFeedbackRcbResponse>(`rcb/feedback/${feedbackId}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const patchFeedbackRcb = async (
+  feedbackId: string,
+  body: IPatchFeedbackRcbBody,
+  apiKey?: string,
+): Promise<IGetFeedbackRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.patch<IGetFeedbackRcbResponse>(`rcb/feedback/${feedbackId}`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+// ─── HEALTH / STATS / USAGE / QUOTA ─────────
+
+export const healthRcb = async (apiKey?: string): Promise<IHealthRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IHealthRcbResponse>(`rcb/health`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const statsRcb = async (apiKey?: string): Promise<IStatsRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IStatsRcbResponse>(`rcb/stats`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const listUsageRcb = async (
+  query: IListUsageRcbQuery = {},
+  apiKey?: string,
+): Promise<{ data: unknown[]; total?: number }> => {
+  return (
+    await AbyssToolsCore.axios.get<{ data: unknown[]; total?: number }>(`rcb/usage`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const summaryUsageRcb = async (
+  query: ISummaryUsageRcbQuery = {},
+  apiKey?: string,
+): Promise<ISummaryUsageRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<ISummaryUsageRcbResponse>(`rcb/usage/summary`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const getQuotaRcb = async (apiKey?: string): Promise<IGetQuotaRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetQuotaRcbResponse>(`rcb/quota`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+// ─── SHARED FILES (content_share-backed) ────
+//
+// Types live in `../types/interface/api/requests/rcb.request.ts` so they
+// stay alongside every other RCB SDK contract.
+
+export const listSharedFilesRcb = async (
+  query: IListSharedFilesRcbQuery = {},
+  apiKey?: string,
+): Promise<IListFilesRcbResponse> =>
+  (
+    await AbyssToolsCore.axios.get<IListFilesRcbResponse>(`rcb/files/shared`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+
+// ─── WEBHOOK DELIVERIES ─────────────────────
+
+export const listWebhookDeliveriesRcb = async (
+  query: IListWebhookDeliveriesRcbQuery = {},
+  apiKey?: string,
+): Promise<IListWebhookDeliveriesRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListWebhookDeliveriesRcbResponse>(`rcb/webhooks/deliveries`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+export const getWebhookDeliveryRcb = async (
+  deliveryId: string,
+  apiKey?: string,
+): Promise<IGetWebhookDeliveryRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetWebhookDeliveryRcbResponse>(
+      `rcb/webhooks/deliveries/${deliveryId}`,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const replayWebhookDeliveryRcb = async (
+  deliveryId: string,
+  body: IReplayWebhookDeliveryRcbBody = {},
+  apiKey?: string,
+): Promise<IGetWebhookDeliveryRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IGetWebhookDeliveryRcbResponse>(
+      `rcb/webhooks/deliveries/${deliveryId}/replay`,
+      body,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+// ─── WEBHOOK SUBSCRIPTIONS (CRUD) ───────────
+//
+// Request / response types are defined alongside every other RCB SDK
+// contract — see ../types/interface/api/{requests,responses}/rcb.*.ts.
+
+export const paginateRcbWebhook = async (
+  query: IPaginateRcbWebhookQuery = {},
+  apiKey?: string,
+): Promise<IPaginateRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.get<IPaginateRcbWebhookResponse>(`rcb/webhook`, {
+      params: serializeParams(query),
+      headers: authHeader(apiKey),
+    })
+  ).data;
+
+export const getRcbWebhook = async (
+  webhookId: string,
+  scope: IRcbWebhookScopeQuery = {},
+  apiKey?: string,
+): Promise<IGetRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.get<IGetRcbWebhookResponse>(
+      `rcb/webhook/${webhookId}`,
+      { params: serializeParams(scope), headers: authHeader(apiKey) },
+    )
+  ).data;
+
+export const createRcbWebhook = async (
+  body: ICreateRcbWebhookBody,
+  scope: IRcbWebhookScopeQuery = {},
+  apiKey?: string,
+): Promise<ICreateRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.post<ICreateRcbWebhookResponse>(
+      `rcb/webhook`,
+      body,
+      { params: serializeParams(scope), headers: authHeader(apiKey) },
+    )
+  ).data;
+
+export const updateRcbWebhook = async (
+  webhookId: string,
+  body: IUpdateRcbWebhookBody,
+  scope: IRcbWebhookScopeQuery = {},
+  apiKey?: string,
+): Promise<IUpdateRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.put<IUpdateRcbWebhookResponse>(
+      `rcb/webhook/${webhookId}`,
+      body,
+      { params: serializeParams(scope), headers: authHeader(apiKey) },
+    )
+  ).data;
+
+export const deleteRcbWebhook = async (
+  webhookId: string,
+  scope: IRcbWebhookScopeQuery = {},
+  apiKey?: string,
+): Promise<IDeleteRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.delete<IDeleteRcbWebhookResponse>(
+      `rcb/webhook/${webhookId}`,
+      { params: serializeParams(scope), headers: authHeader(apiKey) },
+    )
+  ).data;
+
+export const resetSecretRcbWebhook = async (
+  webhookId: string,
+  scope: IRcbWebhookScopeQuery = {},
+  apiKey?: string,
+): Promise<IResetSecretRcbWebhookResponse> =>
+  (
+    await AbyssToolsCore.axios.post<IResetSecretRcbWebhookResponse>(
+      `rcb/webhook/${webhookId}/reset-secret`,
+      undefined,
+      { params: serializeParams(scope), headers: authHeader(apiKey) },
+    )
+  ).data;
+
+// ─── SHARE ───────────────────────────────────
+
+export const mintShareExtractionRcb = async (
+  extractionId: string,
+  body: IMintShareExtractionRcbBody = {},
+  apiKey?: string,
+): Promise<IMintShareExtractionRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IMintShareExtractionRcbResponse>(
+      `rcb/share/owner/extractions/${extractionId}`,
+      body,
+      { headers: authHeader(apiKey) },
+    )
+  ).data;
+};
+
+export const revokeShareExtractionRcb = async (
+  extractionId: string,
+  apiKey?: string,
+): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`rcb/share/owner/extractions/${extractionId}`, {
+    headers: authHeader(apiKey),
+  });
+};
+
+export const getSharedExtractionRcbPublic = async (
+  token: string,
+): Promise<IGetSharedExtractionRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetSharedExtractionRcbResponse>(
+      `rcb/share/extractions/${token}`,
+    )
+  ).data;
+};
+
+// ─── CHANGELOG ──────────────────────────────
+
+export const changelogRcb = async (apiKey?: string): Promise<IChangelogRcbResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IChangelogRcbResponse>(`rcb/changelog`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};