@lexnode/legal-data-sdk 1.0.0 → 1.24.0

package/dist/webhooks.d.ts

@@ -0,0 +1,330 @@
+/**
+ * Verificação e tipagem das entregas assinadas do motor.
+ *
+ * O motor assina cada entrega como `x-lexnode-signature: t=<unix>,v1=<hex>`,
+ * onde o HMAC-SHA256 cobre `${t}.${corpoCru}` com o segredo do endpoint. A
+ * conferência é sobre os BYTES CRUS recebidos: reserializar o JSON muda a
+ * ordem das chaves e o digest deixa de bater.
+ */
+export declare const LEXNODE_WEBHOOK_HEADERS: {
+    readonly event: "x-lexnode-event";
+    readonly timestamp: "x-lexnode-timestamp";
+    readonly signature: "x-lexnode-signature";
+    readonly deliveryAttempt: "x-lexnode-delivery-attempt";
+};
+/** Janela de replay do motor. */
+export declare const DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+/**
+ * Os BYTES como chegaram. Reserializar o JSON reordena as chaves e o digest
+ * deixa de bater, então um corpo já parseado é recusado em vez de conferido.
+ */
+export type WebhookRawBody = string | Uint8Array;
+export type WebhookRejection = "MISSING_SECRET" | "RAW_BODY_REQUIRED" | "MISSING_SIGNATURE" | "MALFORMED_SIGNATURE" | "TIMESTAMP_MISMATCH" | "TIMESTAMP_OUT_OF_TOLERANCE" | "SIGNATURE_MISMATCH";
+export type WebhookVerification = {
+    ok: true;
+    timestamp: number;
+} | {
+    ok: false;
+    reason: WebhookRejection;
+};
+export type WebhookParseRejection = WebhookRejection | "INVALID_JSON" | "INVALID_ENVELOPE";
+/**
+ * O desfecho de `parseWebhookEvent`.
+ *
+ * `known` é o discriminador que separa o catálogo conhecido do resto. Ele mora
+ * no RESULTADO, e não no evento, por uma razão de tipo: um ramo `type: string`
+ * dentro da própria união apagaria o estreitamento por `type` de todos os
+ * outros — `payload` viraria `unknown` mesmo no caso reconhecido.
+ */
+export type WebhookParseResult = {
+    ok: true;
+    known: true;
+    event: WebhookEvent;
+} | {
+    ok: true;
+    known: false;
+    event: UnknownWebhookEvent;
+} | {
+    ok: false;
+    reason: WebhookParseRejection;
+};
+/** Cabeçalhos como um `Headers` do fetch ou como o objeto cru de um framework. */
+export type WebhookHeaders = Headers | Record<string, string | string[] | undefined>;
+export interface VerifyWebhookOptions {
+    /** Janela de replay, em segundos. Padrão: 300, como o motor. */
+    toleranceSeconds?: number;
+    /** Relógio, em SEGUNDOS da época Unix — o mesmo eixo do `t` do cabeçalho. */
+    now?: number;
+}
+/**
+ * Confere a assinatura de uma entrega e diz POR QUE recusou.
+ *
+ * O veredito é motivado de propósito: um `false` nu manda o receptor devolver
+ * o mesmo erro para segredo trocado, relógio fora de hora e corpo adulterado —
+ * três incidentes com conduta diferente.
+ */
+export declare function verifyWebhookSignature(rawBody: WebhookRawBody, headers: WebhookHeaders, secret: string, options?: VerifyWebhookOptions): WebhookVerification;
+/** O envelope comum a toda entrega. */
+export interface WebhookEventEnvelope {
+    id: string;
+    occurredAt: string;
+    projectId: string | null;
+    monitorId: string | null;
+}
+/** Sinal compacto de suspensão de prazo — nível, termos e trecho. */
+export interface SuspensionSignal {
+    confidence: "HIGH" | "MEDIUM" | "LOW";
+    keywords: string[];
+    excerpt: string;
+}
+/** A data-limite do índice da fonte que qualifica um `total: 0`. */
+export interface ProcessSourceIndex {
+    tribunalAlias: string;
+    updatedThrough: string | null;
+    checkedAt: string;
+}
+export interface ProcessMovementCreatedPayload {
+    canonicalProcessId: string;
+    tribunalAlias: string;
+    processNumber: string;
+    /** O ponteiro que o consumidor informou ao assinar o processo. */
+    externalRef: string | null;
+    newMovementCount: number;
+    latestMovementKey: string;
+    /**
+     * O que a movimentação mais recente É: o código da Tabela Processual
+     * Unificada e o nome do ato como a fonte o escreve. Nulos quando a fonte não
+     * os declara. É por eles que um aviso diz o que aconteceu sem reler a
+     * listagem de movimentações a cada evento.
+     */
+    latestMovementCode?: number | null;
+    latestMovementLabel?: string | null;
+    /**
+     * Presente quando o processo não é compartilhável: o aviso diz que ele andou
+     * e não diz o quê, porque ali o nome do ato é teor.
+     */
+    contentWithheld?: true;
+}
+export interface PublicationCreatedPayload {
+    monitorId: string;
+    officeId: string | null;
+    publicationKey: string;
+    processNumber: string;
+    formattedProcessNumber: string;
+    /** `null` quando o diário devolveu sigla que o catálogo do CNJ não cobre. */
+    tribunalAlias: string | null;
+    tribunalCode: string | null;
+    availableAt: string | null;
+    sourceUrl: string | null;
+    type: string;
+    /** Prévia do teor; `null` quando o gate reteve. */
+    excerpt: string | null;
+    suspensionSignal: SuspensionSignal | null;
+    /** Presente só quando o teor foi retido no instante do envio. */
+    contentWithheld?: true;
+    /** Só na vigília por termo. */
+    term?: string;
+    /** Só na vigília por nome de parte. */
+    partyName?: string;
+    partyRole?: string | null;
+    /** Só na vigília por CNPJ: o literal vigiado — o documento pontuado
+     *  inteiro, ou a raiz `NN.NNN.NNN` quando `includeBranches`. */
+    partyDocument?: string;
+    includeBranches?: boolean;
+    /** `document`: o CNPJ consta no teor — a empresa foi citada no ato, seja
+     *  ou não parte. */
+    matchedBy?: "document";
+}
+export interface MonitorSyncSucceededPayload {
+    monitorId: string;
+    officeId: string | null;
+    checkedAt: string;
+    newEvents: number;
+    /** `false` quando a passada não cobriu a janela inteira. */
+    complete: boolean;
+    /** Vigília de processo: se algo mudou desde a passada anterior. */
+    changed?: boolean;
+    processNumber?: string | null;
+    formattedProcessNumber?: string;
+    tribunalAlias?: string;
+    tribunalCode?: string;
+    snapshotHash?: string;
+    sourceUpdatedAt?: string | null;
+    latestMovementAt?: string | null;
+    /** O alvo que a fonte não indexava passou a existir nesta passada. */
+    firstAppearance?: true;
+    /** A vigília de aparição segue esperando o alvo entrar no índice. */
+    awaitingAppearance?: true;
+    indexUpdatedThrough?: string | null;
+    expectedFrom?: string | null;
+    /**
+     * Varredura de diário: os EXTREMOS do que a passada abriu de fato. `null`
+     * quando o ciclo não abriu fatia nenhuma — anunciar uma janela nesse caso
+     * seria dizer que leu o que não leu.
+     */
+    availableFrom?: string | null;
+    availableTo?: string | null;
+    daysSwept?: number;
+    pagesFetched?: number;
+    publicationsSeen?: number;
+    coveredThrough?: string;
+    /** Onde a próxima passada retoma: o dia e a página. `null` quando fechou. */
+    resumesAt?: {
+        day: string;
+        page: number;
+    } | null;
+    pendingDays?: number;
+    /**
+     * Fatias encerradas sem leitura completa, como chaves `AAAA-MM-DD#SIGLA`
+     * (sem a sigla no dia não dividido). `volumeCapped` é o dia grande demais,
+     * com cauda por ler; `refusedDays` é o que a fonte recusa em definitivo.
+     * Separá-los do dia lido por inteiro é a razão de os campos existirem.
+     */
+    volumeCapped?: string[];
+    refusedDays?: string[];
+    term?: string;
+    partyName?: string;
+    partyDocument?: string;
+    includeBranches?: boolean;
+    publicationsMatched?: number;
+}
+export interface MonitorSyncFailedPayload {
+    monitorId: string;
+    officeId: string | null;
+    error: string;
+    code: string;
+    class: "RETRYABLE" | "TERMINAL";
+    retryable: boolean;
+    /** O que o ciclo alcançou antes da recusa, quando houve ciclo. */
+    coverage?: Record<string, unknown>;
+}
+export interface SearchJobSucceededPayload {
+    jobId: string;
+    status: "SUCCEEDED";
+    kind: string;
+    officeId: string | null;
+    traceId: string | null;
+    total: number;
+    relation: "eq" | "gte";
+    sourceIndex?: ProcessSourceIndex;
+    processNumbers: string[];
+    pollUrl: string;
+}
+export interface SearchJobFailedPayload {
+    jobId: string;
+    status: "FAILED";
+    kind: string;
+    officeId: string | null;
+    traceId: string | null;
+    error: {
+        class: "RETRYABLE" | "TERMINAL";
+        code: string;
+        message: string;
+        retryable: boolean;
+        upstreamStatus?: number;
+    };
+    pollUrl: string;
+}
+export interface PublicationTextAlertMatch {
+    source: string;
+    publicationKey: string;
+    tribunalSigla: string | null;
+    publicationDate: string | null;
+    headline: string | null;
+    /** Presente só quando o teor deste item foi retido no envio. */
+    contentWithheld?: true;
+}
+export interface PublicationTextAlertMatchedPayload {
+    alertId: string;
+    externalRef: string | null;
+    queryHash: string;
+    /** O total real; `matches` é uma amostra. */
+    totalNew: number;
+    matches: PublicationTextAlertMatch[];
+}
+export interface PublicationHarvestCompletedPayload {
+    sliceId: string;
+    tribunalSigla: string;
+    harvestDate: string;
+    seedTerm: string | null;
+    itemsIndexable: number;
+}
+export interface QuotaLowPayload {
+    usedCredits: number;
+    limitCredits: number;
+    includedMonthlyCredits: number;
+    topupCredits: number;
+    remainingCredits: number;
+    thresholdPercent: number;
+    periodStart: string;
+    periodEnd: string;
+}
+export interface PeriodEndingPayload {
+    planCode: string;
+    periodEnd: string;
+    daysRemaining: number;
+}
+export interface SubscriptionPastDuePayload {
+    status: string;
+    planCode: string;
+    currentPeriodEnd: string | null;
+}
+/**
+ * A entrega sintética do teste de conectividade do endpoint. O motor a manda a
+ * pedido, com a mesma assinatura de um evento real.
+ */
+export interface WebhookTestPayload {
+    message: string;
+}
+type Typed<T extends string, P> = WebhookEventEnvelope & {
+    type: T;
+    payload: P;
+};
+/** Os dez tipos do catálogo, discriminados por `type`. */
+export type WebhookEvent = Typed<"PROCESS_MOVEMENT_CREATED", ProcessMovementCreatedPayload> | Typed<"PUBLICATION_CREATED", PublicationCreatedPayload> | Typed<"MONITOR_SYNC_SUCCEEDED", MonitorSyncSucceededPayload> | Typed<"MONITOR_SYNC_FAILED", MonitorSyncFailedPayload> | Typed<"SEARCH_JOB_COMPLETED", SearchJobSucceededPayload | SearchJobFailedPayload> | Typed<"PUBLICATION_TEXT_ALERT_MATCHED", PublicationTextAlertMatchedPayload> | Typed<"PUBLICATION_HARVEST_COMPLETED", PublicationHarvestCompletedPayload> | Typed<"QUOTA_LOW", QuotaLowPayload> | Typed<"PERIOD_ENDING", PeriodEndingPayload> | Typed<"SUBSCRIPTION_PAST_DUE", SubscriptionPastDuePayload> | Typed<"WEBHOOK_TEST", WebhookTestPayload>;
+/**
+ * O evento que o catálogo ainda não descreve.
+ *
+ * Tipo novo é coisa a ignorar, nunca exceção: o receptor precisa responder 2xx
+ * para o motor não entrar na curva de reentrega por uma novidade inofensiva.
+ */
+export type UnknownWebhookEvent = WebhookEventEnvelope & {
+    type: string;
+    payload: unknown;
+};
+export type WebhookEventType = WebhookEvent["type"];
+/**
+ * A entrega de teste, que o endpoint recebe sem assinar.
+ *
+ * Ela é o PRIMEIRO corpo que um receptor novo vê — o botão de testar
+ * conectividade existe para ser apertado antes do primeiro evento real. Por
+ * isso está na união (quem faz `switch (event.type)` precisa enxergá-la) e
+ * fora do catálogo assinável (não se pede, não se recusa, chega a qualquer
+ * endpoint).
+ */
+export declare const WEBHOOK_TEST_EVENT_TYPE: "WEBHOOK_TEST";
+/** Os tipos que se pode ASSINAR ao cadastrar um endpoint. */
+export declare const WEBHOOK_EVENT_TYPES: readonly ["PROCESS_MOVEMENT_CREATED", "PUBLICATION_CREATED", "MONITOR_SYNC_SUCCEEDED", "MONITOR_SYNC_FAILED", "SEARCH_JOB_COMPLETED", "PUBLICATION_TEXT_ALERT_MATCHED", "PUBLICATION_HARVEST_COMPLETED", "QUOTA_LOW", "PERIOD_ENDING", "SUBSCRIPTION_PAST_DUE"];
+/**
+ * O que entra em `eventTypes` ao cadastrar um endpoint. É subconjunto próprio
+ * de `WebhookEventType`: mandar a entrega de teste nessa lista é recusa.
+ */
+export type SubscribableWebhookEventType = (typeof WEBHOOK_EVENT_TYPES)[number];
+/** Se o tipo está no catálogo que este pacote descreve. */
+export declare function isKnownWebhookEventType(type: string): type is WebhookEventType;
+/** Se este evento é a entrega de teste, e não um fato do acervo. */
+export declare function isWebhookTest(event: WebhookEvent): event is Extract<WebhookEvent, {
+    type: "WEBHOOK_TEST";
+}>;
+export declare function webhookRejectionStatus(reason: WebhookParseRejection): number;
+/** Se a recusa é de responsabilidade do receptor, e o remetente deve voltar. */
+export declare function isReceiverFault(reason: WebhookParseRejection): boolean;
+/**
+ * Confere a assinatura e devolve o evento tipado.
+ *
+ * A assinatura prova a ORIGEM; a conferência de forma que vem depois prova que
+ * o corpo é um envelope de evento — sem ela, um corpo assinado mas malformado
+ * viraria um `as` silencioso dentro do consumidor.
+ */
+export declare function parseWebhookEvent(rawBody: WebhookRawBody, headers: WebhookHeaders, secret: string, options?: VerifyWebhookOptions): WebhookParseResult;
+export {};

package/dist/webhooks.js

@@ -0,0 +1,223 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+/**
+ * Verificação e tipagem das entregas assinadas do motor.
+ *
+ * O motor assina cada entrega como `x-lexnode-signature: t=<unix>,v1=<hex>`,
+ * onde o HMAC-SHA256 cobre `${t}.${corpoCru}` com o segredo do endpoint. A
+ * conferência é sobre os BYTES CRUS recebidos: reserializar o JSON muda a
+ * ordem das chaves e o digest deixa de bater.
+ */
+export const LEXNODE_WEBHOOK_HEADERS = {
+    event: "x-lexnode-event",
+    timestamp: "x-lexnode-timestamp",
+    signature: "x-lexnode-signature",
+    deliveryAttempt: "x-lexnode-delivery-attempt",
+};
+/** Janela de replay do motor. */
+export const DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+/**
+ * A forma exata do digest que o motor emite: 64 dígitos hex minúsculos.
+ *
+ * Conferir a forma ANTES de decodificar é o que barra o cabeçalho maleável:
+ * `Buffer.from(v1, "hex")` para no primeiro caractere inválido, então um
+ * digest válido com lixo colado no fim decodifica nos mesmos bytes e passaria
+ * pela guarda de tamanho — a mesma entrega verificaria quantas vezes o
+ * remetente quisesse, com cabeçalhos diferentes a cada vez.
+ */
+const V1_DIGEST = /^[0-9a-f]{64}$/u;
+function isRawBody(value) {
+    return typeof value === "string" || value instanceof Uint8Array;
+}
+function readHeader(headers, name) {
+    if (typeof headers.get === "function") {
+        return headers.get(name);
+    }
+    const bag = headers;
+    const alvo = name.toLowerCase();
+    const encontrado = Object.entries(bag).find(([key]) => key.toLowerCase() === alvo);
+    if (!encontrado)
+        return null;
+    const raw = Array.isArray(encontrado[1]) ? encontrado[1][0] : encontrado[1];
+    return raw ?? null;
+}
+function parseSignatureHeader(header) {
+    const out = {};
+    for (const part of header.split(",")) {
+        const separator = part.indexOf("=");
+        if (separator !== -1) {
+            const key = part.slice(0, separator).trim();
+            const value = part.slice(separator + 1).trim();
+            if (key === "t")
+                out.t = value;
+            else if (key === "v1")
+                out.v1 = value;
+        }
+    }
+    return out;
+}
+/**
+ * Confere a assinatura de uma entrega e diz POR QUE recusou.
+ *
+ * O veredito é motivado de propósito: um `false` nu manda o receptor devolver
+ * o mesmo erro para segredo trocado, relógio fora de hora e corpo adulterado —
+ * três incidentes com conduta diferente.
+ */
+export function verifyWebhookSignature(rawBody, headers, secret, options = {}) {
+    if (!secret)
+        return { ok: false, reason: "MISSING_SECRET" };
+    if (!isRawBody(rawBody))
+        return { ok: false, reason: "RAW_BODY_REQUIRED" };
+    const signatureHeader = readHeader(headers, LEXNODE_WEBHOOK_HEADERS.signature);
+    if (!signatureHeader)
+        return { ok: false, reason: "MISSING_SIGNATURE" };
+    const { t, v1 } = parseSignatureHeader(signatureHeader);
+    if (!t || !v1 || !V1_DIGEST.test(v1)) {
+        return { ok: false, reason: "MALFORMED_SIGNATURE" };
+    }
+    const timestamp = Number(t);
+    if (!Number.isFinite(timestamp)) {
+        return { ok: false, reason: "MALFORMED_SIGNATURE" };
+    }
+    // O cabeçalho de timestamp é redundante com o `t` da assinatura — e é por
+    // isso que ele vale: divergir os dois é sinal de corpo remontado no caminho.
+    const timestampHeader = readHeader(headers, LEXNODE_WEBHOOK_HEADERS.timestamp);
+    if (timestampHeader !== null && timestampHeader.trim() !== t) {
+        return { ok: false, reason: "TIMESTAMP_MISMATCH" };
+    }
+    const tolerance = options.toleranceSeconds ?? DEFAULT_WEBHOOK_TOLERANCE_SECONDS;
+    const now = options.now ?? Math.floor(Date.now() / 1000);
+    if (Math.abs(now - timestamp) > tolerance) {
+        return { ok: false, reason: "TIMESTAMP_OUT_OF_TOLERANCE" };
+    }
+    // O prefixo e o corpo entram separados: o corpo em bytes é assinado como
+    // veio, sem passar por uma conversão de texto que possa alterá-lo.
+    const mac = createHmac("sha256", secret).update(`${t}.`, "utf8");
+    const expected = (typeof rawBody === "string"
+        ? mac.update(rawBody, "utf8")
+        : mac.update(rawBody)).digest();
+    const provided = Buffer.from(v1, "hex");
+    if (provided.length !== expected.length) {
+        return { ok: false, reason: "SIGNATURE_MISMATCH" };
+    }
+    if (!timingSafeEqual(provided, expected)) {
+        return { ok: false, reason: "SIGNATURE_MISMATCH" };
+    }
+    return { ok: true, timestamp };
+}
+/**
+ * A entrega de teste, que o endpoint recebe sem assinar.
+ *
+ * Ela é o PRIMEIRO corpo que um receptor novo vê — o botão de testar
+ * conectividade existe para ser apertado antes do primeiro evento real. Por
+ * isso está na união (quem faz `switch (event.type)` precisa enxergá-la) e
+ * fora do catálogo assinável (não se pede, não se recusa, chega a qualquer
+ * endpoint).
+ */
+export const WEBHOOK_TEST_EVENT_TYPE = "WEBHOOK_TEST";
+/** Os tipos que se pode ASSINAR ao cadastrar um endpoint. */
+export const WEBHOOK_EVENT_TYPES = [
+    "PROCESS_MOVEMENT_CREATED",
+    "PUBLICATION_CREATED",
+    "MONITOR_SYNC_SUCCEEDED",
+    "MONITOR_SYNC_FAILED",
+    "SEARCH_JOB_COMPLETED",
+    "PUBLICATION_TEXT_ALERT_MATCHED",
+    "PUBLICATION_HARVEST_COMPLETED",
+    "QUOTA_LOW",
+    "PERIOD_ENDING",
+    "SUBSCRIPTION_PAST_DUE",
+];
+const KNOWN_EVENT_TYPES = new Set([
+    ...WEBHOOK_EVENT_TYPES,
+    WEBHOOK_TEST_EVENT_TYPE,
+]);
+/** Se o tipo está no catálogo que este pacote descreve. */
+export function isKnownWebhookEventType(type) {
+    return KNOWN_EVENT_TYPES.has(type);
+}
+/** Se este evento é a entrega de teste, e não um fato do acervo. */
+export function isWebhookTest(event) {
+    return event.type === WEBHOOK_TEST_EVENT_TYPE;
+}
+/**
+ * O status HTTP que cada recusa merece.
+ *
+ * A distinção que decide tudo é: o remetente deve voltar? Um corpo que não se
+ * autentica nunca passará a se autenticar, e insistir só queima a curva de
+ * reentrega — recusa definitiva. Já o segredo ausente é indisponibilidade
+ * NOSSA: responder 4xx ali faz o motor desistir de uma entrega que a nossa
+ * própria configuração derrubou, e o evento se perde para sempre.
+ *
+ * A regra é a mesma em todo receptor, então mora aqui em vez de ser reinventada
+ * — com esse erro — em cada integração.
+ */
+const REJECTION_STATUS = {
+    MISSING_SECRET: 503,
+    RAW_BODY_REQUIRED: 500,
+    MISSING_SIGNATURE: 401,
+    MALFORMED_SIGNATURE: 401,
+    SIGNATURE_MISMATCH: 401,
+    TIMESTAMP_MISMATCH: 401,
+    TIMESTAMP_OUT_OF_TOLERANCE: 401,
+    INVALID_JSON: 400,
+    INVALID_ENVELOPE: 400,
+};
+export function webhookRejectionStatus(reason) {
+    return REJECTION_STATUS[reason];
+}
+/** Se a recusa é de responsabilidade do receptor, e o remetente deve voltar. */
+export function isReceiverFault(reason) {
+    return REJECTION_STATUS[reason] >= 500;
+}
+/**
+ * Confere a assinatura e devolve o evento tipado.
+ *
+ * A assinatura prova a ORIGEM; a conferência de forma que vem depois prova que
+ * o corpo é um envelope de evento — sem ela, um corpo assinado mas malformado
+ * viraria um `as` silencioso dentro do consumidor.
+ */
+export function parseWebhookEvent(rawBody, headers, secret, options = {}) {
+    const verification = verifyWebhookSignature(rawBody, headers, secret, options);
+    if (!verification.ok)
+        return verification;
+    let parsed;
+    try {
+        parsed = JSON.parse(typeof rawBody === "string"
+            ? rawBody
+            : Buffer.from(rawBody).toString("utf8"));
+    }
+    catch {
+        return { ok: false, reason: "INVALID_JSON" };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { ok: false, reason: "INVALID_ENVELOPE" };
+    }
+    const body = parsed;
+    if (typeof body.type !== "string" || !body.type) {
+        return { ok: false, reason: "INVALID_ENVELOPE" };
+    }
+    if (!body.payload || typeof body.payload !== "object") {
+        return { ok: false, reason: "INVALID_ENVELOPE" };
+    }
+    // O id é a chave de idempotência de todo receptor: uma entrega repetida é
+    // normal, e é por ele que ela se reconhece. Aceitá-lo vazio faria a primeira
+    // entrega sem id ocupar a única vaga de deduplicação e todas as seguintes
+    // parecerem repetição dela — um evento por conta, e o resto em silêncio.
+    if (typeof body.id !== "string" || !body.id) {
+        return { ok: false, reason: "INVALID_ENVELOPE" };
+    }
+    if (typeof body.occurredAt !== "string" || !body.occurredAt) {
+        return { ok: false, reason: "INVALID_ENVELOPE" };
+    }
+    const event = {
+        id: body.id,
+        type: body.type,
+        occurredAt: body.occurredAt,
+        projectId: typeof body.projectId === "string" ? body.projectId : null,
+        monitorId: typeof body.monitorId === "string" ? body.monitorId : null,
+        payload: body.payload,
+    };
+    return isKnownWebhookEventType(event.type)
+        ? { ok: true, known: true, event: event }
+        : { ok: true, known: false, event };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lexnode/legal-data-sdk",
-  "version": "1.0.0",
-  "description": "TypeScript types for the LexNode legal-data engine: a generic B2B API over Brazilian court process, movement and publication data.",
+  "version": "1.24.0",
+  "description": "Cliente TypeScript do LexNode, o motor de dados jur\u00eddicos do Brasil: transporte tipado, erros classificados, verifica\u00e7\u00e3o de webhook e os tipos gerados do contrato OpenAPI.",
   "license": "MIT",
   "homepage": "https://www.lexnode.com.br/docs",
   "keywords": [
@@ -11,16 +11,40 @@
     "cnj",
     "djen",
     "openapi",
-    "types",
+    "sdk",
+    "client",
+    "webhooks",
     "typescript"
   ],
   "private": false,
-  "types": "schema.d.ts",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
+    "dist",
     "schema.d.ts",
     "README.md",
     "LICENSE"
   ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.9"
+  },
   "publishConfig": {
     "access": "public"
   }