@lexnode/legal-data-sdk 1.27.0 → 1.29.0

package/schema.d.ts

@@ -260,6 +260,78 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/processes/lookups": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Listar as consultas de processo em segundo plano
+         * @description Lista as consultas da conta, no recorte do escritório, da mais nova para a mais antiga, com paginação keyset. Só o que cada uma é: o processo fica atrás da leitura da consulta. Sem cobrança.
+         *
+         *     **Escopo exigido na chave de API:** `PROCESSES_READ`
+         */
+        get: operations["listProcessLookups"];
+        put?: never;
+        /**
+         * Ler um processo e seguir em segundo plano se a fonte não entregar
+         * @description Faz a leitura de `GET /v1/processes/{processNumber}` (visão `PROCESS`) ou de `GET /v1/processes/{processNumber}/snapshot` (visão `SNAPSHOT`) dentro de `waitSeconds`. Quando ela cabe na espera, a resposta é **200** com uma consulta `SUCCEEDED`, sem consulta aberta (`lookupId` nulo), que traz o processo em `process` ou `snapshot`: o mesmo corpo, o mesmo `meta` e o mesmo preço da leitura direta — inclusive a cópia de até 24 h que socorre a fonte que falhou. Quando a fonte processual falha — não responde dentro da espera, fica indisponível, responde com parte do índice sem o processo ou pede para esperar por volume —, a resposta é **202** com a consulta aberta: o motor segue tentando sozinho, até 60 s por tentativa, por até 6 h (`giveUpAt`). O header `Location` aponta a consulta, que se lê sem cobrança em `GET /v1/processes/lookups/{lookupId}`, e `Retry-After` diz quando lê-la de novo. O 202 não cobra: o preço da leitura fica retido em `creditsReserved` e só é cobrado se o processo vier — 3 pela ficha, 8 pelo retrato; 1 pela ficha que outra leitura trouxe ao acervo nesse meio-tempo. O fim sai no evento `PROCESS_LOOKUP_COMPLETED`, que aponta a consulta e nunca traz o processo; o movimento novo segue no próprio evento dele. Chamar de novo a mesma leitura (conta, escritório, processo e visão) devolve a mesma consulta (`deduped: true`), sem nova retenção nem conferência de saldo; quando a próxima tentativa agendada está a mais de 2 min e a última ficou pelo menos isso para trás, a chamada tenta a fonte na hora, dentro da espera dela, e responde 200 se o processo vier. Com `staleOnFailure: true`, a falha da fonte com uma cópia guardada mais velha que o frescor do plano responde 202 com a cópia em `stale`, por 1 crédito, e a consulta cobra só o resto do preço se a versão atual vier: socorro e atualização somam o preço da leitura viva. Toda outra recusa é exatamente a da leitura direta: a resposta da fonte sem o processo (404), o segredo de justiça (403), o saldo (402) — e também a falha da fonte quando a conta já tem consultas abertas demais (5 por chave, 20 por conta) ou quando o saldo não comporta a retenção. Uma leitura direta sua do mesmo processo que dá certo fecha a consulta aberta sem cobrar, e o retrato fecha também a da ficha. A chave de teste nunca abre consulta: responde como a leitura direta.
+         *
+         *     **Escopo exigido na chave de API:** `PROCESSES_READ`
+         */
+        post: operations["createProcessLookup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/processes/lookups/{lookupId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ler uma consulta de processo em segundo plano
+         * @description Lê a consulta, sem cobrança. Aberta, diz a próxima tentativa (`nextAttemptAt`), até quando ela tenta (`giveUpAt`) e a última ida à fonte (`lastAttempt`). Entregue, traz o processo por 24 h depois da entrega (`resultExpiresAt`), relido do acervo e passado de novo pelo controle de confidencialidade de quem lê: o processo que passou a segredo de justiça depois da entrega responde 403, como a leitura direta. Depois disso, `resultExpired` e nenhum processo: uma leitura nova o traz. No retrato, `sourcePayload` é nulo. `meta.sourceFetchedAt` diz quando a cópia servida foi buscada na fonte. Terminada sem o processo, `error` diz o código e `creditsRefunded` a retenção devolvida. Consulta de outra conta ou de outro escritório responde 404 `PROCESS_LOOKUP_NOT_FOUND`.
+         *
+         *     **Escopo exigido na chave de API:** `PROCESSES_READ`
+         */
+        get: operations["getProcessLookup"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/processes/lookups/{lookupId}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancelar uma consulta de processo em segundo plano
+         * @description Cancela uma consulta aberta da própria conta e escritório e devolve a retenção na mesma chamada; `refunded` diz se a devolução aconteceu AQUI, porque uma entrega em corrida pode já tê-la consumido. O que a mesma compra já cobrou pela cópia em `stale` fica cobrado: a cópia foi entregue. O cancelamento não gera `PROCESS_LOOKUP_COMPLETED`. Consulta terminada responde 409 `JOB_TERMINAL`; de outra conta, 404 `PROCESS_LOOKUP_NOT_FOUND`.
+         *
+         *     **Escopo exigido na chave de API:** `PROCESSES_READ`
+         */
+        post: operations["cancelProcessLookup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/monitors": {
         parameters: {
             query?: never;
@@ -375,7 +447,7 @@ export interface paths {
         };
         /**
          * Listar os jobs de busca do chamador
-         * @description Lista com escopo de conta/office dos jobs de busca assíncronos (mais recentes primeiro, paginação keyset). Apenas metadados — os resultados ficam atrás do endpoint de consulta do job.
+         * @description Lista com escopo de conta/office dos jobs de busca assíncronos (mais recentes primeiro, paginação keyset). Apenas metadados — os resultados ficam atrás do endpoint de consulta do job. Só a busca assíncrona de processos: a consulta de processo em segundo plano tem rota própria, `/v1/processes/lookups`.
          *
          *     **Escopo exigido na chave de API:** `PROCESSES_READ`
          */
@@ -397,7 +469,7 @@ export interface paths {
         };
         /**
          * Consultar um job de busca
-         * @description Retorna o status do job; em SUCCEEDED, `result` carrega o mesmo formato da busca síncrona de processos — inclusive `sourceIndex.updatedThrough`, a data até onde o índice do tribunal está atualizado, que qualifica um `total: 0` como *ainda não chegou* em vez de *não existe*. O campo acompanha o resultado que consultou a fonte; um job servido do acervo não o traz. O processo que o controle de confidencialidade retém de quem consulta sai de `items`, conta em `redactedCount` e uma vez só em `total`, quantos documentos dele a busca tenha achado. Jobs são visíveis apenas para a conta/office que os submeteu (404 caso contrário). A submissão acontece via POST /v1/processes/search, que responde 202 + jobId quando o modo assíncrono está ativo.
+         * @description Retorna o status do job; em SUCCEEDED, `result` carrega o mesmo formato da busca síncrona de processos — inclusive `sourceIndex.updatedThrough`, a data até onde o índice do tribunal está atualizado, que qualifica um `total: 0` como *ainda não chegou* em vez de *não existe*. O campo acompanha o resultado que consultou a fonte; um job servido do acervo não o traz. O processo que o controle de confidencialidade retém de quem consulta sai de `items`, conta em `redactedCount` e uma vez só em `total`, quantos documentos dele a busca tenha achado. Jobs são visíveis apenas para a conta/office que os submeteu (404 caso contrário). A submissão acontece via POST /v1/processes/search, que responde 202 + jobId quando o modo assíncrono está ativo. O id de uma consulta de processo em segundo plano responde 404 aqui: ela se lê em `GET /v1/processes/lookups/{lookupId}`.
          *
          *     **Escopo exigido na chave de API:** `PROCESSES_READ`
          */
@@ -421,7 +493,7 @@ export interface paths {
         put?: never;
         /**
          * Cancelar um job de busca ainda não concluído
-         * @description Cancela um job QUEUED/LEASED da própria conta/office e devolve a retenção de créditos na mesma chamada — job que não rodou não custa nada. `refunded` diz se a devolução aconteceu AQUI: um worker em corrida pode já ter consumido ou devolvido a retenção. Job em estado terminal responde 409; job de outra conta, 404.
+         * @description Cancela um job QUEUED/LEASED da própria conta/office e devolve a retenção de créditos na mesma chamada — job que não rodou não custa nada. `refunded` diz se a devolução aconteceu AQUI: um worker em corrida pode já ter consumido ou devolvido a retenção. Job em estado terminal responde 409; job de outra conta, 404. A consulta de processo em segundo plano se cancela em `POST /v1/processes/lookups/{lookupId}/cancel`; o id dela aqui responde 404.
          *
          *     **Escopo exigido na chave de API:** `PROCESSES_SEARCH`
          */
@@ -569,7 +641,7 @@ export interface paths {
         };
         /**
          * Consultar a cobertura do corpus indexado
-         * @description Cobertura agregada do corpus de jurisprudência indexado localmente: documentos indexáveis por fonte × tribunal × mês (a mesma agregação congelada no snapshot de cobertura de cada busca textual), combinada com o estado das fatias de colheita do diário oficial — grupo com fatia pendente reporta `PARTIAL` (o conjunto indexado ainda pode crescer), grupo totalmente colhido/indexado reporta `INDEXED`, e `NONE` significa nada indexado nem colheita solicitada. Inclui totais por fonte com as datas da publicação indexada mais antiga e mais recente, e a cobertura por matéria em `areas` — cada área do direito com estado, contagens e tribunais indexados, inclusive as matérias fora do acervo (`covered: false`), para que resultado vazio nunca se confunda com matéria não coberta. As fontes são reportadas separadamente — um corpus estruturado espelhado do tribunal e menções no diário oficial são ativos diferentes. Leitura local, zero créditos.
+         * @description Cobertura agregada do corpus de jurisprudência indexado localmente: documentos indexáveis por fonte × tribunal × mês (a mesma agregação que cada busca textual congela no snapshot de cobertura — lá marcado `UNAVAILABLE`, sem grupos, quando ela não coube no prazo da busca), combinada com o estado das fatias de colheita do diário oficial — grupo com fatia pendente reporta `PARTIAL` (o conjunto indexado ainda pode crescer), grupo totalmente colhido/indexado reporta `INDEXED`, e `NONE` significa nada indexado nem colheita solicitada. Inclui totais por fonte com as datas da publicação indexada mais antiga e mais recente, e a cobertura por matéria em `areas` — cada área do direito com estado, contagens e tribunais indexados, inclusive as matérias fora do acervo (`covered: false`), para que resultado vazio nunca se confunda com matéria não coberta. As fontes são reportadas separadamente — um corpus estruturado espelhado do tribunal e menções no diário oficial são ativos diferentes. Leitura local, zero créditos.
          *
          *     **Escopo exigido na chave de API:** `PUBLICATIONS_READ`
          */
@@ -3445,7 +3517,3070 @@ export interface operations {
             };
         };
     };
-    getProcessSnapshotBatch: {
+    getProcessSnapshotBatch: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Identificador da requisição escolhido pelo cliente, ecoado em meta.requestId e no corpo de erro. Tem DOIS papéis: (1) rastreio, em toda rota — é por ele que o suporte encontra a chamada; (2) idempotência por conta em POST /v1/publications/text-searches e POST /v1/search-jobs, onde reenviar o mesmo valor reapresenta o resultado já produzido, sem nova cobrança. Fora dessas duas rotas o valor não deduplica nada: para repetir uma chamada de propósito, mande um valor novo. Aceita [A-Za-z0-9_.:-], até 200 caracteres; valor fora disso é ignorado e o motor cunha o próprio. */
+                "x-request-id"?: string;
+                /** @description Atribui a chamada a um sub-tenant seu (por exemplo, um escritório) na medição de uso e no roteamento de eventos. Opcional. */
+                "x-office-id"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    items: {
+                        tribunalAlias: string;
+                        processNumber: string;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Resposta padrão */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: {
+                            total: number;
+                            succeeded: number;
+                            failed: number;
+                            items: ({
+                                tribunalAlias: string;
+                                processNumber: string;
+                                ok: boolean;
+                                snapshot?: {
+                                    process: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        djen?: {
+                                            publicationCount: number;
+                                            /** Format: date-time */
+                                            latestPublicationAt?: string | null;
+                                            latestPublicationType?: string | null;
+                                            latestPublicationExcerpt?: string | null;
+                                            latestPublicationUrl?: string | null;
+                                        } | null;
+                                    };
+                                    movements: unknown[];
+                                    /** @description Os documentos que o motor guarda do número, a principal primeiro, só com o cabeçalho de cada um: os movimentos de cada instância vêm no retrato de um processo. */
+                                    instances: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                    }[];
+                                };
+                                /** @description Presente só no item que a fonte processual não entregou e que o acervo socorreu com a cópia guardada de até 24 h: a causa, a espera que a fonte pediu, quando pediu, e quando a cópia foi buscada. O item socorrido custa 1 crédito. */
+                                lakeRescue?: {
+                                    /**
+                                     * @description Por que a fonte não entregou: `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem poder servir o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume).
+                                     * @enum {string}
+                                     */
+                                    cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                    /** @description A espera que a fonte pediu: não consulte a fonte de novo antes dela. */
+                                    retryAfterSeconds?: number;
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando a cópia servida foi buscada na fonte.
+                                     */
+                                    sourceFetchedAt: string;
+                                };
+                                error?: {
+                                    status?: number;
+                                    /** @description Código estável da taxonomia, quando a falha do item o carrega — é o que distingue, por exemplo, a recusa da chave de teste de um bloqueio LGPD. */
+                                    code?: string;
+                                    /** @description Os mesmos `details` do envelope de erro da rota unitária — na recusa da chave de teste, `reason` diz a causa. */
+                                    details?: {
+                                        [key: string]: unknown;
+                                    };
+                                    message: string;
+                                };
+                            } & {
+                                [key: string]: unknown;
+                            })[];
+                        };
+                        meta: {
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            credits?: number;
+                            cacheHit?: boolean;
+                        } & {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    listProcessLookups: {
+        parameters: {
+            query?: {
+                status?: "QUEUED" | "LEASED" | "SUCCEEDED" | "FAILED" | "CANCELED";
+                cursor?: string;
+                limit?: number;
+            };
+            header?: {
+                /** @description Identificador da requisição escolhido pelo cliente, ecoado em meta.requestId e no corpo de erro. Tem DOIS papéis: (1) rastreio, em toda rota — é por ele que o suporte encontra a chamada; (2) idempotência por conta em POST /v1/publications/text-searches e POST /v1/search-jobs, onde reenviar o mesmo valor reapresenta o resultado já produzido, sem nova cobrança. Fora dessas duas rotas o valor não deduplica nada: para repetir uma chamada de propósito, mande um valor novo. Aceita [A-Za-z0-9_.:-], até 200 caracteres; valor fora disso é ignorado e o motor cunha o próprio. */
+                "x-request-id"?: string;
+                /** @description Atribui a chamada a um sub-tenant seu (por exemplo, um escritório) na medição de uso e no roteamento de eventos. Opcional. */
+                "x-office-id"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Resposta padrão */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: {
+                            items: {
+                                lookupId: string;
+                                /** @enum {string} */
+                                status: "QUEUED" | "LEASED" | "SUCCEEDED" | "FAILED" | "CANCELED";
+                                /**
+                                 * @description O que ler: `PROCESS`, a ficha do processo (a mesma de `GET /v1/processes/{processNumber}`), ou `SNAPSHOT`, o retrato com os movimentos (o de `GET /v1/processes/{processNumber}/snapshot`).
+                                 * @enum {string}
+                                 */
+                                view: "PROCESS" | "SNAPSHOT";
+                                tribunalAlias: string;
+                                /** @description O número do processo, só os 20 dígitos. */
+                                processNumber: string;
+                                /** @description Onde a consulta é lida, sem nova cobrança. */
+                                pollUrl: string;
+                                /** @description A chamada reencontrou a consulta já aberta para a mesma conta, escritório, processo e visão, em vez de abrir outra. */
+                                deduped: boolean;
+                                /** @description Créditos retidos pela consulta: o máximo que a entrega cobra, só se o processo vier — a ficha que outra leitura trouxe ao acervo cobra menos. Enquanto isso, a retenção conta no saldo e no teto diário da chave que abriu a consulta. */
+                                creditsReserved: number;
+                                /** @description O que a mesma compra já cobrou fora da consulta: a cópia guardada entregue em `stale`. A entrega cobra o preço da leitura menos isto. */
+                                alreadyCharged: number;
+                                /** @description Idas à fonte até aqui, a leitura que abriu a consulta incluída. */
+                                attempts: number;
+                                /**
+                                 * Format: date-time
+                                 * @description Quando a próxima tentativa sai; nulo na consulta terminada e enquanto uma tentativa está em curso. A hora que já passou é a da tentativa esperando a vez na fila. Ler a consulta antes da hora futura devolve o mesmo estado.
+                                 */
+                                nextAttemptAt: string | null;
+                                /**
+                                 * Format: date-time
+                                 * @description Até quando a consulta tenta; depois, termina sem o processo e devolve a retenção.
+                                 */
+                                giveUpAt: string;
+                                /** @description A última ida à fonte que não entregou: quando, e por quê — `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume). */
+                                lastAttempt: {
+                                    /** Format: date-time */
+                                    at: string;
+                                    /** @enum {string} */
+                                    code: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                    retryable: boolean;
+                                } | null;
+                                /**
+                                 * @description Quem entregou: `SOURCE`, uma tentativa na fonte; `LAKE`, o acervo, que outra leitura atualizou depois de a consulta abrir; `DIRECT_READ`, uma leitura sua do mesmo processo, que entregou e cobrou antes — a consulta fecha sem cobrar. Nulo enquanto não houve entrega.
+                                 * @enum {string|null}
+                                 */
+                                satisfiedBy: "SOURCE" | "LAKE" | "DIRECT_READ" | null;
+                                creditsCharged: number | null;
+                                creditsRefunded: number | null;
+                                /** @description Por que a consulta terminou sem o processo: o código da taxonomia de erros, como a leitura síncrona o daria. */
+                                error: {
+                                    /** @enum {string} */
+                                    class: "RETRYABLE" | "TERMINAL";
+                                    code: string;
+                                    /** @description O texto público fixo do código, o mesmo em toda consulta. */
+                                    message: string;
+                                    retryable: boolean;
+                                    upstreamStatus?: number;
+                                } | null;
+                                /** Format: date-time */
+                                createdAt: string;
+                                /** Format: date-time */
+                                finishedAt: string | null;
+                                /**
+                                 * Format: date-time
+                                 * @description Até quando o processo entregue é lido nesta consulta sem nova cobrança: 24 h depois da entrega.
+                                 */
+                                resultExpiresAt: string | null;
+                                /** @description O processo entregue já não é lido aqui: o prazo passou, ou o acervo já não sustenta a cópia. Uma leitura nova o traz. */
+                                resultExpired: boolean;
+                            }[];
+                            nextCursor: string | null;
+                        };
+                        meta: {
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            credits?: number;
+                            cacheHit?: boolean;
+                        } & {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    createProcessLookup: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Identificador da requisição escolhido pelo cliente, ecoado em meta.requestId e no corpo de erro. Tem DOIS papéis: (1) rastreio, em toda rota — é por ele que o suporte encontra a chamada; (2) idempotência por conta em POST /v1/publications/text-searches e POST /v1/search-jobs, onde reenviar o mesmo valor reapresenta o resultado já produzido, sem nova cobrança. Fora dessas duas rotas o valor não deduplica nada: para repetir uma chamada de propósito, mande um valor novo. Aceita [A-Za-z0-9_.:-], até 200 caracteres; valor fora disso é ignorado e o motor cunha o próprio. */
+                "x-request-id"?: string;
+                /** @description Atribui a chamada a um sub-tenant seu (por exemplo, um escritório) na medição de uso e no roteamento de eventos. Opcional. */
+                "x-office-id"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    tribunalAlias: string;
+                    processNumber: string;
+                    /**
+                     * @description O que ler: `PROCESS`, a ficha do processo (a mesma de `GET /v1/processes/{processNumber}`), ou `SNAPSHOT`, o retrato com os movimentos (o de `GET /v1/processes/{processNumber}/snapshot`).
+                     * @enum {string}
+                     */
+                    view: "PROCESS" | "SNAPSHOT";
+                    /**
+                     * @description Quanto esperar pela fonte processual nesta chamada, em segundos: de 10 a 180, padrão 20. A mesma espera de `waitSeconds` nas duas leituras de processo; o que não cabe nela segue em segundo plano.
+                     * @default 20
+                     */
+                    waitSeconds?: number;
+                    /**
+                     * @description Com `true`, quando a fonte falha e o acervo guarda uma cópia do processo mais velha que o frescor do seu plano, a resposta 202 traz essa cópia em `stale`, por 1 crédito, e a consulta segue buscando a versão atual pelo resto do preço. Sem ele, a falha da fonte socorrida pela cópia de até 24 h responde 200, como nas duas leituras.
+                     * @default false
+                     */
+                    staleOnFailure?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Resposta padrão */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: {
+                            /** @description O id da consulta; nulo quando a leitura coube na espera e nenhuma consulta foi aberta. */
+                            lookupId: string | null;
+                            /** @enum {string} */
+                            status: "QUEUED" | "LEASED" | "SUCCEEDED" | "FAILED" | "CANCELED";
+                            /**
+                             * @description O que ler: `PROCESS`, a ficha do processo (a mesma de `GET /v1/processes/{processNumber}`), ou `SNAPSHOT`, o retrato com os movimentos (o de `GET /v1/processes/{processNumber}/snapshot`).
+                             * @enum {string}
+                             */
+                            view: "PROCESS" | "SNAPSHOT";
+                            tribunalAlias: string;
+                            /** @description O número do processo, só os 20 dígitos. */
+                            processNumber: string;
+                            /** @description Onde a consulta é lida, sem nova cobrança; nulo sem consulta aberta. */
+                            pollUrl: string | null;
+                            /** @description A chamada reencontrou a consulta já aberta para a mesma conta, escritório, processo e visão, em vez de abrir outra. */
+                            deduped: boolean;
+                            /** @description Créditos retidos pela consulta: o máximo que a entrega cobra, só se o processo vier — a ficha que outra leitura trouxe ao acervo cobra menos. Enquanto isso, a retenção conta no saldo e no teto diário da chave que abriu a consulta. */
+                            creditsReserved: number;
+                            /** @description O que a mesma compra já cobrou fora da consulta: a cópia guardada entregue em `stale`. A entrega cobra o preço da leitura menos isto. */
+                            alreadyCharged: number;
+                            /** @description Idas à fonte até aqui, a leitura que abriu a consulta incluída. */
+                            attempts: number;
+                            /**
+                             * Format: date-time
+                             * @description Quando a próxima tentativa sai; nulo na consulta terminada e enquanto uma tentativa está em curso. A hora que já passou é a da tentativa esperando a vez na fila. Ler a consulta antes da hora futura devolve o mesmo estado.
+                             */
+                            nextAttemptAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando a consulta tenta; depois, termina sem o processo e devolve a retenção. Nulo sem consulta aberta.
+                             */
+                            giveUpAt: string | null;
+                            /** @description A última ida à fonte que não entregou: quando, e por quê — `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume). */
+                            lastAttempt: {
+                                /** Format: date-time */
+                                at: string;
+                                /** @enum {string} */
+                                code: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                retryable: boolean;
+                            } | null;
+                            /**
+                             * @description Quem entregou: `SOURCE`, uma tentativa na fonte; `LAKE`, o acervo, que outra leitura atualizou depois de a consulta abrir; `DIRECT_READ`, uma leitura sua do mesmo processo, que entregou e cobrou antes — a consulta fecha sem cobrar. Nulo enquanto não houve entrega.
+                             * @enum {string|null}
+                             */
+                            satisfiedBy: "SOURCE" | "LAKE" | "DIRECT_READ" | null;
+                            creditsCharged: number | null;
+                            creditsRefunded: number | null;
+                            /** @description Por que a consulta terminou sem o processo: o código da taxonomia de erros, como a leitura síncrona o daria. */
+                            error: {
+                                /** @enum {string} */
+                                class: "RETRYABLE" | "TERMINAL";
+                                code: string;
+                                /** @description O texto público fixo do código, o mesmo em toda consulta. */
+                                message: string;
+                                retryable: boolean;
+                                upstreamStatus?: number;
+                            } | null;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            finishedAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando o processo entregue é lido nesta consulta sem nova cobrança: 24 h depois da entrega.
+                             */
+                            resultExpiresAt: string | null;
+                            /** @description O processo entregue já não é lido aqui: o prazo passou, ou o acervo já não sustenta a cópia. Uma leitura nova o traz. */
+                            resultExpired: boolean;
+                            /** @description A vigília que a conta já mantém sobre o processo: quando olhou pela última vez e quando olha de novo. Só para a chave que lê monitores (`MONITORS_READ`); nulo sem vigília. */
+                            monitor: {
+                                monitorId: string;
+                                /** Format: date-time */
+                                lastCheckedAt: string | null;
+                                /** Format: date-time */
+                                nextCheckAt: string | null;
+                            } | null;
+                            /** @description A ficha entregue, na visão `PROCESS`, enquanto o resultado vale, com as instâncias do número em `instances`, como na leitura direta. Lida da consulta, ela passa de novo pelo controle de confidencialidade. */
+                            process?: {
+                                sourceId?: string | null;
+                                number: string;
+                                formattedNumber: string;
+                                tribunal: {
+                                    alias: string;
+                                    code: string;
+                                };
+                                degree?: string | null;
+                                sigiloLevel?: number | null;
+                                /**
+                                 * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                 * @enum {string}
+                                 */
+                                confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                shareable?: boolean;
+                                class: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                courtBody: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                    municipalityIbgeCode?: number | null;
+                                } | null;
+                                system?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                format?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                /** Format: date-time */
+                                filedAt?: string | null;
+                                /** Format: date-time */
+                                updatedAt?: string | null;
+                                /** Format: date-time */
+                                indexedAt?: string | null;
+                                subjects: {
+                                    code?: number | null;
+                                    name: string;
+                                }[];
+                                djen?: {
+                                    publicationCount: number;
+                                    /** Format: date-time */
+                                    latestPublicationAt?: string | null;
+                                    latestPublicationType?: string | null;
+                                    latestPublicationExcerpt?: string | null;
+                                    latestPublicationUrl?: string | null;
+                                } | null;
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                instances?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                }[];
+                            };
+                            /** @description O retrato entregue, na visão `SNAPSHOT`, enquanto o resultado vale: a instância principal no topo e cada instância do número em `instances`, como na leitura direta. Lido da consulta, ele é composto do que o acervo guarda da última captura de cada instância, e `sourcePayload` é nulo: o documento bruto da fonte não é guardado. */
+                            snapshot?: {
+                                process: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                };
+                                sourcePayload: unknown;
+                                movements: {
+                                    externalMovementKey: string;
+                                    codigo?: number | null;
+                                    nome: string;
+                                    /** Format: date-time */
+                                    dataHora?: string | null;
+                                    complementos: unknown;
+                                    rawPayload: unknown;
+                                }[];
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                instances: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                    /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                    movementsCaptured: boolean;
+                                    /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                    movementCount: number | null;
+                                    /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                    }[] | null;
+                                }[];
+                            };
+                            /** @description Presente só no 202 de uma chamada com `staleOnFailure: true`: a cópia que o acervo guarda, com a data, na visão pedida. Movimentos posteriores a essa data podem existir e não estão nela; é a versão atual que a consulta segue buscando. */
+                            stale?: {
+                                process?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                    instances?: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                    }[];
+                                };
+                                snapshot?: {
+                                    process: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        djen?: {
+                                            publicationCount: number;
+                                            /** Format: date-time */
+                                            latestPublicationAt?: string | null;
+                                            latestPublicationType?: string | null;
+                                            latestPublicationExcerpt?: string | null;
+                                            latestPublicationUrl?: string | null;
+                                        } | null;
+                                    };
+                                    sourcePayload: unknown;
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                        rawPayload: unknown;
+                                    }[];
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                    instances: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                        /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                        movementsCaptured: boolean;
+                                        /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                        movementCount: number | null;
+                                        /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                        movements: {
+                                            externalMovementKey: string;
+                                            codigo?: number | null;
+                                            nome: string;
+                                            /** Format: date-time */
+                                            dataHora?: string | null;
+                                            complementos: unknown;
+                                        }[] | null;
+                                    }[];
+                                };
+                                /**
+                                 * Format: date-time
+                                 * @description Quando a cópia foi buscada na fonte.
+                                 */
+                                sourceFetchedAt: string;
+                                /**
+                                 * @description Por que a fonte não entregou nesta chamada.
+                                 * @enum {string}
+                                 */
+                                cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                            };
+                        };
+                        meta: {
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            credits?: number;
+                            cacheHit?: boolean;
+                            /**
+                             * Format: date-time
+                             * @description Quando os dados servidos foram buscados na fonte: agora, se ela respondeu; antes, se vieram do acervo. No retrato socorrido pelo acervo, é a data da captura dos movimentos servidos. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor.
+                             */
+                            sourceFetchedAt?: string;
+                            /** @description Presente só quando a fonte processual falhou e o motor serviu a cópia que o acervo guarda do processo. A data da cópia está em `meta.sourceFetchedAt`; movimentos posteriores a ela podem existir e não estão na resposta. */
+                            lakeRescue?: {
+                                /**
+                                 * @description Por que a fonte não entregou: `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem poder servir o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume).
+                                 * @enum {string}
+                                 */
+                                cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                /** @description A espera que a fonte pediu: não consulte a fonte de novo antes dela. */
+                                retryAfterSeconds?: number;
+                            };
+                            /** @description Presente só quando a fonte respondeu com parte do índice e o processo estava na parte que respondeu: o documento que o acervo já guardava e não veio sai em `instances` do acervo (`origin: LAKE`), e outra instância que o acervo não conhece, se existir, pode não ter vindo. */
+                            partialIndex?: {
+                                /** @description Partes do índice da fonte que não responderam. */
+                                shardsFailed: number;
+                                /** @description Total de partes do índice; nulo quando a fonte não as contou. */
+                                shardsTotal: number | null;
+                                /** @description A fonte estourou o próprio prazo interno e devolveu só o que deu tempo de olhar. */
+                                timedOut: boolean;
+                            };
+                            /** @description Presente só quando a resposta da fonte trouxe outros documentos do número além da instância principal, que é o topo de `data` (com o grau em `degree`) — em geral de instâncias diferentes, mas dois podem ter o mesmo `grau`. O motor guarda cada documento na sua instância e serve todos em `data.instances`; esta lista é o resumo dos outros que vieram na mesma resposta. Não inclui documento que o motor classificaria como segredo de justiça, e não aparece quando o processo servido é restrito. */
+                            otherInstances?: {
+                                /** @description O grau deste documento na fonte: G1, G2, JE, TR… */
+                                grau: string | null;
+                                /**
+                                 * Format: date-time
+                                 * @description Quando a fonte atualizou este documento pela última vez.
+                                 */
+                                updatedAt: string | null;
+                                /** @description O órgão julgador deste documento, quando a fonte o traz. */
+                                courtBody?: string;
+                            }[];
+                        } & {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: {
+                            /** @description O id da consulta; nulo quando a leitura coube na espera e nenhuma consulta foi aberta. */
+                            lookupId: string | null;
+                            /** @enum {string} */
+                            status: "QUEUED" | "LEASED" | "SUCCEEDED" | "FAILED" | "CANCELED";
+                            /**
+                             * @description O que ler: `PROCESS`, a ficha do processo (a mesma de `GET /v1/processes/{processNumber}`), ou `SNAPSHOT`, o retrato com os movimentos (o de `GET /v1/processes/{processNumber}/snapshot`).
+                             * @enum {string}
+                             */
+                            view: "PROCESS" | "SNAPSHOT";
+                            tribunalAlias: string;
+                            /** @description O número do processo, só os 20 dígitos. */
+                            processNumber: string;
+                            /** @description Onde a consulta é lida, sem nova cobrança; nulo sem consulta aberta. */
+                            pollUrl: string | null;
+                            /** @description A chamada reencontrou a consulta já aberta para a mesma conta, escritório, processo e visão, em vez de abrir outra. */
+                            deduped: boolean;
+                            /** @description Créditos retidos pela consulta: o máximo que a entrega cobra, só se o processo vier — a ficha que outra leitura trouxe ao acervo cobra menos. Enquanto isso, a retenção conta no saldo e no teto diário da chave que abriu a consulta. */
+                            creditsReserved: number;
+                            /** @description O que a mesma compra já cobrou fora da consulta: a cópia guardada entregue em `stale`. A entrega cobra o preço da leitura menos isto. */
+                            alreadyCharged: number;
+                            /** @description Idas à fonte até aqui, a leitura que abriu a consulta incluída. */
+                            attempts: number;
+                            /**
+                             * Format: date-time
+                             * @description Quando a próxima tentativa sai; nulo na consulta terminada e enquanto uma tentativa está em curso. A hora que já passou é a da tentativa esperando a vez na fila. Ler a consulta antes da hora futura devolve o mesmo estado.
+                             */
+                            nextAttemptAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando a consulta tenta; depois, termina sem o processo e devolve a retenção. Nulo sem consulta aberta.
+                             */
+                            giveUpAt: string | null;
+                            /** @description A última ida à fonte que não entregou: quando, e por quê — `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume). */
+                            lastAttempt: {
+                                /** Format: date-time */
+                                at: string;
+                                /** @enum {string} */
+                                code: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                retryable: boolean;
+                            } | null;
+                            /**
+                             * @description Quem entregou: `SOURCE`, uma tentativa na fonte; `LAKE`, o acervo, que outra leitura atualizou depois de a consulta abrir; `DIRECT_READ`, uma leitura sua do mesmo processo, que entregou e cobrou antes — a consulta fecha sem cobrar. Nulo enquanto não houve entrega.
+                             * @enum {string|null}
+                             */
+                            satisfiedBy: "SOURCE" | "LAKE" | "DIRECT_READ" | null;
+                            creditsCharged: number | null;
+                            creditsRefunded: number | null;
+                            /** @description Por que a consulta terminou sem o processo: o código da taxonomia de erros, como a leitura síncrona o daria. */
+                            error: {
+                                /** @enum {string} */
+                                class: "RETRYABLE" | "TERMINAL";
+                                code: string;
+                                /** @description O texto público fixo do código, o mesmo em toda consulta. */
+                                message: string;
+                                retryable: boolean;
+                                upstreamStatus?: number;
+                            } | null;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            finishedAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando o processo entregue é lido nesta consulta sem nova cobrança: 24 h depois da entrega.
+                             */
+                            resultExpiresAt: string | null;
+                            /** @description O processo entregue já não é lido aqui: o prazo passou, ou o acervo já não sustenta a cópia. Uma leitura nova o traz. */
+                            resultExpired: boolean;
+                            /** @description A vigília que a conta já mantém sobre o processo: quando olhou pela última vez e quando olha de novo. Só para a chave que lê monitores (`MONITORS_READ`); nulo sem vigília. */
+                            monitor: {
+                                monitorId: string;
+                                /** Format: date-time */
+                                lastCheckedAt: string | null;
+                                /** Format: date-time */
+                                nextCheckAt: string | null;
+                            } | null;
+                            /** @description A ficha entregue, na visão `PROCESS`, enquanto o resultado vale, com as instâncias do número em `instances`, como na leitura direta. Lida da consulta, ela passa de novo pelo controle de confidencialidade. */
+                            process?: {
+                                sourceId?: string | null;
+                                number: string;
+                                formattedNumber: string;
+                                tribunal: {
+                                    alias: string;
+                                    code: string;
+                                };
+                                degree?: string | null;
+                                sigiloLevel?: number | null;
+                                /**
+                                 * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                 * @enum {string}
+                                 */
+                                confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                shareable?: boolean;
+                                class: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                courtBody: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                    municipalityIbgeCode?: number | null;
+                                } | null;
+                                system?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                format?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                /** Format: date-time */
+                                filedAt?: string | null;
+                                /** Format: date-time */
+                                updatedAt?: string | null;
+                                /** Format: date-time */
+                                indexedAt?: string | null;
+                                subjects: {
+                                    code?: number | null;
+                                    name: string;
+                                }[];
+                                djen?: {
+                                    publicationCount: number;
+                                    /** Format: date-time */
+                                    latestPublicationAt?: string | null;
+                                    latestPublicationType?: string | null;
+                                    latestPublicationExcerpt?: string | null;
+                                    latestPublicationUrl?: string | null;
+                                } | null;
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                instances?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                }[];
+                            };
+                            /** @description O retrato entregue, na visão `SNAPSHOT`, enquanto o resultado vale: a instância principal no topo e cada instância do número em `instances`, como na leitura direta. Lido da consulta, ele é composto do que o acervo guarda da última captura de cada instância, e `sourcePayload` é nulo: o documento bruto da fonte não é guardado. */
+                            snapshot?: {
+                                process: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                };
+                                sourcePayload: unknown;
+                                movements: {
+                                    externalMovementKey: string;
+                                    codigo?: number | null;
+                                    nome: string;
+                                    /** Format: date-time */
+                                    dataHora?: string | null;
+                                    complementos: unknown;
+                                    rawPayload: unknown;
+                                }[];
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                instances: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                    /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                    movementsCaptured: boolean;
+                                    /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                    movementCount: number | null;
+                                    /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                    }[] | null;
+                                }[];
+                            };
+                            /** @description Presente só no 202 de uma chamada com `staleOnFailure: true`: a cópia que o acervo guarda, com a data, na visão pedida. Movimentos posteriores a essa data podem existir e não estão nela; é a versão atual que a consulta segue buscando. */
+                            stale?: {
+                                process?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                    instances?: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                    }[];
+                                };
+                                snapshot?: {
+                                    process: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        djen?: {
+                                            publicationCount: number;
+                                            /** Format: date-time */
+                                            latestPublicationAt?: string | null;
+                                            latestPublicationType?: string | null;
+                                            latestPublicationExcerpt?: string | null;
+                                            latestPublicationUrl?: string | null;
+                                        } | null;
+                                    };
+                                    sourcePayload: unknown;
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                        rawPayload: unknown;
+                                    }[];
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                    instances: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                        /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                        movementsCaptured: boolean;
+                                        /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                        movementCount: number | null;
+                                        /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                        movements: {
+                                            externalMovementKey: string;
+                                            codigo?: number | null;
+                                            nome: string;
+                                            /** Format: date-time */
+                                            dataHora?: string | null;
+                                            complementos: unknown;
+                                        }[] | null;
+                                    }[];
+                                };
+                                /**
+                                 * Format: date-time
+                                 * @description Quando a cópia foi buscada na fonte.
+                                 */
+                                sourceFetchedAt: string;
+                                /**
+                                 * @description Por que a fonte não entregou nesta chamada.
+                                 * @enum {string}
+                                 */
+                                cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                            };
+                        };
+                        meta: {
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            credits?: number;
+                            cacheHit?: boolean;
+                            /** @description O rastro da chamada, o mesmo do evento que a consulta emite. */
+                            traceId?: string;
+                        } & {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    getProcessLookup: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description Identificador da requisição escolhido pelo cliente, ecoado em meta.requestId e no corpo de erro. Tem DOIS papéis: (1) rastreio, em toda rota — é por ele que o suporte encontra a chamada; (2) idempotência por conta em POST /v1/publications/text-searches e POST /v1/search-jobs, onde reenviar o mesmo valor reapresenta o resultado já produzido, sem nova cobrança. Fora dessas duas rotas o valor não deduplica nada: para repetir uma chamada de propósito, mande um valor novo. Aceita [A-Za-z0-9_.:-], até 200 caracteres; valor fora disso é ignorado e o motor cunha o próprio. */
+                "x-request-id"?: string;
+                /** @description Atribui a chamada a um sub-tenant seu (por exemplo, um escritório) na medição de uso e no roteamento de eventos. Opcional. */
+                "x-office-id"?: string;
+            };
+            path: {
+                lookupId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Resposta padrão */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        data: {
+                            /** @description O id da consulta; nulo quando a leitura coube na espera e nenhuma consulta foi aberta. */
+                            lookupId: string | null;
+                            /** @enum {string} */
+                            status: "QUEUED" | "LEASED" | "SUCCEEDED" | "FAILED" | "CANCELED";
+                            /**
+                             * @description O que ler: `PROCESS`, a ficha do processo (a mesma de `GET /v1/processes/{processNumber}`), ou `SNAPSHOT`, o retrato com os movimentos (o de `GET /v1/processes/{processNumber}/snapshot`).
+                             * @enum {string}
+                             */
+                            view: "PROCESS" | "SNAPSHOT";
+                            tribunalAlias: string;
+                            /** @description O número do processo, só os 20 dígitos. */
+                            processNumber: string;
+                            /** @description Onde a consulta é lida, sem nova cobrança; nulo sem consulta aberta. */
+                            pollUrl: string | null;
+                            /** @description A chamada reencontrou a consulta já aberta para a mesma conta, escritório, processo e visão, em vez de abrir outra. */
+                            deduped: boolean;
+                            /** @description Créditos retidos pela consulta: o máximo que a entrega cobra, só se o processo vier — a ficha que outra leitura trouxe ao acervo cobra menos. Enquanto isso, a retenção conta no saldo e no teto diário da chave que abriu a consulta. */
+                            creditsReserved: number;
+                            /** @description O que a mesma compra já cobrou fora da consulta: a cópia guardada entregue em `stale`. A entrega cobra o preço da leitura menos isto. */
+                            alreadyCharged: number;
+                            /** @description Idas à fonte até aqui, a leitura que abriu a consulta incluída. */
+                            attempts: number;
+                            /**
+                             * Format: date-time
+                             * @description Quando a próxima tentativa sai; nulo na consulta terminada e enquanto uma tentativa está em curso. A hora que já passou é a da tentativa esperando a vez na fila. Ler a consulta antes da hora futura devolve o mesmo estado.
+                             */
+                            nextAttemptAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando a consulta tenta; depois, termina sem o processo e devolve a retenção. Nulo sem consulta aberta.
+                             */
+                            giveUpAt: string | null;
+                            /** @description A última ida à fonte que não entregou: quando, e por quê — `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume). */
+                            lastAttempt: {
+                                /** Format: date-time */
+                                at: string;
+                                /** @enum {string} */
+                                code: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                                retryable: boolean;
+                            } | null;
+                            /**
+                             * @description Quem entregou: `SOURCE`, uma tentativa na fonte; `LAKE`, o acervo, que outra leitura atualizou depois de a consulta abrir; `DIRECT_READ`, uma leitura sua do mesmo processo, que entregou e cobrou antes — a consulta fecha sem cobrar. Nulo enquanto não houve entrega.
+                             * @enum {string|null}
+                             */
+                            satisfiedBy: "SOURCE" | "LAKE" | "DIRECT_READ" | null;
+                            creditsCharged: number | null;
+                            creditsRefunded: number | null;
+                            /** @description Por que a consulta terminou sem o processo: o código da taxonomia de erros, como a leitura síncrona o daria. */
+                            error: {
+                                /** @enum {string} */
+                                class: "RETRYABLE" | "TERMINAL";
+                                code: string;
+                                /** @description O texto público fixo do código, o mesmo em toda consulta. */
+                                message: string;
+                                retryable: boolean;
+                                upstreamStatus?: number;
+                            } | null;
+                            /** Format: date-time */
+                            createdAt: string;
+                            /** Format: date-time */
+                            finishedAt: string | null;
+                            /**
+                             * Format: date-time
+                             * @description Até quando o processo entregue é lido nesta consulta sem nova cobrança: 24 h depois da entrega.
+                             */
+                            resultExpiresAt: string | null;
+                            /** @description O processo entregue já não é lido aqui: o prazo passou, ou o acervo já não sustenta a cópia. Uma leitura nova o traz. */
+                            resultExpired: boolean;
+                            /** @description A vigília que a conta já mantém sobre o processo: quando olhou pela última vez e quando olha de novo. Só para a chave que lê monitores (`MONITORS_READ`); nulo sem vigília. */
+                            monitor: {
+                                monitorId: string;
+                                /** Format: date-time */
+                                lastCheckedAt: string | null;
+                                /** Format: date-time */
+                                nextCheckAt: string | null;
+                            } | null;
+                            /** @description A ficha entregue, na visão `PROCESS`, enquanto o resultado vale, com as instâncias do número em `instances`, como na leitura direta. Lida da consulta, ela passa de novo pelo controle de confidencialidade. */
+                            process?: {
+                                sourceId?: string | null;
+                                number: string;
+                                formattedNumber: string;
+                                tribunal: {
+                                    alias: string;
+                                    code: string;
+                                };
+                                degree?: string | null;
+                                sigiloLevel?: number | null;
+                                /**
+                                 * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                 * @enum {string}
+                                 */
+                                confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                shareable?: boolean;
+                                class: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                courtBody: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                    municipalityIbgeCode?: number | null;
+                                } | null;
+                                system?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                format?: {
+                                    code?: number | null;
+                                    name?: string | null;
+                                } | null;
+                                /** Format: date-time */
+                                filedAt?: string | null;
+                                /** Format: date-time */
+                                updatedAt?: string | null;
+                                /** Format: date-time */
+                                indexedAt?: string | null;
+                                subjects: {
+                                    code?: number | null;
+                                    name: string;
+                                }[];
+                                djen?: {
+                                    publicationCount: number;
+                                    /** Format: date-time */
+                                    latestPublicationAt?: string | null;
+                                    latestPublicationType?: string | null;
+                                    latestPublicationExcerpt?: string | null;
+                                    latestPublicationUrl?: string | null;
+                                } | null;
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                instances?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                }[];
+                            };
+                            /** @description O retrato entregue, na visão `SNAPSHOT`, enquanto o resultado vale: a instância principal no topo e cada instância do número em `instances`, como na leitura direta. Lido da consulta, ele é composto do que o acervo guarda da última captura de cada instância, e `sourcePayload` é nulo: o documento bruto da fonte não é guardado. */
+                            snapshot?: {
+                                process: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                };
+                                sourcePayload: unknown;
+                                movements: {
+                                    externalMovementKey: string;
+                                    codigo?: number | null;
+                                    nome: string;
+                                    /** Format: date-time */
+                                    dataHora?: string | null;
+                                    complementos: unknown;
+                                    rawPayload: unknown;
+                                }[];
+                                /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                instances: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                    primary: boolean;
+                                    /**
+                                     * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                     * @enum {string}
+                                     */
+                                    origin: "SOURCE" | "LAKE";
+                                    /**
+                                     * Format: date-time
+                                     * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                     */
+                                    fetchedAt: string;
+                                    /**
+                                     * Format: date-time
+                                     * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                     */
+                                    absentSince: string | null;
+                                    /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                    movementsCaptured: boolean;
+                                    /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                    movementCount: number | null;
+                                    /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                    }[] | null;
+                                }[];
+                            };
+                            /** @description Presente só no 202 de uma chamada com `staleOnFailure: true`: a cópia que o acervo guarda, com a data, na visão pedida. Movimentos posteriores a essa data podem existir e não estão nela; é a versão atual que a consulta segue buscando. */
+                            stale?: {
+                                process?: {
+                                    sourceId?: string | null;
+                                    number: string;
+                                    formattedNumber: string;
+                                    tribunal: {
+                                        alias: string;
+                                        code: string;
+                                    };
+                                    degree?: string | null;
+                                    sigiloLevel?: number | null;
+                                    /**
+                                     * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                     * @enum {string}
+                                     */
+                                    confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                    /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                    shareable?: boolean;
+                                    class: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    courtBody: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                        municipalityIbgeCode?: number | null;
+                                    } | null;
+                                    system?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    format?: {
+                                        code?: number | null;
+                                        name?: string | null;
+                                    } | null;
+                                    /** Format: date-time */
+                                    filedAt?: string | null;
+                                    /** Format: date-time */
+                                    updatedAt?: string | null;
+                                    /** Format: date-time */
+                                    indexedAt?: string | null;
+                                    subjects: {
+                                        code?: number | null;
+                                        name: string;
+                                    }[];
+                                    djen?: {
+                                        publicationCount: number;
+                                        /** Format: date-time */
+                                        latestPublicationAt?: string | null;
+                                        latestPublicationType?: string | null;
+                                        latestPublicationExcerpt?: string | null;
+                                        latestPublicationUrl?: string | null;
+                                    } | null;
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor. */
+                                    instances?: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                    }[];
+                                };
+                                snapshot?: {
+                                    process: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        djen?: {
+                                            publicationCount: number;
+                                            /** Format: date-time */
+                                            latestPublicationAt?: string | null;
+                                            latestPublicationType?: string | null;
+                                            latestPublicationExcerpt?: string | null;
+                                            latestPublicationUrl?: string | null;
+                                        } | null;
+                                    };
+                                    sourcePayload: unknown;
+                                    movements: {
+                                        externalMovementKey: string;
+                                        codigo?: number | null;
+                                        nome: string;
+                                        /** Format: date-time */
+                                        dataHora?: string | null;
+                                        complementos: unknown;
+                                        rawPayload: unknown;
+                                    }[];
+                                    /** @description Todos os documentos que o motor guarda deste número — em geral um por instância (1º grau, 2º grau, turma recursal…), às vezes dois do mesmo grau —, a principal primeiro, depois os que a fonte ainda traz e por fim os que ela deixou de trazer. O topo da resposta é a principal. Cada um leva a classificação do número inteiro: basta um documento em segredo de justiça para todos saírem marcados. `process` e `movements` são os da principal, e cada instância traz os movimentos dela. */
+                                    instances: {
+                                        sourceId?: string | null;
+                                        number: string;
+                                        formattedNumber: string;
+                                        tribunal: {
+                                            alias: string;
+                                            code: string;
+                                        };
+                                        degree?: string | null;
+                                        sigiloLevel?: number | null;
+                                        /**
+                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
+                                         * @enum {string}
+                                         */
+                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
+                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
+                                        shareable?: boolean;
+                                        class: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        courtBody: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                            municipalityIbgeCode?: number | null;
+                                        } | null;
+                                        system?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        format?: {
+                                            code?: number | null;
+                                            name?: string | null;
+                                        } | null;
+                                        /** Format: date-time */
+                                        filedAt?: string | null;
+                                        /** Format: date-time */
+                                        updatedAt?: string | null;
+                                        /** Format: date-time */
+                                        indexedAt?: string | null;
+                                        subjects: {
+                                            code?: number | null;
+                                            name: string;
+                                        }[];
+                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
+                                        primary: boolean;
+                                        /**
+                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
+                                         * @enum {string}
+                                         */
+                                        origin: "SOURCE" | "LAKE";
+                                        /**
+                                         * Format: date-time
+                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
+                                         */
+                                        fetchedAt: string;
+                                        /**
+                                         * Format: date-time
+                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
+                                         */
+                                        absentSince: string | null;
+                                        /** @description Se o motor guarda os movimentos desta instância. Falso quando eles nunca foram capturados — o documento só veio numa ficha ou numa busca — ou quando o acervo já não guarda algum deles, e aí `movements` e `movementCount` são nulos. */
+                                        movementsCaptured: boolean;
+                                        /** @description Quantos movimentos a última captura desta instância trouxe; nulo quando eles nunca foram capturados. */
+                                        movementCount: number | null;
+                                        /** @description Os movimentos da última captura desta instância, do mais recente ao mais antigo, sem o payload bruto da fonte; nulo quando eles nunca foram capturados. */
+                                        movements: {
+                                            externalMovementKey: string;
+                                            codigo?: number | null;
+                                            nome: string;
+                                            /** Format: date-time */
+                                            dataHora?: string | null;
+                                            complementos: unknown;
+                                        }[] | null;
+                                    }[];
+                                };
+                                /**
+                                 * Format: date-time
+                                 * @description Quando a cópia foi buscada na fonte.
+                                 */
+                                sourceFetchedAt: string;
+                                /**
+                                 * @description Por que a fonte não entregou nesta chamada.
+                                 * @enum {string}
+                                 */
+                                cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
+                            };
+                        };
+                        meta: {
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            credits?: number;
+                            cacheHit?: boolean;
+                            /**
+                             * Format: date-time
+                             * @description Quando os dados servidos foram buscados na fonte: agora, se ela respondeu; antes, se vieram do acervo. No retrato socorrido pelo acervo, é a data da captura dos movimentos servidos. Ausente na ficha que o controle de confidencialidade entrega retida, sem o teor.
+                             */
+                            sourceFetchedAt?: string;
+                        } & {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            402: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    cancelProcessLookup: {
         parameters: {
             query?: never;
             header?: {
@@ -3454,19 +6589,12 @@ export interface operations {
                 /** @description Atribui a chamada a um sub-tenant seu (por exemplo, um escritório) na medição de uso e no roteamento de eventos. Opcional. */
                 "x-office-id"?: string;
             };
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": {
-                    items: {
-                        tribunalAlias: string;
-                        processNumber: string;
-                    }[];
-                };
+            path: {
+                lookupId: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
             /** @description Resposta padrão */
             200: {
@@ -3476,160 +6604,10 @@ export interface operations {
                 content: {
                     "application/json": {
                         data: {
-                            total: number;
-                            succeeded: number;
-                            failed: number;
-                            items: ({
-                                tribunalAlias: string;
-                                processNumber: string;
-                                ok: boolean;
-                                snapshot?: {
-                                    process: {
-                                        sourceId?: string | null;
-                                        number: string;
-                                        formattedNumber: string;
-                                        tribunal: {
-                                            alias: string;
-                                            code: string;
-                                        };
-                                        degree?: string | null;
-                                        sigiloLevel?: number | null;
-                                        /**
-                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
-                                         * @enum {string}
-                                         */
-                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
-                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
-                                        shareable?: boolean;
-                                        class: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        courtBody: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                            municipalityIbgeCode?: number | null;
-                                        } | null;
-                                        system?: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        format?: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        /** Format: date-time */
-                                        filedAt?: string | null;
-                                        /** Format: date-time */
-                                        updatedAt?: string | null;
-                                        /** Format: date-time */
-                                        indexedAt?: string | null;
-                                        subjects: {
-                                            code?: number | null;
-                                            name: string;
-                                        }[];
-                                        djen?: {
-                                            publicationCount: number;
-                                            /** Format: date-time */
-                                            latestPublicationAt?: string | null;
-                                            latestPublicationType?: string | null;
-                                            latestPublicationExcerpt?: string | null;
-                                            latestPublicationUrl?: string | null;
-                                        } | null;
-                                    };
-                                    movements: unknown[];
-                                    /** @description Os documentos que o motor guarda do número, a principal primeiro, só com o cabeçalho de cada um: os movimentos de cada instância vêm no retrato de um processo. */
-                                    instances: {
-                                        sourceId?: string | null;
-                                        number: string;
-                                        formattedNumber: string;
-                                        tribunal: {
-                                            alias: string;
-                                            code: string;
-                                        };
-                                        degree?: string | null;
-                                        sigiloLevel?: number | null;
-                                        /**
-                                         * @description Classificação do motor: PUBLIC ou SEGREDO_DE_JUSTICA. Linha em segredo nunca deve ser exibida a público.
-                                         * @enum {string}
-                                         */
-                                        confidentiality?: "PUBLIC" | "SEGREDO_DE_JUSTICA";
-                                        /** @description Se a linha pode ser amortizada entre consumidores. Falso acompanha o segredo e também a linha que o motor reteve por outro motivo. */
-                                        shareable?: boolean;
-                                        class: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        courtBody: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                            municipalityIbgeCode?: number | null;
-                                        } | null;
-                                        system?: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        format?: {
-                                            code?: number | null;
-                                            name?: string | null;
-                                        } | null;
-                                        /** Format: date-time */
-                                        filedAt?: string | null;
-                                        /** Format: date-time */
-                                        updatedAt?: string | null;
-                                        /** Format: date-time */
-                                        indexedAt?: string | null;
-                                        subjects: {
-                                            code?: number | null;
-                                            name: string;
-                                        }[];
-                                        /** @description A instância principal do número, a que o topo da resposta serve. É a mesma de uma leitura para a outra e só muda quando uma resposta completa da fonte pelo número deixa de trazê-la. */
-                                        primary: boolean;
-                                        /**
-                                         * @description `SOURCE`: veio da fonte nesta resposta. `LAKE`: servida do que o acervo guarda — a fonte não a trouxe nesta resposta, ou a resposta inteira saiu do acervo.
-                                         * @enum {string}
-                                         */
-                                        origin: "SOURCE" | "LAKE";
-                                        /**
-                                         * Format: date-time
-                                         * @description Quando os dados desta instância foram buscados na fonte. No retrato, com os movimentos servidos do acervo, é a data da captura deles.
-                                         */
-                                        fetchedAt: string;
-                                        /**
-                                         * Format: date-time
-                                         * @description Desde quando a resposta completa da fonte pelo número vem sem este documento; nulo enquanto ela o traz.
-                                         */
-                                        absentSince: string | null;
-                                    }[];
-                                };
-                                /** @description Presente só no item que a fonte processual não entregou e que o acervo socorreu com a cópia guardada de até 24 h: a causa, a espera que a fonte pediu, quando pediu, e quando a cópia foi buscada. O item socorrido custa 1 crédito. */
-                                lakeRescue?: {
-                                    /**
-                                     * @description Por que a fonte não entregou: `UPSTREAM_TIMEOUT` (não respondeu dentro da espera), `UPSTREAM_UNAVAILABLE` (indisponível, ou respondeu com parte do índice sem poder servir o processo) ou `UPSTREAM_RATE_LIMITED` (pediu para esperar por volume).
-                                     * @enum {string}
-                                     */
-                                    cause: "UPSTREAM_TIMEOUT" | "UPSTREAM_UNAVAILABLE" | "UPSTREAM_RATE_LIMITED";
-                                    /** @description A espera que a fonte pediu: não consulte a fonte de novo antes dela. */
-                                    retryAfterSeconds?: number;
-                                    /**
-                                     * Format: date-time
-                                     * @description Quando a cópia servida foi buscada na fonte.
-                                     */
-                                    sourceFetchedAt: string;
-                                };
-                                error?: {
-                                    status?: number;
-                                    /** @description Código estável da taxonomia, quando a falha do item o carrega — é o que distingue, por exemplo, a recusa da chave de teste de um bloqueio LGPD. */
-                                    code?: string;
-                                    /** @description Os mesmos `details` do envelope de erro da rota unitária — na recusa da chave de teste, `reason` diz a causa. */
-                                    details?: {
-                                        [key: string]: unknown;
-                                    };
-                                    message: string;
-                                };
-                            } & {
-                                [key: string]: unknown;
-                            })[];
+                            lookupId: string;
+                            /** @enum {boolean} */
+                            canceled: true;
+                            refunded: boolean;
                         };
                         meta: {
                             /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
@@ -3763,6 +6741,66 @@ export interface operations {
                 };
             };
             /** @description Resposta padrão */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /** @description Código estável da taxonomia (VALIDATION_ERROR, QUOTA_EXCEEDED, UPSTREAM_TIMEOUT…). É por ele que se programa, não pela mensagem. */
+                            code: string;
+                            /** @description Descrição legível, sujeita a mudança. */
+                            message: string;
+                            /** @description Identificador da requisição, para suporte e rastreamento. É o X-Request-Id enviado pelo cliente quando há um; senão, um req_<uuid> cunhado pelo motor. */
+                            requestId: string;
+                            /**
+                             * @description Classificação da falha. TERMINAL não melhora com nova tentativa; RETRYABLE sim.
+                             * @enum {string}
+                             */
+                            class: "RETRYABLE" | "TERMINAL";
+                            /** @description Atalho booleano de `class`, para quem só precisa decidir se repete. */
+                            retryable: boolean;
+                            /** @description Status HTTP real devolvido pela fonte externa, quando a falha veio dela. Preservado sem tradução. */
+                            upstreamStatus?: number;
+                            details: {
+                                [key: string]: unknown;
+                            };
+                        };
+                    };
+                };
+            };
+            /** @description Resposta padrão */
             429: {
                 headers: {
                     [name: string]: unknown;
@@ -8098,10 +11136,10 @@ export interface operations {
                             }[];
                             coverage: {
                                 /**
-                                 * @description NONE = nada indexado nem colheita registrada; PARTIAL = há fatia de colheita pendente (o indexado pode crescer); INDEXED = há documento pesquisável indexado e nenhuma colheita pendente.
+                                 * @description NONE = nada indexado nem colheita registrada; PARTIAL = há fatia de colheita pendente (o indexado pode crescer); INDEXED = há documento pesquisável indexado e nenhuma colheita pendente. UNAVAILABLE = a cobertura do recorte não coube no prazo da busca: `byTribunalMonth` vem vazio, o ranking vem inteiro e a busca custa o preço de sempre. O valor congelado não muda depois; a cobertura do mesmo recorte sai em GET /v1/publications/corpus/coverage, a 0 crédito, com os tribunais da busca num só `tribunalCodes`, separados por vírgula (`tribunalCodes=STJ,TJSP`), e a janela dela em `from` e `to`.
                                  * @enum {string}
                                  */
-                                overallState: "NONE" | "PARTIAL" | "INDEXED";
+                                overallState: "NONE" | "PARTIAL" | "INDEXED" | "UNAVAILABLE";
                                 byTribunalMonth: {
                                     source?: string;
                                     tribunalSigla: string;
@@ -8358,10 +11396,10 @@ export interface operations {
                             corpusWatermark: string | null;
                             coverage: {
                                 /**
-                                 * @description NONE = nada indexado nem colheita registrada; PARTIAL = há fatia de colheita pendente (o indexado pode crescer); INDEXED = há documento pesquisável indexado e nenhuma colheita pendente.
+                                 * @description NONE = nada indexado nem colheita registrada; PARTIAL = há fatia de colheita pendente (o indexado pode crescer); INDEXED = há documento pesquisável indexado e nenhuma colheita pendente. UNAVAILABLE = a cobertura do recorte não coube no prazo da busca: `byTribunalMonth` vem vazio, o ranking vem inteiro e a busca custa o preço de sempre. O valor congelado não muda depois; a cobertura do mesmo recorte sai em GET /v1/publications/corpus/coverage, a 0 crédito, com os tribunais da busca num só `tribunalCodes`, separados por vírgula (`tribunalCodes=STJ,TJSP`), e a janela dela em `from` e `to`.
                                  * @enum {string}
                                  */
-                                overallState: "NONE" | "PARTIAL" | "INDEXED";
+                                overallState: "NONE" | "PARTIAL" | "INDEXED" | "UNAVAILABLE";
                                 byTribunalMonth: {
                                     source?: string;
                                     tribunalSigla: string;
@@ -8685,6 +11723,7 @@ export interface operations {
     getPublicationCorpusCoverage: {
         parameters: {
             query?: {
+                /** @description Tribunais do recorte num só valor, separados por vírgula (`tribunalCodes=STJ,TJSP`), pela sigla ou pelo apelido da fonte. Sem ele, a cobertura é a de todos os tribunais do acervo. */
                 tribunalCodes?: string;
                 from?: string;
                 to?: string;
@@ -12093,7 +15132,7 @@ export interface operations {
                             windowDays: number;
                             items: ({
                                 /** @enum {string} */
-                                type: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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";
+                                type: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE";
                                 /** @enum {string} */
                                 class: "DATA" | "OPERATIONAL";
                                 count: number;
@@ -12104,7 +15143,7 @@ export interface operations {
                             })[];
                             dismissed: ({
                                 /** @enum {string} */
-                                type: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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";
+                                type: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE";
                                 /** Format: date-time */
                                 dismissedAt: string;
                             } & {
@@ -12309,7 +15348,7 @@ export interface operations {
             query?: {
                 cursor?: string;
                 limit?: number;
-                type?: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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";
+                type?: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE";
                 monitorId?: string;
                 since?: unknown;
                 until?: unknown;
@@ -13062,7 +16101,7 @@ export interface operations {
                     /** Format: uri */
                     url: string;
                     description?: string;
-                    eventTypes: ("PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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")[];
+                    eventTypes: ("PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE")[];
                     /** @default true */
                     isActive?: boolean;
                 };
@@ -13537,7 +16576,7 @@ export interface operations {
                     /** Format: uri */
                     url?: string;
                     description?: string;
-                    eventTypes?: ("PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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")[];
+                    eventTypes?: ("PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE")[];
                     isActive?: boolean;
                 };
             };
@@ -14230,7 +17269,7 @@ export interface operations {
                     from: unknown;
                     to?: unknown;
                     /** @enum {string} */
-                    type?: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "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";
+                    type?: "PROCESS_MOVEMENT_CREATED" | "PROCESS_INSTANCE_DISCOVERED" | "PUBLICATION_CREATED" | "MONITOR_SYNC_SUCCEEDED" | "MONITOR_SYNC_FAILED" | "SEARCH_JOB_COMPLETED" | "PUBLICATION_TEXT_ALERT_MATCHED" | "PUBLICATION_HARVEST_COMPLETED" | "PROCESS_LOOKUP_COMPLETED" | "QUOTA_LOW" | "PERIOD_ENDING" | "SUBSCRIPTION_PAST_DUE";
                     /** @default false */
                     includeDelivered?: boolean;
                 };