sgp-sdk 1.2.0 → 2.0.0-beta.2

package/dist/operations/pre-registrations-list-plans.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const preRegistrationPlansSchema: z.ZodArray<z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodNumber, "PreRegistrationPlanId", "out">;
+    tipo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    valor: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    descricao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    observacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    gateway: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        gateway_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+        id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+        descricao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>;
+/**
+ * The response of `POST /api/precadastro/plano/list`, in SGP's own shape: a bare array with one
+ * entry per plan of the pré-cadastro catalog. The route is not paginated, so there is no envelope
+ * and no total. Each `id` is a `PreRegistrationPlanId`, a type apart from the `PlanId` of
+ * `plans.list`.
+ */
+export type PreRegistrationsListPlansData = z.output<typeof preRegistrationPlansSchema>;
+/** INTERNAL definition of `preRegistrations.listPlans`. */
+export declare const preRegistrationsListPlans: OperationDefinition<PreRegistrationsListPlansData, "preRegistrations.listPlans">;
+export {};

package/dist/operations/pre-registrations-list-sellers.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const sellersSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    nome: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cpf: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$loose>>;
+/**
+ * The response of `POST /api/precadastro/vendedor/list`, in SGP's own shape: a bare array with one
+ * entry per seller. The route is not paginated, so there is no envelope and no total.
+ */
+export type PreRegistrationsListSellersData = z.output<typeof sellersSchema>;
+/** INTERNAL definition of `preRegistrations.listSellers`. */
+export declare const preRegistrationsListSellers: OperationDefinition<PreRegistrationsListSellersData, "preRegistrations.listSellers">;
+export {};

package/dist/operations/services-add-generic.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+import type { PlanId } from "./plans-list.js";
+/** Input of `services.addGeneric`, named as SGP names the fields. */
+export interface ServiceAddGenericInput {
+    /**
+     * Exercised only in the refused call. ID of the contract; SGP's TV route refuses a contract
+     * that is not active, and this route is not known to differ.
+     */
+    clientecontrato_id: number;
+    /**
+     * Exercised only with a plan of another type, which SGP refused (400). ID of a plan of the
+     * generic type: a `PlanId` from the URA plan list (`plans.list`), where the provider has created
+     * one in the panel (Administração > Planos > Cadastrar > Serviços). SGP refuses any other plan
+     * type. Whether the URA list shows generic plans is not confirmed.
+     */
+    planobase_id: PlanId;
+    /**
+     * Sent in the refused call (which was refused for its plan), so its effect on a service is
+     * unobserved. Free-text description of the service. Personal data: never log it.
+     */
+    descricao?: string;
+    /** Documented, never sent. The panel's "Gateway ID". Treated as a network identifier. */
+    identificador_gateway?: string;
+    /** Documented, never sent. The panel's "Gateway Extra". Treated as a network identifier. */
+    identificador_gateway_extra?: string;
+    /** Documented, never sent. Login of the service. Secret: never log it. */
+    login?: string;
+    /** Documented, never sent. Password of the service. Secret: never log it. */
+    senha?: string;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const servicesAddGenericInputSchema: z.ZodObject<{
+    clientecontrato_id: z.ZodNumber;
+    planobase_id: z.core.$ZodBranded<z.ZodNumber, "PlanId", "out">;
+    descricao: z.ZodOptional<z.ZodString>;
+    identificador_gateway: z.ZodOptional<z.ZodString>;
+    identificador_gateway_extra: z.ZodOptional<z.ZodString>;
+    login: z.ZodOptional<z.ZodString>;
+    senha: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Success body of `POST /api/servico/generico`: documented, never observed (the provider has no
+ * generic plan, and plans are not created for tests). Nothing is assumed beyond a JSON object;
+ * whatever SGP sends is kept as received.
+ */
+declare const genericAddedSchema: z.ZodObject<{}, z.core.$loose>;
+/** Response of `services.addGeneric`: the JSON object SGP sent, unread. */
+export type ServiceAddGenericData = z.output<typeof genericAddedSchema>;
+/** INTERNAL definition of `services.addGeneric`. */
+export declare const servicesAddGeneric: OperationDefinition<ServiceAddGenericData, "services.addGeneric">;
+export {};

package/dist/operations/services-add-tv.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+import type { PlanId } from "./plans-list.js";
+/** Input of `services.addTv`, named as SGP names the fields. */
+export interface ServiceAddTvInput {
+    /** Exercised. ID of the contract; it must be active (SGP refuses otherwise). */
+    clientecontrato_id: number;
+    /**
+     * Exercised. ID of the TV plan, a `PlanId` from the URA plan list (`plans.list`): a TV plan was
+     * accepted and a read-back confirmed the plan. The ID spaces differ: a plan id from this list
+     * was refused (400) as `plano_id` on the pré-cadastro route while accepted (200) as
+     * `planobase_id` here.
+     */
+    planobase_id: PlanId;
+    /** Exercised. Free-text note about the service. Personal data: never log it. */
+    info_extra?: string;
+    /** Documented, never sent. ID of the equipment type. */
+    tipo_equipamento?: number;
+    /**
+     * Documented, never sent. ID of the address to copy to the installation (omitted: the
+     * customer's).
+     */
+    endereco_id?: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const servicesAddTvInputSchema: z.ZodObject<{
+    clientecontrato_id: z.ZodNumber;
+    planobase_id: z.core.$ZodBranded<z.ZodNumber, "PlanId", "out">;
+    info_extra: z.ZodOptional<z.ZodString>;
+    tipo_equipamento: z.ZodOptional<z.ZodNumber>;
+    endereco_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Success body of `POST /api/servico/tv` (HTTP 201): SGP's `msg`, the new `servico_id` (a number)
+ * and `clientecontrato_id`, which SGP sends as text (`"<n>"`) and `data` carries as a number
+ * (changed versus 2.0.0-beta.1). Other keys SGP may add are kept.
+ */
+declare const tvAddedSchema: z.ZodObject<{
+    msg: z.ZodString;
+    clientecontrato_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+    servico_id: z.ZodNumber;
+}, z.core.$loose>;
+/** Response of `services.addTv`. */
+export type ServiceAddTvData = z.output<typeof tvAddedSchema>;
+/** INTERNAL definition of `services.addTv`. */
+export declare const servicesAddTv: OperationDefinition<ServiceAddTvData, "services.addTv">;
+export {};

package/dist/operations/services-change-plan.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+import type { PlanId } from "./plans-list.js";
+/**
+ * Input of `services.changePlan`, named as SGP names the fields. `action` is fixed by the method
+ * (`change_plano`) and is not an input.
+ */
+export interface ServiceChangePlanInput {
+    /** Exercised. ID of the serviço to change (the `id` of `customers.list` -> `servicos[]`). */
+    servico_id: number;
+    /**
+     * Exercised with `1` only (`SERVICE_TYPE.internet`). Type of the serviço; required. Any
+     * positive integer is sent and SGP decides what it takes, but only internet was ever exercised.
+     */
+    servico_tipo: number;
+    /**
+     * Exercised. ID of the new plan, a `PlanId` from the URA catalog (`plans.list`), which is the ID
+     * space of operations on existing services (not the pré-cadastro catalog of
+     * `preRegistrations.listPlans`, whose ids are `PreRegistrationPlanId`).
+     */
+    plano_id: PlanId;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const servicesChangePlanInputSchema: z.ZodObject<{
+    servico_id: z.ZodNumber;
+    servico_tipo: z.ZodNumber;
+    plano_id: z.core.$ZodBranded<z.ZodNumber, "PlanId", "out">;
+}, z.core.$strict>;
+/**
+ * Success body of `POST /api/suporte/service/update/{servico_id}/`: SGP's `msg`. It names neither
+ * the service nor the plan. Other keys SGP may add are kept.
+ */
+declare const planChangedSchema: z.ZodObject<{
+    msg: z.ZodString;
+}, z.core.$loose>;
+/** Response of `services.changePlan`. */
+export type ServiceChangePlanData = z.output<typeof planChangedSchema>;
+/** INTERNAL definition of `services.changePlan`. */
+export declare const servicesChangePlan: OperationDefinition<ServiceChangePlanData, "services.changePlan">;
+export {};

package/dist/operations/services-remove-generic.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+/** Input of `services.removeGeneric`, named as SGP names the fields. */
+export interface ServiceRemoveGenericInput {
+    /**
+     * Documented, never sent. ID of the generic serviço to remove (the id of the service that
+     * `services.addGeneric` created; read it from the contract with `customers.list`).
+     */
+    servico_id: number;
+    /** Documented, never sent. ID of the contract the serviço belongs to. */
+    clientecontrato_id: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const servicesRemoveGenericInputSchema: z.ZodObject<{
+    servico_id: z.ZodNumber;
+    clientecontrato_id: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * Success body of `DELETE /api/servico/generico/{servico_id}`: documented, never observed (no
+ * generic service was ever created, so none could be removed). Nothing is assumed beyond a JSON
+ * object; whatever SGP sends is kept as received.
+ */
+declare const genericRemovedSchema: z.ZodObject<{}, z.core.$loose>;
+/** Response of `services.removeGeneric`: the JSON object SGP sent, unread. */
+export type ServiceRemoveGenericData = z.output<typeof genericRemovedSchema>;
+/** INTERNAL definition of `services.removeGeneric`. */
+export declare const servicesRemoveGeneric: OperationDefinition<ServiceRemoveGenericData, "services.removeGeneric">;
+export {};

package/dist/operations/services-remove-tv.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+/** Input of `services.removeTv`, named as SGP names the fields. */
+export interface ServiceRemoveTvInput {
+    /** Exercised. ID of the TV serviço to remove (the `servico_id` of `services.addTv`). */
+    servico_id: number;
+    /** Exercised. ID of the contract the serviço belongs to. */
+    clientecontrato_id: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const servicesRemoveTvInputSchema: z.ZodObject<{
+    servico_id: z.ZodNumber;
+    clientecontrato_id: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * Success body of `DELETE /api/servico/tv/{servico_id}`: SGP's `msg`, the removed `servico_id` (a
+ * number) and `clientecontrato_id`, which SGP sends as text and `data` carries as a number (changed
+ * versus 2.0.0-beta.1). Other keys SGP may add are kept.
+ */
+declare const tvRemovedSchema: z.ZodObject<{
+    msg: z.ZodString;
+    clientecontrato_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+    servico_id: z.ZodNumber;
+}, z.core.$loose>;
+/** Response of `services.removeTv`. */
+export type ServiceRemoveTvData = z.output<typeof tvRemovedSchema>;
+/** INTERNAL definition of `services.removeTv`. */
+export declare const servicesRemoveTv: OperationDefinition<ServiceRemoveTvData, "services.removeTv">;
+export {};

package/dist/operations/work-orders-get.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const workOrderDetailSchema: z.ZodObject<{
+    os_id: z.ZodNumber;
+    os_protocolo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_status: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    os_status_txt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_prioridade: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    os_motivo_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    os_motivo_descricao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_data_cadastro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_data_agendamento: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_data_finalizacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_conteudo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_observacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_anotacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_servicoprestado: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_setor_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+    os_setor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_tecnico_responsavel: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_tecnicos_auxiliares: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+    os_agendamento_confirmado: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_agendamento_confirmacao_data: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_agendamento_confirmacao_status: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    os_agendamento_confirmacao_status_txt: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    os_close_edit: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_encerrada_impedir_estorno: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_encerrada_impedir_lancamento_avulso: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_finalizada_permite_add_imagem: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_lancamento_comodato: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    os_djson: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    comentarios: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+    cliente_id: z.ZodNullable<z.ZodOptional<z.core.$ZodBranded<z.ZodNumber, "CustomerId", "out">>>;
+    cliente: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cliente_email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cliente_contato: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    contrato_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    contrato_status: z.ZodNullable<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    contrato_status_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+    contrato_status_data: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    contrato_pop_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    contrato_pop: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    contrato_endereco_ll: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    endereco_logradouro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_numero: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    endereco_complemento: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_bairro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_cidade: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_uf: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_pontoreferencia: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    endereco_ll: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    plano_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    plano: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    plano_download: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    plano_upload: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_id: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>>;
+    servico_tipo: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    servico_login: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_password: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_online: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    servico_mac: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_ip: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_online_mac: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_online_ip: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    servico_online_ipv6_pd: z.ZodOptional<z.ZodUnknown>;
+    nas_ip: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_ssid: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_password: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_channel: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_ssid_5: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_password_5: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wifi_channel_5: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wan_user: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    wan_password: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$loose>;
+/**
+ * The response of `POST /api/os/list/id/{id}`, in SGP's own shape: ONE flat object with the work
+ * order, its customer, contract, address, plan and service together (72 fields observed). The
+ * vendor's collection shows a one-element array; SGP sent the bare object. Most fields are as
+ * received; normalized (changed versus 2.0.0-beta.1): `servico_id`, `contrato_status_id` and
+ * `os_setor_id` are numbers (`""` becomes `null`) and `contrato_status` is trimmed.
+ *
+ * It holds PLAINTEXT CREDENTIALS (`servico_password`, `wan_password`, `wifi_password`,
+ * `wifi_password_5`) and the customer's data: see `getSensitivity("workOrders.get")`.
+ */
+export type WorkOrdersGetData = z.output<typeof workOrderDetailSchema>;
+/** Input of `workOrders.get`, named as SGP names the path parameter. */
+export interface WorkOrdersGetInput {
+    /** Exercised. The id of the work order (the `id` of `workOrders.list`; `os_id` in the result). */
+    id: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const workOrdersGetInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strict>;
+/** INTERNAL definition of `workOrders.get`. */
+export declare const workOrdersGet: OperationDefinition<WorkOrdersGetData, "workOrders.get">;
+export {};

package/dist/operations/work-orders-list-comments.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const commentsSchema: z.ZodArray<z.ZodObject<{
+    comentario_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    comentario: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    usuario: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    data_cadastro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    checklist_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    checklist_descricao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    usuario_setores: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$loose>>;
+/**
+ * The response of `GET /api/os/{id}/comentario/list/`, in SGP's own shape: a bare array with one
+ * entry per comment of the work order. The route is not paginated, so there is no envelope and no
+ * total. An empty array means no comment.
+ *
+ * DOCUMENTED ONLY: the one live read returned `[]`. The item fields (`comentario_id`,
+ * `comentario`, `usuario`, `data_cadastro`, `checklist_id`, `checklist_descricao`,
+ * `usuario_setores`) come from the vendor's collection and were never seen; an element that is not
+ * an object fails the response (`INVALID_RESPONSE`), as everywhere in the client.
+ */
+export type WorkOrdersListCommentsData = z.output<typeof commentsSchema>;
+/** Input of `workOrders.listComments`, named as SGP names the path parameter. */
+export interface WorkOrdersListCommentsInput {
+    /** Exercised. The id of the work order (the `id` of `workOrders.list`). */
+    id: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check it against the public type. */
+export declare const workOrdersListCommentsInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strict>;
+/** INTERNAL definition of `workOrders.listComments`. */
+export declare const workOrdersListComments: OperationDefinition<WorkOrdersListCommentsData, "workOrders.listComments">;
+export {};

package/dist/operations/work-orders-list-reasons.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const workOrderReasonsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    codigo: z.ZodNumber;
+    descricao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    ativo: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    classificacoes: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+    classificacoes_obrigatorio: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+    setores: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+}, z.core.$loose>>;
+/**
+ * The response of `GET /api/os/ocorrencia/motivo/list/`, in SGP's own shape: a bare array with one
+ * entry per occurrence reason (the `motivo` of a work order). The route is not paginated, so there
+ * is no envelope and no total.
+ */
+export type WorkOrdersListReasonsData = z.output<typeof workOrderReasonsSchema>;
+/** INTERNAL definition of `workOrders.listReasons`. */
+export declare const workOrdersListReasons: OperationDefinition<WorkOrdersListReasonsData, "workOrders.listReasons">;
+export {};

package/dist/operations/work-orders-list.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import type { OperationDefinition } from "../operation.js";
+declare const pageSchema: z.ZodObject<{
+    paginacao: z.ZodObject<{
+        offset: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        limit: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        parcial: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        total: z.ZodNumber;
+    }, z.core.$loose>;
+    ordens_servicos: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        contrato: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        status_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        status: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tipo_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        data_cadastro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        cliente: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        contrato_status: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        contrato_status_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        ocorrencia: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        hora_cadastro: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        data_agendamento: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        hora_agendamento: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        data_finalizacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        hora_finalizacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tipo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        motivo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        pop: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        conteudo: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        responsavel: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        tecnicos_auxiliares: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+        usuario: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        usuario_finalizacao: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        classificacoes: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/**
+ * One page of `POST /api/ura/ordemservico/list/`, with SGP's own `paginacao`, returned as received:
+ *
+ * - `offset`: index of the first work order of the page (SGP starts at 0);
+ * - `limit`: page size SGP applied, which may differ from the one requested;
+ * - `parcial`: how many work orders this page holds (observed equal to `ordens_servicos.length`);
+ * - `total`: how many work orders match the filters in all, across every page.
+ *
+ * `total` is SGP's and never computed by the SDK: a page without a numeric `total` is
+ * `INVALID_RESPONSE`. Nothing here fetches the next page: ask for it with `offset`.
+ */
+export type WorkOrdersListData = z.output<typeof pageSchema>;
+/** Filters and paging of `workOrders.list`, named as SGP names them. All optional. */
+export interface WorkOrdersListInput {
+    /** Index of the first work order of the page; SGP starts at 0. Non-negative integer. */
+    offset?: number;
+    /** Work orders per page. Non-negative integer; SGP decides the cap. */
+    limit?: number;
+    /**
+     * Work order id. SGP's collection describes it as the id of the occurrence (the OS); whether it
+     * matches `ordens_servicos[].id` or the `ocorrencia` number was not verified.
+     */
+    ordem_servico?: number;
+    /** Work order status id (`status_id` in the result; 0 is "Aberta" in the captures). */
+    status?: number;
+    /** POP id. */
+    pop?: number;
+    /** Occurrence reason id. */
+    motivo?: number;
+    /** Only work orders of this contract. */
+    contrato?: number;
+}
+/** INTERNAL. Validation of the input, exported so a test can check its keys are classified. */
+export declare const workOrdersListInputSchema: z.ZodObject<{
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    ordem_servico: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodNumber>;
+    pop: z.ZodOptional<z.ZodNumber>;
+    motivo: z.ZodOptional<z.ZodNumber>;
+    contrato: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** INTERNAL definition of `workOrders.list`. */
+export declare const workOrdersList: OperationDefinition<WorkOrdersListData, "workOrders.list">;
+export {};

package/dist/path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Fills the `{name}` placeholders of `template` with URL-encoded `pathParams`. Otherwise the first
+ * problem, named without its value: a placeholder with no value, an empty value, `.`/`..` (dot
+ * segments would change the route), a number that is not a safe integer, a value that cannot be
+ * encoded (lone surrogate), or a `pathParams` key that is not in the template.
+ */
+export declare const resolvePath: (template: string, pathParams?: Readonly<Record<string, string | number>>) => {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    problem: string;
+};

package/dist/raw-request.d.ts

@@ -0,0 +1,26 @@
+import type { CallOptions, ResolvedConfig } from "./config.js";
+import type { Encoding } from "./operation.js";
+import type { SgpResult } from "./result.js";
+/** Input of `request()`. */
+export interface RawRequestInput {
+    /** HTTP method. Which one a route needs is for the caller to know: the SDK never infers it. */
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    /**
+     * Route on the configured SGP instance, e.g. `/api/ura/clientes/`: it starts with `/api/` and is
+     * already in its final form (no query, no fragment, no `//`, no `.`/`..` segments, no `%`).
+     * Anything else is refused locally with `INVALID_INPUT` before a request is sent. Put query
+     * parameters of a GET in `body`. `;` is sent literally (it stays on the same origin, under `/api/`).
+     */
+    path: string;
+    /**
+     * Request fields. A GET has no body: they go in the query string (primitives only). Other
+     * methods send them in `encoding`; a `json` body must be serializable (no `BigInt`, no cycle)
+     * and a `form` body takes primitives only. It is copied once when the call starts. Credentials are added by the SDK and cannot be
+     * overridden.
+     */
+    body?: Readonly<Record<string, unknown>>;
+    /** Body encoding of POST/PUT/DELETE: `json` (default) or `form` (multipart text fields). */
+    encoding?: Encoding;
+}
+/** INTERNAL. Runs `request()`: validates the destination, then the shared executor. */
+export declare const executeRawRequest: (config: ResolvedConfig, input: RawRequestInput, options?: CallOptions) => Promise<SgpResult<unknown>>;

package/dist/request.d.ts

@@ -0,0 +1,28 @@
+import type { ResolvedConfig } from "./config.js";
+import type { OperationDefinition, RequestBuild } from "./operation.js";
+/** What goes on the wire for one attempt. */
+export interface EncodedRequest {
+    url: string;
+    headers?: Record<string, string>;
+    body?: string | FormData;
+}
+/** The parts of a successful `buildRequest` that the encoder writes: body fields, files, URL query. */
+type BuiltRequest = Pick<Extract<RequestBuild, {
+    ok: true;
+}>, "params" | "files" | "query">;
+/**
+ * Encodes one request. A GET never has a body: params and credentials go in the query string
+ * (primitives only, `undefined` omitted). Every other method (POST, PUT and DELETE alike) sends
+ * the body in the operation's encoding: `json`, or `form` (multipart text fields, no content-type
+ * header so `fetch` adds the boundary), or `form-files`, the same plus one part per file (written
+ * before the credentials, so these stay last). Credentials are written once and last, so a param
+ * can never replace or repeat them. `undefined` when a GET or form param is not a primitive.
+ *
+ * `query` is for a request that has a body: its entries go in the URL after the path (primitives
+ * only, `undefined` omitted; none, or only `undefined`, leaves the URL as it was) while the
+ * credentials stay in the body. A GET already puts everything in the query string, so a GET with a
+ * `query`, a `query` that is not made of primitives, or one that names `token` or `app` gives
+ * `undefined`.
+ */
+export declare const encodeRequest: (config: ResolvedConfig, definition: Pick<OperationDefinition<unknown>, "method" | "encoding">, path: string, built?: BuiltRequest) => EncodedRequest | undefined;
+export {};