sgp-sdk 0.0.0-stage → 1.2.0

package/dist/index.js

@@ -0,0 +1,1449 @@
+// src/errors.ts
+var DETAIL_UNAUTHORIZED = "Credenciais de autenticação incorretas.";
+var DETAIL_ROUTE_NOT_ALLOWED = "As credenciais de autenticação não foram fornecidas.";
+var MESSAGE_WRITE_NOT_CONFIRMED = "SGP answered with a success status but the response does not confirm the write; it may have been applied.";
+var MESSAGE_WRITE_FAILED_GENERICALLY = "SGP reported an error while processing the write; it may have been applied.";
+var MESSAGE_REJECTED_LOCALLY = "The SDK rejected the request before sending it.";
+var MESSAGES = {
+  UNAUTHORIZED: "SGP rejected the credentials (token or app).",
+  ROUTE_NOT_ALLOWED: "SGP does not allow this app to call this route.",
+  NOT_FOUND: "SGP resource not found.",
+  METHOD_NOT_ALLOWED: "SGP does not accept this HTTP method on this route.",
+  VALIDATION: "SGP rejected the request parameters.",
+  SCHEMA_MISMATCH: "SGP response does not match the expected schema.",
+  UPSTREAM: "SGP failed to process the request.",
+  TIMEOUT: "Request to SGP timed out.",
+  NETWORK: "Could not reach SGP.",
+  UNKNOWN: "Unexpected response from SGP."
+};
+var readErrors = (errors) => {
+  let parts = [];
+  if (Array.isArray(errors)) {
+    parts = errors.filter((item) => typeof item === "string");
+  } else if (typeof errors === "object" && errors !== null) {
+    parts = Object.entries(errors).flatMap(([key, value]) => typeof value === "string" ? [`${key}: ${value}`] : []);
+  }
+  const joined = parts.join("; ");
+  return joined === "" ? undefined : joined;
+};
+var readSgpDetail = (body) => {
+  if (typeof body !== "object" || body === null)
+    return;
+  if ("detail" in body && typeof body.detail === "string")
+    return body.detail;
+  if ("msg" in body && typeof body.msg === "string" && body.msg !== "")
+    return body.msg;
+  const fromErrors = "errors" in body ? readErrors(body.errors) : undefined;
+  if (fromErrors !== undefined)
+    return fromErrors;
+  return "error" in body && typeof body.error === "string" && body.error !== "" ? body.error : undefined;
+};
+var hasErrorList = (body) => typeof body === "object" && body !== null && ("errors" in body) && Array.isArray(body.errors);
+var codeForHttpStatus = (status, detail) => {
+  if (status === 401 || status === 403) {
+    if (detail === DETAIL_UNAUTHORIZED)
+      return "UNAUTHORIZED";
+    if (detail === DETAIL_ROUTE_NOT_ALLOWED)
+      return "ROUTE_NOT_ALLOWED";
+    return "UNKNOWN";
+  }
+  if (status === 404)
+    return "NOT_FOUND";
+  if (status === 405)
+    return "METHOD_NOT_ALLOWED";
+  if (status >= 400 && status < 500)
+    return "VALIDATION";
+  if (status >= 500 && status < 600)
+    return "UPSTREAM";
+  return "UNKNOWN";
+};
+var createError = (code, status, endpoint, detail, message = MESSAGES[code]) => {
+  const error = { status, code, message, endpoint };
+  if (detail !== undefined)
+    error.detail = detail;
+  return error;
+};
+var mapHttpFailure = (status, body, endpoint) => {
+  const detail = readSgpDetail(body);
+  return createError(codeForHttpStatus(status, detail), status, endpoint, detail);
+};
+var mapFetchFailure = (cause, endpoint) => {
+  const isTimeout = cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError");
+  return createError(isTimeout ? "TIMEOUT" : "NETWORK", 0, endpoint);
+};
+var EXPLICIT_REFUSALS = [401, 403, 404, 405, 422];
+var toWriteError = (error, isErrorListBody = false) => {
+  const isRejectedLocally = error.code === "VALIDATION" && error.status === 0;
+  const isClientError = error.status >= 400 && error.status <= 499;
+  const isGenericFailure = isErrorListBody && !EXPLICIT_REFUSALS.includes(error.status);
+  const isRejectedBySgp = isClientError && !isGenericFailure;
+  return {
+    ...error,
+    ...isClientError && isGenericFailure && { message: MESSAGE_WRITE_FAILED_GENERICALLY },
+    outcome: isRejectedLocally || isRejectedBySgp ? "not_applied" : "unknown"
+  };
+};
+
+// src/schema/paths.ts
+var normalizePath = (path) => path.reduce((joined, segment) => {
+  if (typeof segment === "number")
+    return `${joined}[]`;
+  return joined === "" ? String(segment) : `${joined}.${String(segment)}`;
+}, "");
+var formatPath = (path) => path.reduce((joined, segment) => {
+  if (typeof segment === "number")
+    return `${joined}[${segment}]`;
+  return joined === "" ? String(segment) : `${joined}.${String(segment)}`;
+}, "");
+var segmentsOf = (path) => path.match(/\[\]|[^.[\]]+/g) ?? [];
+var isKeyPathOf = (path, keyFields) => keyFields.some((key) => {
+  const keySegments = segmentsOf(key);
+  return path.length <= keySegments.length && path.every((segment, index) => {
+    const keySegment = keySegments[index];
+    if (typeof segment === "number")
+      return keySegment === "[]";
+    return keySegment === "*" || keySegment !== "[]" && keySegment === segment;
+  });
+});
+var valueAt = (input, path) => {
+  let current = input;
+  for (const segment of path) {
+    if (typeof current !== "object" || current === null)
+      return;
+    current = Reflect.get(current, segment);
+  }
+  return current;
+};
+var typeNameAt = (input, path) => {
+  const value = valueAt(input, path);
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+};
+
+// src/schema/parse.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var schemaMismatch = (issues, endpoint) => {
+  const paths = new Set(issues.map((issue) => normalizePath(issue.path) || "(root)"));
+  return {
+    success: false,
+    error: createError("SCHEMA_MISMATCH", 200, endpoint, [...paths].join(", "))
+  };
+};
+var findRemovalTarget = (input, path) => {
+  for (let end = path.length;end > 0; end -= 1) {
+    if (isPlainObject(valueAt(input, path.slice(0, end - 1))))
+      return path.slice(0, end);
+  }
+  return;
+};
+var removeAt = (root, path) => {
+  const parent = valueAt(root, path.slice(0, -1));
+  const key = path.at(-1);
+  if (isPlainObject(parent) && key !== undefined)
+    Reflect.deleteProperty(parent, key);
+};
+var parseResponse = (schema, keyFields, input, endpoint) => {
+  const first = schema.safeParse(input);
+  if (first.success)
+    return { success: true, data: first.data };
+  const { issues } = first.error;
+  const pruned = structuredClone(input);
+  for (const issue of issues) {
+    const target = findRemovalTarget(input, issue.path);
+    if (target === undefined || isKeyPathOf(target, keyFields)) {
+      return schemaMismatch(issues, endpoint);
+    }
+    removeAt(pruned, target);
+  }
+  const second = schema.safeParse(pruned);
+  if (!second.success)
+    return schemaMismatch(second.error.issues, endpoint);
+  const warnings = issues.map((issue) => ({
+    path: formatPath(issue.path),
+    expected: issue.code === "invalid_type" ? issue.expected : issue.code,
+    received: typeNameAt(input, issue.path)
+  }));
+  return { success: true, data: second.data, warnings };
+};
+
+// src/transport.ts
+var DEFAULT_TIMEOUT_MS = 20000;
+var PLACEHOLDER = /\{([^{}]+)\}/g;
+var resolvePath = (spec) => {
+  const pathParams = spec.pathParams ?? {};
+  const usedNames = new Set;
+  let invalidName;
+  const path = spec.path.replace(PLACEHOLDER, (_placeholder, name) => {
+    usedNames.add(name);
+    const value = Object.hasOwn(pathParams, name) ? pathParams[name] : undefined;
+    const text = value === undefined ? "" : String(value);
+    if (text === "" || text === "." || text === ".." || typeof value === "number" && !Number.isSafeInteger(value)) {
+      invalidName ??= name;
+      return "";
+    }
+    try {
+      return encodeURIComponent(text);
+    } catch {
+      invalidName ??= name;
+      return "";
+    }
+  });
+  if (invalidName !== undefined)
+    return { problem: `invalid path param: ${invalidName}` };
+  const unusedName = Object.keys(pathParams).find((name) => !usedNames.has(name));
+  if (unusedName !== undefined)
+    return { problem: `unexpected path param: ${unusedName}` };
+  return { path };
+};
+var definedParams = (params) => {
+  const defined = {};
+  for (const [key, value] of Object.entries(params ?? {})) {
+    if (value !== undefined)
+      defined[key] = value;
+  }
+  return defined;
+};
+var isPrimitive = (value) => typeof value !== "object" || value === null;
+var endpointUrl = (config, path) => `${config.baseUrl.replace(/\/+$/, "")}${path}`;
+var rejectedLocally = (problem, endpoint) => ({
+  ok: false,
+  error: createError("VALIDATION", 0, endpoint, problem, MESSAGE_REJECTED_LOCALLY)
+});
+var buildGetUrl = (config, spec, path) => {
+  const query = new URLSearchParams;
+  for (const [key, value] of Object.entries(definedParams(spec.params))) {
+    query.set(key, String(value));
+  }
+  query.set("token", config.token);
+  query.set("app", config.app);
+  return `${endpointUrl(config, path)}?${query.toString()}`;
+};
+var buildJsonBody = (config, spec) => JSON.stringify({ ...definedParams(spec.params), token: config.token, app: config.app });
+var buildMultipartBody = (config, spec, files) => {
+  const form = new FormData;
+  for (const [key, value] of Object.entries(definedParams(spec.params))) {
+    form.append(key, isPrimitive(value) ? String(value) : JSON.stringify(value));
+  }
+  form.set("token", config.token);
+  form.set("app", config.app);
+  for (const [field, file] of Object.entries(files)) {
+    const type = file.contentType ?? (file.data instanceof Blob ? file.data.type : undefined);
+    form.append(field, new Blob([file.data], { type }), file.filename);
+  }
+  return form;
+};
+var buildInit = (config, spec, signal) => {
+  if (spec.method === "GET")
+    return { method: "GET", redirect: "manual", signal };
+  if (spec.files !== undefined) {
+    return {
+      method: spec.method,
+      body: buildMultipartBody(config, spec, spec.files),
+      redirect: "manual",
+      signal
+    };
+  }
+  return {
+    method: spec.method,
+    headers: { "content-type": "application/json" },
+    body: buildJsonBody(config, spec),
+    redirect: "manual",
+    signal
+  };
+};
+var parseJson = (text) => {
+  try {
+    return { isJson: true, value: JSON.parse(text) };
+  } catch {
+    return { isJson: false };
+  }
+};
+var sendRequest = async (config, spec) => {
+  const resolved = resolvePath(spec);
+  if ("problem" in resolved)
+    return rejectedLocally(resolved.problem, spec.path);
+  const structuredName = spec.method === "GET" ? Object.entries(definedParams(spec.params)).find(([, value]) => !isPrimitive(value))?.[0] : undefined;
+  if (structuredName !== undefined) {
+    return rejectedLocally(`structured value in GET param: ${structuredName}`, spec.path);
+  }
+  const { path } = resolved;
+  const fetchImpl = config.fetch ?? fetch;
+  const signal = AbortSignal.timeout(config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  let status;
+  let text;
+  try {
+    const url = spec.method === "GET" ? buildGetUrl(config, spec, path) : endpointUrl(config, path);
+    const response = await fetchImpl(url, buildInit(config, spec, signal));
+    status = response.status;
+    text = await response.text();
+  } catch (cause) {
+    return { ok: false, error: mapFetchFailure(cause, spec.path) };
+  }
+  if (status >= 200 && status < 300) {
+    if (text.trim() === "")
+      return { ok: true, body: null, status };
+    const parsed2 = parseJson(text);
+    if (!parsed2.isJson)
+      return { ok: false, error: createError("SCHEMA_MISMATCH", status, spec.path) };
+    return { ok: true, body: parsed2.value, status };
+  }
+  const parsed = parseJson(text);
+  const body = parsed.isJson ? parsed.value : undefined;
+  return {
+    ok: false,
+    error: mapHttpFailure(status, body, spec.path),
+    hasErrorList: hasErrorList(body)
+  };
+};
+
+// src/endpoint.ts
+var callEndpoint = async (config, def, params, pathParams) => {
+  const raw = await sendRequest(config, { method: def.method, path: def.path, params, pathParams });
+  if (!raw.ok)
+    return { success: false, error: raw.error };
+  return parseResponse(def.schema, def.keyFields, raw.body, def.path);
+};
+var unconfirmedWrite = (status, endpoint, detail) => ({
+  ...createError("VALIDATION", status, endpoint, detail, MESSAGE_WRITE_NOT_CONFIRMED),
+  outcome: "unknown"
+});
+var callWriteEndpoint = async (config, def, call) => {
+  const raw = await sendRequest(config, {
+    method: def.method,
+    path: def.path,
+    pathParams: call?.pathParams,
+    params: call?.params,
+    files: call?.files
+  });
+  if (!raw.ok) {
+    const { error } = raw;
+    const isUnreadable2xx = error.code === "SCHEMA_MISMATCH" && error.status >= 200 && error.status < 300;
+    return {
+      success: false,
+      error: isUnreadable2xx ? unconfirmedWrite(error.status, def.path) : toWriteError(error, raw.hasErrorList)
+    };
+  }
+  const parsed = parseResponse(def.schema, def.keyFields, raw.body, def.path);
+  if (parsed.success)
+    return parsed;
+  return {
+    success: false,
+    error: unconfirmedWrite(raw.status, def.path, readSgpDetail(raw.body) ?? parsed.error.detail)
+  };
+};
+
+// src/endpoints/crm/create-contract.ts
+import { z } from "zod";
+
+// src/endpoints/crm/address.ts
+var flatAddress = (address) => {
+  const flat = {};
+  for (const [key, value] of Object.entries(address)) {
+    if (value !== undefined)
+      flat[key] = value;
+  }
+  return flat;
+};
+
+// src/endpoints/crm/create-contract.ts
+var formaCobrancaCodigo = {
+  boleto: 1,
+  debitoAutomatico: 2,
+  carne: 3,
+  cobrancaRecorrente: 4,
+  pix: 6
+};
+var modoAquisicao = { proprio: 0, comodato: 1 };
+var createContractSchema = z.object({
+  message: z.string().optional().nullable(),
+  clientecontrato: z.number(),
+  cliente: z.string().optional().nullable()
+});
+var createContractKeyFields = ["clientecontrato"];
+var contractCreatedItemPath = "";
+var contractCreatedSecretKeys = [];
+var contractCreatedPersonalKeys = ["cliente"];
+var toContractBody = (params) => ({
+  ...params,
+  endereco_instalacao: flatAddress(params.endereco_instalacao),
+  endereco_cobranca: flatAddress(params.endereco_cobranca),
+  ...flatAddress(params.endereco_instalacao)
+});
+var createContractDefinition = {
+  kind: "write",
+  method: "POST",
+  path: "/api/crm/cliente/{cliente_id}/contratos/",
+  schema: createContractSchema,
+  keyFields: createContractKeyFields,
+  itemPath: contractCreatedItemPath,
+  secretKeys: contractCreatedSecretKeys,
+  personalKeys: contractCreatedPersonalKeys
+};
+
+// src/endpoints/crm/create-customer.ts
+import { z as z2 } from "zod";
+var createCustomerSchema = z2.object({
+  cliente_id: z2.number(),
+  message: z2.string().optional().nullable()
+});
+var createCustomerKeyFields = ["cliente_id"];
+var customerCreatedItemPath = "";
+var customerCreatedSecretKeys = [];
+var customerCreatedPersonalKeys = ["message"];
+var toCustomerBody = (params) => ({
+  ...params,
+  endereco: flatAddress(params.endereco),
+  ...flatAddress(params.endereco)
+});
+var createIndividualCustomerDefinition = {
+  kind: "write",
+  method: "POST",
+  path: "/api/crm/cliente/F",
+  schema: createCustomerSchema,
+  keyFields: createCustomerKeyFields,
+  itemPath: customerCreatedItemPath,
+  secretKeys: customerCreatedSecretKeys,
+  personalKeys: customerCreatedPersonalKeys
+};
+var createCompanyCustomerDefinition = {
+  kind: "write",
+  method: "POST",
+  path: "/api/crm/cliente/J",
+  schema: createCustomerSchema,
+  keyFields: createCustomerKeyFields,
+  itemPath: customerCreatedItemPath,
+  secretKeys: customerCreatedSecretKeys,
+  personalKeys: customerCreatedPersonalKeys
+};
+
+// src/endpoints/crm/update-customer-status.ts
+import { z as z3 } from "zod";
+var crmStatus = {
+  emAnalise: 1,
+  aprovado: 2,
+  reprovado: 3,
+  aguardandoContato: 4,
+  tentandoContato: 5,
+  contratoRealizadoNoSgp: 6,
+  inviabilidadeTecnica: 7,
+  contratoEmProspeccao: 8,
+  reprovadoSpcSerasa: 9,
+  analiseViabilidadeTecnica: 10
+};
+var updateCustomerStatusSchema = z3.object({
+  cliente_id: z3.number(),
+  message: z3.string().optional().nullable(),
+  novo_status: z3.object({
+    codigo: z3.number(),
+    descricao: z3.string().optional().nullable()
+  })
+});
+var updateCustomerStatusKeyFields = ["cliente_id", "novo_status.codigo"];
+var customerStatusItemPath = "";
+var customerStatusSecretKeys = [];
+var customerStatusPersonalKeys = ["message"];
+var updateCustomerStatusDefinition = {
+  kind: "write",
+  method: "POST",
+  path: "/api/crm/cliente/{cliente_id}/status/",
+  schema: updateCustomerStatusSchema,
+  keyFields: updateCustomerStatusKeyFields,
+  itemPath: customerStatusItemPath,
+  secretKeys: customerStatusSecretKeys,
+  personalKeys: customerStatusPersonalKeys
+};
+
+// src/endpoints/os/list-occurrence-reasons.ts
+import { z as z4 } from "zod";
+var occurrenceReasonSchema = z4.object({
+  id: z4.number(),
+  codigo: z4.number(),
+  descricao: z4.string(),
+  ativo: z4.boolean(),
+  classificacoes: z4.array(z4.object({})).optional().nullable(),
+  classificacoes_obrigatorio: z4.boolean().optional().nullable(),
+  setores: z4.array(z4.object({})).optional().nullable()
+});
+var listOccurrenceReasonsSchema = z4.array(occurrenceReasonSchema);
+var listOccurrenceReasonsKeyFields = [
+  "[].id",
+  "[].codigo",
+  "[].descricao",
+  "[].ativo"
+];
+var occurrenceReasonItemPath = "[]";
+var occurrenceReasonSecretKeys = [];
+var occurrenceReasonPersonalKeys = [];
+var listOccurrenceReasonsDefinition = {
+  method: "GET",
+  path: "/api/os/ocorrencia/motivo/list/",
+  schema: listOccurrenceReasonsSchema,
+  keyFields: listOccurrenceReasonsKeyFields,
+  itemPath: occurrenceReasonItemPath,
+  secretKeys: occurrenceReasonSecretKeys,
+  personalKeys: occurrenceReasonPersonalKeys
+};
+
+// src/endpoints/os/list-occurrence-types.ts
+import { z as z5 } from "zod";
+var occurrenceTypeSchema = z5.object({
+  id: z5.number(),
+  codigo: z5.number(),
+  descricao: z5.string(),
+  ativo: z5.boolean(),
+  classificacoes: z5.array(z5.object({})).optional().nullable(),
+  classificacoes_obrigatorio: z5.boolean().optional().nullable(),
+  setores: z5.array(z5.object({})).optional().nullable(),
+  classificacoes_obrigatorio_encerramento: z5.boolean().optional().nullable()
+});
+var listOccurrenceTypesSchema = z5.array(occurrenceTypeSchema);
+var listOccurrenceTypesKeyFields = [
+  "[].id",
+  "[].codigo",
+  "[].descricao",
+  "[].ativo"
+];
+var occurrenceTypeItemPath = "[]";
+var occurrenceTypeSecretKeys = [];
+var occurrenceTypePersonalKeys = [];
+var listOccurrenceTypesDefinition = {
+  method: "GET",
+  path: "/api/os/ocorrencia/tipo/list/",
+  schema: listOccurrenceTypesSchema,
+  keyFields: listOccurrenceTypesKeyFields,
+  itemPath: occurrenceTypeItemPath,
+  secretKeys: occurrenceTypeSecretKeys,
+  personalKeys: occurrenceTypePersonalKeys
+};
+
+// src/endpoints/precadastro/list-due-days.ts
+import { z as z6 } from "zod";
+var dueDaySchema = z6.object({
+  id: z6.number(),
+  dia: z6.number()
+});
+var listDueDaysSchema = z6.array(dueDaySchema);
+var listDueDaysKeyFields = ["[].id", "[].dia"];
+var dueDayItemPath = "[]";
+var dueDaySecretKeys = [];
+var dueDayPersonalKeys = [];
+var listDueDaysDefinition = {
+  method: "POST",
+  path: "/api/precadastro/vencimento/list",
+  schema: listDueDaysSchema,
+  keyFields: listDueDaysKeyFields,
+  itemPath: dueDayItemPath,
+  secretKeys: dueDaySecretKeys,
+  personalKeys: dueDayPersonalKeys
+};
+
+// src/endpoints/precadastro/list-sellers.ts
+import { z as z7 } from "zod";
+var sellerSchema = z7.object({
+  id: z7.number(),
+  nome: z7.string(),
+  cpf: z7.string().optional().nullable(),
+  email: z7.string().optional().nullable()
+});
+var listSellersSchema = z7.array(sellerSchema);
+var listSellersKeyFields = ["[].id", "[].nome"];
+var sellerItemPath = "[]";
+var sellerSecretKeys = [];
+var sellerPersonalKeys = ["nome", "cpf", "email"];
+var listSellersDefinition = {
+  method: "POST",
+  path: "/api/precadastro/vendedor/list",
+  schema: listSellersSchema,
+  keyFields: listSellersKeyFields,
+  itemPath: sellerItemPath,
+  secretKeys: sellerSecretKeys,
+  personalKeys: sellerPersonalKeys
+};
+
+// src/endpoints/suporte/add-customer-document.ts
+import { z as z8 } from "zod";
+var addCustomerDocumentSchema = z8.null();
+var addCustomerDocumentKeyFields = [];
+var customerDocumentAddedItemPath = "";
+var customerDocumentAddedSecretKeys = [];
+var customerDocumentAddedPersonalKeys = [];
+var addCustomerDocumentDefinition = {
+  kind: "write",
+  method: "PUT",
+  path: "/api/suporte/cliente/{cliente_id}/documento/add/",
+  schema: addCustomerDocumentSchema,
+  keyFields: addCustomerDocumentKeyFields,
+  itemPath: customerDocumentAddedItemPath,
+  secretKeys: customerDocumentAddedSecretKeys,
+  personalKeys: customerDocumentAddedPersonalKeys
+};
+
+// src/endpoints/suporte/list-customer-documents.ts
+import { z as z9 } from "zod";
+var customerDocumentSchema = z9.object({
+  id: z9.number(),
+  cliente_id: z9.number(),
+  arquivo: z9.string().optional().nullable(),
+  descricao: z9.string().optional().nullable(),
+  usuario: z9.string().optional().nullable()
+});
+var listCustomerDocumentsSchema = z9.array(customerDocumentSchema);
+var listCustomerDocumentsKeyFields = ["[].id", "[].cliente_id"];
+var customerDocumentItemPath = "[]";
+var customerDocumentSecretKeys = [];
+var customerDocumentPersonalKeys = ["arquivo", "descricao", "usuario"];
+var listCustomerDocumentsDefinition = {
+  method: "GET",
+  path: "/api/suporte/cliente/{cliente_id}/documento/list/",
+  schema: listCustomerDocumentsSchema,
+  keyFields: listCustomerDocumentsKeyFields,
+  itemPath: customerDocumentItemPath,
+  secretKeys: customerDocumentSecretKeys,
+  personalKeys: customerDocumentPersonalKeys
+};
+
+// src/endpoints/ura/check-coverage.ts
+import { z as z10 } from "zod";
+var numberOrNumericString = z10.union([
+  z10.number(),
+  z10.string().regex(/^-?\d+(\.\d+)?$/).transform(Number)
+]);
+var ctoSchema = z10.object({
+  lat: numberOrNumericString.optional().nullable(),
+  lng: numberOrNumericString.optional().nullable(),
+  distancia: numberOrNumericString.optional().nullable(),
+  id: z10.union([z10.string(), z10.number().transform(String)]).optional().nullable(),
+  nome: z10.string().optional().nullable()
+});
+var checkCoverageSchema = z10.array(z10.record(z10.string(), z10.union([z10.array(ctoSchema), z10.string()])));
+var checkCoverageKeyFields = ["[].*"];
+var coverageItemPath = "[]";
+var coverageSecretKeys = [];
+var coveragePersonalKeys = [];
+var checkCoverageDefinition = {
+  method: "GET",
+  path: "/api/ura/viabilidadeinstalacao",
+  schema: checkCoverageSchema,
+  keyFields: checkCoverageKeyFields,
+  itemPath: coverageItemPath,
+  secretKeys: coverageSecretKeys,
+  personalKeys: coveragePersonalKeys
+};
+
+// src/endpoints/ura/list-annotations.ts
+import { z as z11 } from "zod";
+var PATH = "/api/ura/cliente/anotacao/list/";
+var annotationSchema = z11.object({
+  id: z11.number(),
+  cliente: z11.number(),
+  clientecontrato: z11.number().nullable(),
+  anotacao: z11.string(),
+  usuario: z11.number().optional().nullable(),
+  tipo: z11.number().optional().nullable(),
+  alerta_modo: z11.number().optional().nullable(),
+  data_cadastro: z11.string().optional().nullable(),
+  data_alteracao: z11.string().optional().nullable()
+});
+var listAnnotationsSchema = z11.array(annotationSchema);
+var listAnnotationsKeyFields = [
+  "[].id",
+  "[].cliente",
+  "[].clientecontrato",
+  "[].anotacao"
+];
+var annotationItemPath = "[]";
+var annotationSecretKeys = [];
+var annotationPersonalKeys = ["anotacao", "usuario"];
+var validFilter = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+var listAnnotations = async (config, params) => {
+  const customer = params?.cliente_id;
+  const contract = params?.contrato_id;
+  if (customer === undefined && contract === undefined || customer !== undefined && !validFilter(customer) || contract !== undefined && !validFilter(contract)) {
+    return {
+      success: false,
+      error: createError("VALIDATION", 0, PATH, "cliente_id / contrato_id: supply at least one positive safe integer", MESSAGE_REJECTED_LOCALLY)
+    };
+  }
+  const raw = await sendRequest(config, {
+    method: "GET",
+    path: PATH,
+    params: { cliente_id: customer, contrato_id: contract }
+  });
+  if (!raw.ok)
+    return { success: false, error: raw.error };
+  if (!Array.isArray(raw.body)) {
+    return { success: false, error: createError("SCHEMA_MISMATCH", 200, PATH, "(root)") };
+  }
+  const rows = raw.body;
+  const selected = [];
+  for (const row of rows) {
+    const record = typeof row === "object" && row !== null && !Array.isArray(row) ? row : {};
+    const customerIsNumber = typeof record.cliente === "number" && Number.isFinite(record.cliente);
+    const contractIsNumber = typeof record.clientecontrato === "number" && Number.isFinite(record.clientecontrato);
+    const customerMismatch = customer !== undefined && customerIsNumber && record.cliente !== customer;
+    const contractMismatch = contract !== undefined && (record.clientecontrato === null || contractIsNumber && record.clientecontrato !== contract);
+    if (customerMismatch || contractMismatch)
+      continue;
+    const ambiguousPaths = [];
+    if (customer !== undefined && !customerIsNumber)
+      ambiguousPaths.push("[].cliente");
+    if (contract !== undefined && !contractIsNumber)
+      ambiguousPaths.push("[].clientecontrato");
+    if (ambiguousPaths.length > 0) {
+      return {
+        success: false,
+        error: createError("SCHEMA_MISMATCH", 200, PATH, ambiguousPaths.join(", "))
+      };
+    }
+    selected.push(row);
+  }
+  return parseResponse(listAnnotationsSchema, listAnnotationsKeyFields, selected, PATH);
+};
+
+// src/endpoints/ura/list-clients.ts
+import { z as z12 } from "zod";
+var addressSchema = z12.object({
+  logradouro: z12.string().optional().nullable(),
+  numero: z12.number().optional().nullable(),
+  bairro: z12.string().optional().nullable(),
+  cidade: z12.string().optional().nullable(),
+  uf: z12.string().optional().nullable(),
+  cep: z12.string().optional().nullable(),
+  complemento: z12.string().optional().nullable(),
+  latitude: z12.string().optional().nullable(),
+  longitude: z12.string().optional().nullable()
+});
+var contactsSchema = z12.object({
+  telefones: z12.array(z12.string()).optional().nullable(),
+  celulares: z12.array(z12.string()).optional().nullable(),
+  emails: z12.array(z12.string()).optional().nullable(),
+  outros: z12.array(z12.string()).optional().nullable()
+});
+var clientSchema = z12.object({
+  id: z12.number(),
+  nome: z12.string(),
+  tipo: z12.string(),
+  cpfcnpj: z12.string(),
+  sexo: z12.string().optional().nullable(),
+  dataCadastro: z12.string().optional().nullable(),
+  endereco: addressSchema.optional().nullable(),
+  contratos: z12.array(z12.object({})).optional().nullable(),
+  titulos: z12.array(z12.object({})).optional().nullable(),
+  contatos: contactsSchema.optional().nullable()
+});
+var listClientsSchema = z12.object({
+  paginacao: z12.object({
+    offset: z12.number().optional().nullable(),
+    limit: z12.number().optional().nullable(),
+    parcial: z12.number().optional().nullable(),
+    total: z12.number()
+  }),
+  clientes: z12.array(clientSchema)
+});
+var listClientsKeyFields = [
+  "paginacao.total",
+  "clientes",
+  "clientes[].id",
+  "clientes[].nome",
+  "clientes[].cpfcnpj",
+  "clientes[].tipo"
+];
+var clientItemPath = "clientes[]";
+var clientSecretKeys = [];
+var clientPersonalKeys = ["nome", "cpfcnpj", "sexo", "endereco", "contatos"];
+var listClientsDefinition = {
+  method: "POST",
+  path: "/api/ura/clientes/",
+  schema: listClientsSchema,
+  keyFields: listClientsKeyFields,
+  itemPath: clientItemPath,
+  secretKeys: clientSecretKeys,
+  personalKeys: clientPersonalKeys
+};
+
+// src/endpoints/ura/list-contracts.ts
+import { z as z13 } from "zod";
+var contractSummarySchema = z13.object({
+  id_contrato: z13.number(),
+  id_cliente: z13.number(),
+  status: z13.string(),
+  pop_id: z13.number(),
+  nome: z13.string().optional().nullable(),
+  cpfcnpj: z13.string().optional().nullable(),
+  email: z13.string().optional().nullable(),
+  telefone: z13.string().optional().nullable(),
+  data_status: z13.string().optional().nullable(),
+  data_cadastro: z13.string().optional().nullable(),
+  motivo_status: z13.string().optional().nullable()
+});
+var listContractsSchema = z13.array(contractSummarySchema);
+var listContractsKeyFields = [
+  "[].id_contrato",
+  "[].id_cliente",
+  "[].status",
+  "[].pop_id"
+];
+var contractSummaryItemPath = "[]";
+var contractSummarySecretKeys = [];
+var contractSummaryPersonalKeys = [
+  "nome",
+  "cpfcnpj",
+  "email",
+  "telefone",
+  "motivo_status"
+];
+var listContractsDefinition = {
+  method: "POST",
+  path: "/api/ura/listacontrato/",
+  schema: listContractsSchema,
+  keyFields: listContractsKeyFields,
+  itemPath: contractSummaryItemPath,
+  secretKeys: contractSummarySecretKeys,
+  personalKeys: contractSummaryPersonalKeys
+};
+
+// src/endpoints/ura/list-invoices.ts
+import { z as z14 } from "zod";
+var invoiceSchema = z14.object({
+  id: z14.number(),
+  status: z14.string(),
+  valor: z14.number(),
+  dataVencimento: z14.string(),
+  clienteNome: z14.string().optional().nullable(),
+  clienteCpfcnpj: z14.string().optional().nullable(),
+  clienteContrato: z14.number().optional().nullable(),
+  portador: z14.string().optional().nullable(),
+  numeroDocumento: z14.number().optional().nullable(),
+  nossoNumero: z14.string().optional().nullable(),
+  link: z14.string().optional().nullable(),
+  link_cobranca: z14.string().optional().nullable(),
+  valorDesconto: z14.number().optional().nullable(),
+  valorCorrigido: z14.number().optional().nullable(),
+  valorPago: z14.number().optional().nullable(),
+  valorPagoParcial: z14.number().optional().nullable(),
+  codigoBarras: z14.string().optional().nullable(),
+  linhaDigitavel: z14.string().optional().nullable(),
+  codigoPix: z14.string().optional().nullable(),
+  dataEmissao: z14.string().optional().nullable(),
+  dataPagamento: z14.string().optional().nullable(),
+  dataCancelamento: z14.string().optional().nullable(),
+  demonstrativo: z14.string().optional().nullable(),
+  acordoPagamento: z14.object({
+    acordados: z14.array(z14.object({})).optional().nullable(),
+    cobrados: z14.array(z14.object({})).optional().nullable()
+  }).optional().nullable(),
+  formaPagamento: z14.string().optional().nullable(),
+  usuario_baixa: z14.string().optional().nullable()
+});
+var listInvoicesSchema = z14.object({
+  paginacao: z14.object({
+    offset: z14.number().optional().nullable(),
+    limit: z14.number().optional().nullable(),
+    parcial: z14.number().optional().nullable(),
+    total: z14.number()
+  }),
+  titulos: z14.array(invoiceSchema)
+});
+var listInvoicesKeyFields = [
+  "paginacao.total",
+  "titulos",
+  "titulos[].id",
+  "titulos[].status",
+  "titulos[].valor",
+  "titulos[].dataVencimento"
+];
+var invoiceItemPath = "titulos[]";
+var invoiceSecretKeys = [];
+var invoicePersonalKeys = [
+  "clienteNome",
+  "clienteCpfcnpj",
+  "demonstrativo",
+  "link",
+  "link_cobranca",
+  "codigoPix"
+];
+var listInvoicesDefinition = {
+  method: "POST",
+  path: "/api/ura/titulos/",
+  schema: listInvoicesSchema,
+  keyFields: listInvoicesKeyFields,
+  itemPath: invoiceItemPath,
+  secretKeys: invoiceSecretKeys,
+  personalKeys: invoicePersonalKeys
+};
+
+// src/endpoints/ura/list-nas.ts
+import { z as z15 } from "zod";
+var nasPopSchema = z15.object({
+  id: z15.number().optional().nullable(),
+  cidade: z15.string().optional().nullable(),
+  uf: z15.string().optional().nullable(),
+  codigo_ibge: z15.number().optional().nullable(),
+  ativo: z15.boolean().optional().nullable()
+});
+var nasSchema = z15.object({
+  id: z15.number(),
+  descricao: z15.string(),
+  identificador: z15.string(),
+  endereco_ip: z15.string().optional().nullable(),
+  ativo: z15.boolean().optional().nullable(),
+  pops: z15.array(nasPopSchema).optional().nullable()
+});
+var listNasSchema = z15.array(nasSchema);
+var listNasKeyFields = ["[].id", "[].descricao", "[].identificador"];
+var nasItemPath = "[]";
+var nasSecretKeys = ["endereco_ip"];
+var nasPersonalKeys = [];
+var listNasDefinition = {
+  method: "POST",
+  path: "/api/ura/nas/list/",
+  schema: listNasSchema,
+  keyFields: listNasKeyFields,
+  itemPath: nasItemPath,
+  secretKeys: nasSecretKeys,
+  personalKeys: nasPersonalKeys
+};
+
+// src/endpoints/ura/list-occurrence-methods.ts
+import { z as z16 } from "zod";
+var occurrenceMethodSchema = z16.object({
+  codigo: z16.number(),
+  descricao: z16.string()
+});
+var listOccurrenceMethodsSchema = z16.array(occurrenceMethodSchema);
+var listOccurrenceMethodsKeyFields = ["[].codigo", "[].descricao"];
+var occurrenceMethodItemPath = "[]";
+var occurrenceMethodSecretKeys = [];
+var occurrenceMethodPersonalKeys = [];
+var listOccurrenceMethodsDefinition = {
+  method: "GET",
+  path: "/api/ura/ocorrencia/metodo/list/",
+  schema: listOccurrenceMethodsSchema,
+  keyFields: listOccurrenceMethodsKeyFields,
+  itemPath: occurrenceMethodItemPath,
+  secretKeys: occurrenceMethodSecretKeys,
+  personalKeys: occurrenceMethodPersonalKeys
+};
+
+// src/endpoints/ura/list-payment-carriers.ts
+import { z as z17 } from "zod";
+var paymentCarrierSchema = z17.object({
+  id: z17.number(),
+  descricao: z17.string(),
+  codigo_banco: z17.string().optional().nullable()
+});
+var listPaymentCarriersSchema = z17.array(paymentCarrierSchema);
+var listPaymentCarriersKeyFields = ["[].id", "[].descricao"];
+var paymentCarrierItemPath = "[]";
+var paymentCarrierSecretKeys = [];
+var paymentCarrierPersonalKeys = [];
+var listPaymentCarriersDefinition = {
+  method: "GET",
+  path: "/api/ura/portador/",
+  schema: listPaymentCarriersSchema,
+  keyFields: listPaymentCarriersKeyFields,
+  itemPath: paymentCarrierItemPath,
+  secretKeys: paymentCarrierSecretKeys,
+  personalKeys: paymentCarrierPersonalKeys
+};
+
+// src/endpoints/ura/list-plans.ts
+import { z as z18 } from "zod";
+var planPopSchema = z18.object({
+  id: z18.number().optional().nullable(),
+  uf: z18.string().optional().nullable(),
+  pop: z18.string().optional().nullable()
+});
+var planSchema = z18.object({
+  id: z18.number(),
+  descricao: z18.string(),
+  preco: z18.number(),
+  ativo: z18.boolean(),
+  grupo: z18.string().optional().nullable(),
+  tipo: z18.string().optional().nullable(),
+  pos_pago: z18.boolean().optional().nullable(),
+  desconto: z18.number().optional().nullable(),
+  desconto_venc: z18.number().optional().nullable(),
+  desconto_venc_modo: z18.string().optional().nullable(),
+  valor_desconto_temporario: z18.number().optional().nullable(),
+  desconto_temporario_modo: z18.string().optional().nullable(),
+  desconto_temporario_quantidade: z18.number().optional().nullable(),
+  descricao_desconto_temporario: z18.string().optional().nullable(),
+  desconto_temporario_proporcional: z18.boolean().optional().nullable(),
+  observacao: z18.string().optional().nullable(),
+  instalacao_qtd_parcelas: z18.number().optional().nullable(),
+  instalacao_valor: z18.number().optional().nullable(),
+  instalacao_desconto_max: z18.number().optional().nullable(),
+  instalacao_desconto_min: z18.number().optional().nullable(),
+  disponivel_pre_cadastro: z18.boolean().optional().nullable(),
+  disponivel_pre_cadastro_publico: z18.boolean().optional().nullable(),
+  data_validade: z18.string().optional().nullable(),
+  pops: z18.array(planPopSchema).optional().nullable(),
+  auto_bloqueio: z18.boolean().optional().nullable(),
+  dias_bloqueio_pos_venc: z18.number().optional().nullable(),
+  dias_bloqueio_aviso: z18.number().optional().nullable(),
+  dias_reducao_velocidade: z18.number().optional().nullable(),
+  download: z18.number().optional().nullable(),
+  upload: z18.number().optional().nullable(),
+  trafego_mensal: z18.number().optional().nullable(),
+  contabilizacao_trafego_mensal: z18.string().optional().nullable(),
+  trafego_excedente_acao: z18.string().optional().nullable(),
+  valor_trafego_excedido: z18.number().optional().nullable(),
+  duplicacao_noturna: z18.boolean().optional().nullable(),
+  inicio_duplicacao_noturna: z18.string().optional().nullable(),
+  fim_duplicacao_noturna: z18.string().optional().nullable(),
+  modo_velocidade_reduzida: z18.string().optional().nullable(),
+  download_red_financeiro: z18.number().optional().nullable(),
+  upload_red_financeiro: z18.number().optional().nullable(),
+  modo_velocidade_red_franquia: z18.string().optional().nullable(),
+  download_red_franquia: z18.number().optional().nullable(),
+  upload_red_franquia: z18.number().optional().nullable(),
+  combo: z18.array(z18.object({})).optional().nullable(),
+  qtd_servicos: z18.number().optional().nullable()
+});
+var listPlansSchema = z18.object({
+  planos: z18.array(planSchema),
+  total_planos: z18.number().optional().nullable(),
+  total_qtd_servicos: z18.number().optional().nullable()
+});
+var listPlansKeyFields = [
+  "planos",
+  "planos[].id",
+  "planos[].descricao",
+  "planos[].preco",
+  "planos[].ativo"
+];
+var planItemPath = "planos[]";
+var planSecretKeys = [];
+var planPersonalKeys = [];
+var listPlansDefinition = {
+  method: "GET",
+  path: "/api/ura/consultaplano/",
+  schema: listPlansSchema,
+  keyFields: listPlansKeyFields,
+  itemPath: planItemPath,
+  secretKeys: planSecretKeys,
+  personalKeys: planPersonalKeys
+};
+
+// src/endpoints/ura/list-pops.ts
+import { z as z19 } from "zod";
+var popSchema = z19.object({
+  id: z19.number(),
+  pop: z19.string()
+});
+var listPopsSchema = z19.array(popSchema);
+var listPopsKeyFields = ["[].id", "[].pop"];
+var popItemPath = "[]";
+var popSecretKeys = [];
+var popPersonalKeys = [];
+var listPopsDefinition = {
+  method: "POST",
+  path: "/api/ura/pops/",
+  schema: listPopsSchema,
+  keyFields: listPopsKeyFields,
+  itemPath: popItemPath,
+  secretKeys: popSecretKeys,
+  personalKeys: popPersonalKeys
+};
+
+// src/endpoints/ura/list-service-orders.ts
+import { z as z20 } from "zod";
+var serviceOrderSchema = z20.object({
+  id: z20.number(),
+  contrato: z20.number(),
+  status_id: z20.number(),
+  status: z20.string(),
+  tipo_id: z20.number(),
+  data_cadastro: z20.string(),
+  cliente: z20.string().optional().nullable(),
+  contrato_status: z20.string().optional().nullable(),
+  contrato_status_id: z20.number().optional().nullable(),
+  ocorrencia: z20.string().optional().nullable(),
+  hora_cadastro: z20.string().optional().nullable(),
+  data_agendamento: z20.string().optional().nullable(),
+  hora_agendamento: z20.string().optional().nullable(),
+  data_finalizacao: z20.string().optional().nullable(),
+  hora_finalizacao: z20.string().optional().nullable(),
+  tipo: z20.string().optional().nullable(),
+  motivo: z20.string().optional().nullable(),
+  pop: z20.string().optional().nullable(),
+  conteudo: z20.string().optional().nullable(),
+  responsavel: z20.string().optional().nullable(),
+  tecnicos_auxiliares: z20.array(z20.object({})).optional().nullable(),
+  usuario: z20.string().optional().nullable(),
+  usuario_finalizacao: z20.string().optional().nullable(),
+  classificacoes: z20.array(z20.object({})).optional().nullable()
+});
+var listServiceOrdersSchema = z20.object({
+  paginacao: z20.object({
+    offset: z20.number().optional().nullable(),
+    limit: z20.number().optional().nullable(),
+    parcial: z20.number().optional().nullable(),
+    total: z20.number()
+  }),
+  ordens_servicos: z20.array(serviceOrderSchema)
+});
+var listServiceOrdersKeyFields = [
+  "paginacao.total",
+  "ordens_servicos",
+  "ordens_servicos[].id",
+  "ordens_servicos[].contrato",
+  "ordens_servicos[].status_id",
+  "ordens_servicos[].status",
+  "ordens_servicos[].tipo_id",
+  "ordens_servicos[].data_cadastro"
+];
+var serviceOrderItemPath = "ordens_servicos[]";
+var serviceOrderSecretKeys = [];
+var serviceOrderPersonalKeys = ["cliente", "conteudo"];
+var listServiceOrdersDefinition = {
+  method: "POST",
+  path: "/api/ura/ordemservico/list/",
+  schema: listServiceOrdersSchema,
+  keyFields: listServiceOrdersKeyFields,
+  itemPath: serviceOrderItemPath,
+  secretKeys: serviceOrderSecretKeys,
+  personalKeys: serviceOrderPersonalKeys
+};
+
+// src/endpoints/ura/lookup-customer.ts
+import { z as z21 } from "zod";
+var contactEntrySchema = z21.object({
+  inscricoes: z21.array(z21.string()).optional().nullable(),
+  tipoContato: z21.string().optional().nullable(),
+  contato: z21.string().optional().nullable()
+});
+var tagSchema = z21.object({
+  color: z21.string().optional().nullable(),
+  font: z21.string().optional().nullable(),
+  tag: z21.string().optional().nullable(),
+  id: z21.number().optional().nullable(),
+  categoria_id: z21.number().optional().nullable()
+});
+var loyaltySchema = z21.object({
+  data_inicio: z21.string().optional().nullable(),
+  descricao: z21.string().optional().nullable(),
+  data_fim: z21.string().optional().nullable()
+});
+var customerContractSchema = z21.object({
+  contratoId: z21.number(),
+  clienteId: z21.number(),
+  contratoStatus: z21.number(),
+  contratoStatusDisplay: z21.string(),
+  contratoValorAberto: z21.number(),
+  contratoTitulosAReceber: z21.number(),
+  cobVencimento: z21.number(),
+  contratoStatusModo: z21.number().optional().nullable(),
+  motivo_status: z21.string().optional().nullable(),
+  dataCadastro: z21.string().optional().nullable(),
+  dataAlteracao: z21.string().optional().nullable(),
+  popId: z21.number().optional().nullable(),
+  popNome: z21.string().optional().nullable(),
+  cobPermuta: z21.boolean().optional().nullable(),
+  cobIsento: z21.number().optional().nullable(),
+  promessasPagamentoMes: z21.number().optional().nullable(),
+  link_quitacao: z21.string().optional().nullable(),
+  planointernet: z21.string().optional().nullable(),
+  fidelidade: loyaltySchema.optional().nullable(),
+  contrato_unificado_principal: z21.number().optional().nullable(),
+  contrato_unificado_filhos: z21.array(z21.number()).optional().nullable(),
+  tags: z21.array(tagSchema).optional().nullable(),
+  anotacoes: z21.array(z21.object({})).optional().nullable(),
+  contratoCentralLogin: z21.string().optional().nullable(),
+  contratoCentralSenha: z21.string().optional().nullable(),
+  servico_login: z21.string().optional().nullable(),
+  servico_senha: z21.string().optional().nullable(),
+  servico_plano: z21.string().optional().nullable(),
+  servico_grupo: z21.string().optional().nullable(),
+  servico_tipo_conexao: z21.string().optional().nullable(),
+  servico_vlan: z21.string().optional().nullable(),
+  servico_mac: z21.string().optional().nullable(),
+  servico_mac2: z21.string().optional().nullable(),
+  servico_wifi_ssid: z21.string().optional().nullable(),
+  servico_wifi_ssid_5: z21.string().optional().nullable(),
+  servico_wifi_password: z21.string().optional().nullable(),
+  servico_wifi_password_5: z21.string().optional().nullable(),
+  servico_wifi_channel: z21.string().optional().nullable(),
+  servico_wifi_channel_5: z21.string().optional().nullable(),
+  razaoSocial: z21.string().optional().nullable(),
+  cpfCnpj: z21.string().optional().nullable(),
+  dataNascimento: z21.string().optional().nullable(),
+  telefones: z21.array(contactEntrySchema).optional().nullable(),
+  telefones_cargos: z21.array(z21.object({})).optional().nullable(),
+  emails: z21.array(contactEntrySchema).optional().nullable(),
+  outros: z21.array(z21.object({})).optional().nullable(),
+  endereco_logradouro: z21.string().optional().nullable(),
+  endereco_numero: z21.number().optional().nullable(),
+  endereco_complemento: z21.string().optional().nullable(),
+  endereco_bairro: z21.string().optional().nullable(),
+  endereco_cidade: z21.string().optional().nullable(),
+  endereco_uf: z21.string().optional().nullable(),
+  endereco_cep: z21.string().optional().nullable(),
+  endereco_pontoreferencia: z21.string().optional().nullable(),
+  endereco_ll: z21.string().optional().nullable()
+});
+var lookupCustomerSchema = z21.object({
+  msg: z21.string().optional().nullable(),
+  contratos: z21.array(customerContractSchema)
+});
+var lookupCustomerKeyFields = [
+  "contratos",
+  "contratos[].contratoId",
+  "contratos[].clienteId",
+  "contratos[].contratoStatus",
+  "contratos[].contratoStatusDisplay",
+  "contratos[].contratoValorAberto",
+  "contratos[].contratoTitulosAReceber",
+  "contratos[].cobVencimento"
+];
+var customerContractItemPath = "contratos[]";
+var customerContractSecretKeys = [
+  "contratoCentralLogin",
+  "contratoCentralSenha",
+  "servico_login",
+  "servico_senha",
+  "servico_wifi_password",
+  "servico_wifi_password_5",
+  "servico_wifi_ssid",
+  "servico_wifi_ssid_5",
+  "servico_mac",
+  "servico_mac2",
+  "link_quitacao"
+];
+var customerContractPersonalKeys = [
+  "motivo_status",
+  "razaoSocial",
+  "cpfCnpj",
+  "dataNascimento",
+  "telefones",
+  "telefones_cargos",
+  "emails",
+  "outros",
+  "anotacoes",
+  "endereco_logradouro",
+  "endereco_numero",
+  "endereco_complemento",
+  "endereco_bairro",
+  "endereco_cidade",
+  "endereco_uf",
+  "endereco_cep",
+  "endereco_pontoreferencia",
+  "endereco_ll"
+];
+var lookupCustomerDefinition = {
+  method: "POST",
+  path: "/api/ura/consultacliente/",
+  schema: lookupCustomerSchema,
+  keyFields: lookupCustomerKeyFields,
+  itemPath: customerContractItemPath,
+  secretKeys: customerContractSecretKeys,
+  personalKeys: customerContractPersonalKeys
+};
+
+// src/endpoints/ura/open-ticket.ts
+import { z as z22 } from "zod";
+var openTicketSchema = z22.object({
+  status: z22.literal(1),
+  protocolo: z22.string(),
+  id: z22.number(),
+  contratoId: z22.number().optional().nullable(),
+  razaoSocial: z22.string().optional().nullable(),
+  cpfCnpj: z22.string().optional().nullable(),
+  msg: z22.string().optional().nullable()
+});
+var openTicketKeyFields = ["status", "protocolo", "id"];
+var ticketOpenedItemPath = "";
+var ticketOpenedSecretKeys = [];
+var ticketOpenedPersonalKeys = ["razaoSocial", "cpfCnpj"];
+var openTicketDefinition = {
+  kind: "write",
+  method: "POST",
+  path: "/api/ura/chamado/",
+  schema: openTicketSchema,
+  keyFields: openTicketKeyFields,
+  itemPath: ticketOpenedItemPath,
+  secretKeys: ticketOpenedSecretKeys,
+  personalKeys: ticketOpenedPersonalKeys
+};
+
+// src/client.ts
+var createSgpClient = (config) => ({
+  ura: {
+    listAnnotations: (params) => listAnnotations(config, params),
+    listClients: (params) => callEndpoint(config, listClientsDefinition, { ...params }),
+    lookupCustomer: (params) => callEndpoint(config, lookupCustomerDefinition, { ...params }),
+    listContracts: (params) => callEndpoint(config, listContractsDefinition, { ...params }),
+    listServiceOrders: (params) => callEndpoint(config, listServiceOrdersDefinition, { ...params }),
+    listPlans: () => callEndpoint(config, listPlansDefinition),
+    listOccurrenceMethods: () => callEndpoint(config, listOccurrenceMethodsDefinition),
+    listInvoices: (params) => callEndpoint(config, listInvoicesDefinition, { ...params }),
+    listPops: () => callEndpoint(config, listPopsDefinition),
+    listNas: () => callEndpoint(config, listNasDefinition),
+    listPaymentCarriers: () => callEndpoint(config, listPaymentCarriersDefinition),
+    checkCoverage: (params) => callEndpoint(config, checkCoverageDefinition, { ...params }),
+    openTicket: (params) => callWriteEndpoint(config, openTicketDefinition, {
+      params: { ...params }
+    })
+  },
+  os: {
+    listOccurrenceTypes: () => callEndpoint(config, listOccurrenceTypesDefinition),
+    listOccurrenceReasons: () => callEndpoint(config, listOccurrenceReasonsDefinition)
+  },
+  precadastro: {
+    listDueDays: () => callEndpoint(config, listDueDaysDefinition),
+    listSellers: () => callEndpoint(config, listSellersDefinition)
+  },
+  crm: {
+    createIndividualCustomer: (params) => callWriteEndpoint(config, createIndividualCustomerDefinition, {
+      params: toCustomerBody(params)
+    }),
+    createCompanyCustomer: (params) => callWriteEndpoint(config, createCompanyCustomerDefinition, {
+      params: toCustomerBody(params)
+    }),
+    createContract: (clienteId, params) => callWriteEndpoint(config, createContractDefinition, {
+      pathParams: { cliente_id: clienteId },
+      params: toContractBody(params)
+    }),
+    updateCustomerStatus: (clienteId, params) => callWriteEndpoint(config, updateCustomerStatusDefinition, {
+      pathParams: { cliente_id: clienteId },
+      params: { ...params }
+    })
+  },
+  suporte: {
+    addCustomerDocument: (clienteId, file, params) => callWriteEndpoint(config, addCustomerDocumentDefinition, {
+      pathParams: { cliente_id: clienteId },
+      params: { ...params },
+      files: { file }
+    }),
+    listCustomerDocuments: (clienteId) => callEndpoint(config, listCustomerDocumentsDefinition, undefined, { cliente_id: clienteId })
+  }
+});
+// src/sensitivity.ts
+var omitSensitive = (obj, keys) => {
+  const copy = { ...obj };
+  for (const key of keys)
+    Reflect.deleteProperty(copy, key);
+  return copy;
+};
+export {
+  updateCustomerStatusKeyFields,
+  updateCustomerStatusDefinition,
+  ticketOpenedSecretKeys,
+  ticketOpenedPersonalKeys,
+  ticketOpenedItemPath,
+  serviceOrderSecretKeys,
+  serviceOrderPersonalKeys,
+  serviceOrderItemPath,
+  sellerSecretKeys,
+  sellerPersonalKeys,
+  sellerItemPath,
+  popSecretKeys,
+  popPersonalKeys,
+  popItemPath,
+  planSecretKeys,
+  planPersonalKeys,
+  planItemPath,
+  paymentCarrierSecretKeys,
+  paymentCarrierPersonalKeys,
+  paymentCarrierItemPath,
+  openTicketKeyFields,
+  openTicketDefinition,
+  omitSensitive,
+  occurrenceTypeSecretKeys,
+  occurrenceTypePersonalKeys,
+  occurrenceTypeItemPath,
+  occurrenceReasonSecretKeys,
+  occurrenceReasonPersonalKeys,
+  occurrenceReasonItemPath,
+  occurrenceMethodSecretKeys,
+  occurrenceMethodPersonalKeys,
+  occurrenceMethodItemPath,
+  nasSecretKeys,
+  nasPersonalKeys,
+  nasItemPath,
+  modoAquisicao,
+  lookupCustomerKeyFields,
+  lookupCustomerDefinition,
+  listServiceOrdersKeyFields,
+  listServiceOrdersDefinition,
+  listSellersKeyFields,
+  listSellersDefinition,
+  listPopsKeyFields,
+  listPopsDefinition,
+  listPlansKeyFields,
+  listPlansDefinition,
+  listPaymentCarriersKeyFields,
+  listPaymentCarriersDefinition,
+  listOccurrenceTypesKeyFields,
+  listOccurrenceTypesDefinition,
+  listOccurrenceReasonsKeyFields,
+  listOccurrenceReasonsDefinition,
+  listOccurrenceMethodsKeyFields,
+  listOccurrenceMethodsDefinition,
+  listNasKeyFields,
+  listNasDefinition,
+  listInvoicesKeyFields,
+  listInvoicesDefinition,
+  listDueDaysKeyFields,
+  listDueDaysDefinition,
+  listCustomerDocumentsKeyFields,
+  listCustomerDocumentsDefinition,
+  listContractsKeyFields,
+  listContractsDefinition,
+  listClientsKeyFields,
+  listClientsDefinition,
+  listAnnotationsSchema,
+  listAnnotationsKeyFields,
+  invoiceSecretKeys,
+  invoicePersonalKeys,
+  invoiceItemPath,
+  formaCobrancaCodigo,
+  dueDaySecretKeys,
+  dueDayPersonalKeys,
+  dueDayItemPath,
+  customerStatusSecretKeys,
+  customerStatusPersonalKeys,
+  customerStatusItemPath,
+  customerDocumentSecretKeys,
+  customerDocumentPersonalKeys,
+  customerDocumentItemPath,
+  customerDocumentAddedSecretKeys,
+  customerDocumentAddedPersonalKeys,
+  customerDocumentAddedItemPath,
+  customerCreatedSecretKeys,
+  customerCreatedPersonalKeys,
+  customerCreatedItemPath,
+  customerContractSecretKeys,
+  customerContractPersonalKeys,
+  customerContractItemPath,
+  crmStatus,
+  createSgpClient,
+  createIndividualCustomerDefinition,
+  createCustomerKeyFields,
+  createContractKeyFields,
+  createContractDefinition,
+  createCompanyCustomerDefinition,
+  coverageSecretKeys,
+  coveragePersonalKeys,
+  coverageItemPath,
+  contractSummarySecretKeys,
+  contractSummaryPersonalKeys,
+  contractSummaryItemPath,
+  contractCreatedSecretKeys,
+  contractCreatedPersonalKeys,
+  contractCreatedItemPath,
+  clientSecretKeys,
+  clientPersonalKeys,
+  clientItemPath,
+  checkCoverageKeyFields,
+  checkCoverageDefinition,
+  annotationSecretKeys,
+  annotationPersonalKeys,
+  annotationItemPath,
+  addCustomerDocumentKeyFields,
+  addCustomerDocumentDefinition
+};