sgp-sdk 1.1.3 → 2.0.0-beta.1

package/dist/index.js

@@ -1,1373 +1,3104 @@
-// 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}`] : []);
+// src/retry.ts
+var sleepFor = (ms, signal) => new Promise((resolve) => {
+  if (signal.aborted) {
+    resolve();
+    return;
   }
-  const joined = parts.join("; ");
-  return joined === "" ? undefined : joined;
+  const finish = () => {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", finish);
+    resolve();
+  };
+  const timer = setTimeout(finish, ms);
+  signal.addEventListener("abort", finish, { once: true });
+});
+var defaultRuntime = {
+  now: () => Date.now(),
+  random: () => Math.random(),
+  sleep: sleepFor
 };
-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";
+var BASE_BACKOFF_MS = 500;
+var MAX_BACKOFF_MS = 1e4;
+var TRANSIENT_UPSTREAM_STATUSES = new Set([502, 503, 504]);
+var isTransientFailure = (failure) => {
+  switch (failure.error.code) {
+    case "RATE_LIMITED":
+    case "NETWORK":
+      return true;
+    case "UPSTREAM":
+      return failure.response !== null && TRANSIENT_UPSTREAM_STATUSES.has(failure.response.status);
+    default:
+      return false;
   }
-  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 backoffMs = (retryNumber, random) => {
+  const ceiling = Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** (retryNumber - 1));
+  return ceiling / 2 + random() * ceiling / 2;
 };
-var mapHttpFailure = (status, body, endpoint) => {
-  const detail = readSgpDetail(body);
-  return createError(codeForHttpStatus(status, detail), status, endpoint, detail);
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+var IMF_FIXDATE = /^[A-Za-z]{3}, (\d{2}) ([A-Za-z]{3}) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/;
+var RFC_850 = /^[A-Za-z]{6,9}, (\d{2})-([A-Za-z]{3})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) GMT$/;
+var ASCTIME = /^[A-Za-z]{3} ([A-Za-z]{3}) ([ \d]\d) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/;
+var utcMs = (year, monthName, day, hour, minute, second) => {
+  const month = MONTHS.indexOf(monthName.toLowerCase());
+  if (month === -1)
+    return;
+  const at = new Date(Date.UTC(year, month, day, hour, minute, second));
+  const isReal = at.getUTCFullYear() === year && at.getUTCMonth() === month && at.getUTCDate() === day && at.getUTCHours() === hour && at.getUTCMinutes() === minute && at.getUTCSeconds() === second;
+  return isReal ? at.getTime() : undefined;
 };
-var mapFetchFailure = (cause, endpoint) => {
-  const isTimeout = cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError");
-  return createError(isTimeout ? "TIMEOUT" : "NETWORK", 0, endpoint);
+var parseHttpDate = (value, now) => {
+  const imf = IMF_FIXDATE.exec(value);
+  if (imf !== null) {
+    const [, day, month, year, hour, minute, second] = imf;
+    return utcMs(Number(year), month ?? "", Number(day), Number(hour), Number(minute), Number(second));
+  }
+  const rfc850 = RFC_850.exec(value);
+  if (rfc850 !== null) {
+    const [, day, month, shortYear, hour, minute, second] = rfc850;
+    let year = 2000 + Number(shortYear);
+    if (year > new Date(now).getUTCFullYear() + 50)
+      year -= 100;
+    return utcMs(year, month ?? "", Number(day), Number(hour), Number(minute), Number(second));
+  }
+  const asctime = ASCTIME.exec(value);
+  if (asctime !== null) {
+    const [, month, day, hour, minute, second, year] = asctime;
+    return utcMs(Number(year), month ?? "", Number(day), Number(hour), Number(minute), Number(second));
+  }
+  return;
 };
-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"
-  };
+var parseRetryAfter = (value, now) => {
+  if (value === null)
+    return;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed))
+    return Number(trimmed) * 1000;
+  const at = parseHttpDate(trimmed, now);
+  return at === undefined ? undefined : Math.max(0, at - now);
 };
 
-// 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);
+// src/config.ts
+var DEFAULT_TIMEOUT_MS = 20000;
+var MAX_TIMEOUT_MS = 2147483647;
+
+class InvalidConfigurationError extends Error {
+  name = "InvalidConfigurationError";
+}
+var isValidTimeoutMs = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 && value <= MAX_TIMEOUT_MS;
+var isAbortSignalLike = (value) => typeof value === "object" && value !== null && ("aborted" in value) && typeof value.aborted === "boolean" && ("addEventListener" in value) && typeof value.addEventListener === "function" && ("removeEventListener" in value) && typeof value.removeEventListener === "function";
+var isValidMaxRetries = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+var isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
+var HOOK_NAMES = ["onRequest", "onResponse", "onError"];
+var resolveOrigin = (baseUrl) => {
+  if (!isNonEmptyString(baseUrl))
+    throw new InvalidConfigurationError("baseUrl must be a URL");
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new InvalidConfigurationError("baseUrl must be a valid URL");
   }
-  return current;
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new InvalidConfigurationError("baseUrl must use http or https");
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new InvalidConfigurationError("baseUrl must not carry credentials");
+  }
+  if (url.pathname !== "/" && url.pathname !== "" || url.search !== "" || url.hash !== "") {
+    throw new InvalidConfigurationError("baseUrl must be an origin without path, query or hash");
+  }
+  return url.origin;
 };
-var typeNameAt = (input, path) => {
-  const value = valueAt(input, path);
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  return typeof value;
+var resolveConfig = (options, runtime = defaultRuntime) => {
+  if (typeof options !== "object" || options === null) {
+    throw new InvalidConfigurationError("options must be an object");
+  }
+  const origin = resolveOrigin(options.baseUrl);
+  const { credentials } = options;
+  if (typeof credentials !== "object" || credentials === null || credentials.kind !== "token") {
+    throw new InvalidConfigurationError('credentials must be { kind: "token", token, app }');
+  }
+  if (!isNonEmptyString(credentials.token)) {
+    throw new InvalidConfigurationError("credentials.token must be a non-empty string");
+  }
+  if (!isNonEmptyString(credentials.app)) {
+    throw new InvalidConfigurationError("credentials.app must be a non-empty string");
+  }
+  if (options.timeoutMs !== undefined && !isValidTimeoutMs(options.timeoutMs)) {
+    throw new InvalidConfigurationError(`timeoutMs must be a positive finite number up to ${MAX_TIMEOUT_MS}`);
+  }
+  if (options.maxRetries !== undefined && !isValidMaxRetries(options.maxRetries)) {
+    throw new InvalidConfigurationError("maxRetries must be a non-negative integer");
+  }
+  if (options.fetch !== undefined && typeof options.fetch !== "function") {
+    throw new InvalidConfigurationError("fetch must be a function");
+  }
+  const hooks = options.hooks ?? {};
+  if (typeof hooks !== "object" || hooks === null) {
+    throw new InvalidConfigurationError("hooks must be an object");
+  }
+  for (const name of HOOK_NAMES) {
+    if (hooks[name] !== undefined && typeof hooks[name] !== "function") {
+      throw new InvalidConfigurationError(`hooks.${name} must be a function`);
+    }
+  }
+  return Object.freeze({
+    origin,
+    credentials: Object.freeze({ kind: "token", token: credentials.token, app: credentials.app }),
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: options.maxRetries ?? 0,
+    runtime,
+    hooks: Object.freeze({
+      onRequest: hooks.onRequest,
+      onResponse: hooks.onResponse,
+      onError: hooks.onError
+    }),
+    fetch: options.fetch ?? ((input, init) => fetch(input, init))
+  });
 };
 
-// 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)"));
+// src/budget.ts
+class BudgetStopped extends Error {
+  name = "BudgetStopped";
+}
+var isBudgetStopped = (error) => error instanceof BudgetStopped;
+var startBudget = (timeoutMs, callerSignal, now = Date.now) => {
+  const deadline = now() + timeoutMs;
+  const controller = new AbortController;
+  let cause;
+  const stop = (why) => {
+    cause ??= why;
+    controller.abort();
+  };
+  const onCallerAbort = () => stop("aborted");
+  if (callerSignal !== undefined) {
+    try {
+      if (callerSignal.aborted)
+        onCallerAbort();
+      else
+        callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+    } catch {
+      return;
+    }
+  }
+  const timer = setTimeout(() => stop("timeout"), timeoutMs);
+  const race = async (work) => {
+    let onStop;
+    const stopped = new Promise((_resolve, reject) => {
+      onStop = () => reject(new BudgetStopped("budget stopped"));
+      if (controller.signal.aborted)
+        onStop();
+      else
+        controller.signal.addEventListener("abort", onStop, { once: true });
+    });
+    try {
+      return await Promise.race([work, stopped]);
+    } finally {
+      if (onStop !== undefined)
+        controller.signal.removeEventListener("abort", onStop);
+    }
+  };
   return {
-    success: false,
-    error: createError("SCHEMA_MISMATCH", 200, endpoint, [...paths].join(", "))
+    signal: controller.signal,
+    cause: () => cause,
+    remainingMs: () => Math.max(0, deadline - now()),
+    race,
+    dispose: () => {
+      clearTimeout(timer);
+      try {
+        callerSignal?.removeEventListener("abort", onCallerAbort);
+      } catch {}
+    }
   };
 };
-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;
+
+// src/guards.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// src/classify.ts
+var ROUTE_NOT_ALLOWED_DETAIL = /credenciais.*n[ãa]o foram fornecidas/i;
+var WRONG_CREDENTIALS_DETAIL = /credenciais.*incorretas/i;
+var MESSAGES = {
+  INVALID_INPUT: "The input of this call is invalid; nothing was sent.",
+  UNAUTHORIZED: "SGP rejected the credentials (token or app).",
+  FORBIDDEN: "SGP refused the call for this token.",
+  RATE_LIMITED: "SGP is rate limiting this client.",
+  ROUTE_NOT_ALLOWED: "The SDK does not allow this route.",
+  NOT_FOUND: "SGP route or resource not found.",
+  REJECTED: "SGP rejected the request.",
+  UPSTREAM: "SGP failed to process the request.",
+  NETWORK: "Could not exchange data with SGP.",
+  TIMEOUT: "The time budget of the call expired.",
+  ABORTED: "The call was aborted by the caller.",
+  INVALID_RESPONSE: "SGP answered outside the contract of this method."
 };
-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 projectSgpFields = (body) => {
+  if (body.kind !== "json" || !isRecord(body.value))
+    return;
+  const fields = {};
+  for (const key of ["detail", "msg", "error", "errors"]) {
+    if (Object.hasOwn(body.value, key))
+      fields[key] = body.value[key];
+  }
+  return Object.keys(fields).length === 0 ? undefined : fields;
 };
-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);
+var classifyStatus = (status, body) => {
+  if (status === 401)
+    return { code: "UNAUTHORIZED" };
+  if (status === 403) {
+    const detail = projectSgpFields(body)?.detail;
+    if (typeof detail === "string" && ROUTE_NOT_ALLOWED_DETAIL.test(detail)) {
+      return { code: "FORBIDDEN", reason: "TOKEN_ROUTE_NOT_ALLOWED" };
     }
-    removeAt(pruned, target);
+    if (typeof detail === "string" && WRONG_CREDENTIALS_DETAIL.test(detail)) {
+      return { code: "UNAUTHORIZED" };
+    }
+    return { code: "FORBIDDEN" };
   }
-  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 };
+  if (status === 404)
+    return { code: "NOT_FOUND" };
+  if (status === 429)
+    return { code: "RATE_LIMITED" };
+  if (status >= 400 && status < 500)
+    return { code: "REJECTED" };
+  if (status >= 500 && status < 600)
+    return { code: "UPSTREAM" };
+  return { code: "INVALID_RESPONSE" };
+};
+var buildError = (code, operation, extra = {}) => {
+  const error = { code, message: MESSAGES[code], operation };
+  if (extra.reason !== undefined)
+    error.reason = extra.reason;
+  if (extra.effect !== undefined)
+    error.effect = extra.effect;
+  if (extra.sgp !== undefined)
+    error.sgp = extra.sgp;
+  if (extra.issues !== undefined)
+    error.issues = extra.issues;
+  return error;
 };
 
-// src/transport.ts
-var DEFAULT_TIMEOUT_MS = 20000;
+// src/effect.ts
+var isNonBlankString = (value) => typeof value === "string" && value.trim() !== "";
+var isClientError = (status) => status >= 400 && status < 500;
+var hasFieldErrorShape = (body) => {
+  if (body.kind !== "json" || !isRecord(body.value))
+    return false;
+  const { errors, error, detail } = body.value;
+  if (Array.isArray(errors))
+    return false;
+  return isRecord(errors) && Object.keys(errors).length > 0 || isNonBlankString(error) || isNonBlankString(detail);
+};
+var errorStringRejection = (status, text, reason) => ({
+  status,
+  reason,
+  matches: (body) => body.kind === "json" && isRecord(body.value) && !("errors" in body.value) && typeof body.value.error === "string" && text.test(body.value.error.trim())
+});
+var singleErrorsEntryRejection = (status, text, reason) => ({
+  status,
+  reason,
+  matches: (body) => {
+    if (body.kind !== "json" || !isRecord(body.value))
+      return false;
+    const { errors } = body.value;
+    return Object.keys(body.value).length === 1 && Array.isArray(errors) && errors.length === 1 && typeof errors[0] === "string" && text.test(errors[0].trim());
+  }
+});
+var findKnownRejection = (write, status, body) => isClientError(status) ? write.knownRejections?.find((rejection) => rejection.status === status && rejection.matches(body)) : undefined;
+var effectOfHttpFailure = (status, body, known) => known !== undefined || isClientError(status) && hasFieldErrorShape(body) ? "none" : "unknown";
+
+// src/exposure.ts
+var withheld = () => ({ kind: "withheld", reason: "bulk-privacy" });
+var exposedBody = (body, exposure) => exposure !== undefined && (body.kind === "json" || body.kind === "text") ? withheld() : body;
+var isText = (value) => typeof value === "string";
+var isMessage = (value) => isText(value) || Array.isArray(value) && value.every(isText) || isRecord(value) && Object.values(value).every(isText);
+var exposedSgp = (sgp, exposure) => {
+  if (exposure === undefined || sgp === undefined)
+    return sgp;
+  const kept = {};
+  for (const key of ["detail", "msg", "error"]) {
+    if (isText(sgp[key]))
+      kept[key] = sgp[key];
+  }
+  if (sgp.errors !== undefined && isMessage(sgp.errors))
+    kept.errors = sgp.errors;
+  return Object.keys(kept).length === 0 ? undefined : kept;
+};
+
+// src/hooks.ts
+var isThenable = (value) => typeof value === "object" && value !== null && ("then" in value) && typeof value.then === "function";
+var createHookRunner = (hooks) => {
+  const diagnostics = [];
+  const guarded = (hook, callback) => {
+    return (metadata) => {
+      if (callback === undefined)
+        return;
+      const copy = Object.freeze({ ...metadata });
+      try {
+        const returned = callback(copy);
+        if (isThenable(returned)) {
+          diagnostics.push({ hook, occurrence: metadata.attempt });
+          Promise.resolve(returned).then(undefined, () => {
+            return;
+          });
+        }
+      } catch {
+        diagnostics.push({ hook, occurrence: metadata.attempt });
+      }
+    };
+  };
+  return {
+    onRequest: guarded("onRequest", hooks.onRequest),
+    onResponse: guarded("onResponse", hooks.onResponse),
+    onError: guarded("onError", hooks.onError),
+    diagnostics: () => [...diagnostics]
+  };
+};
+
+// src/path.ts
 var PLACEHOLDER = /\{([^{}]+)\}/g;
-var resolvePath = (spec) => {
-  const pathParams = spec.pathParams ?? {};
+var resolvePath = (template, pathParams = {}) => {
   const usedNames = new Set;
   let invalidName;
-  const path = spec.path.replace(PLACEHOLDER, (_placeholder, name) => {
+  const path = template.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)) {
+    const valueText = value === undefined ? "" : String(value);
+    if (valueText === "" || valueText === "." || valueText === ".." || typeof value === "number" && !Number.isSafeInteger(value)) {
       invalidName ??= name;
       return "";
     }
     try {
-      return encodeURIComponent(text);
-    } catch {
+      return encodeURIComponent(valueText);
+    } catch (cause) {
+      if (!(cause instanceof URIError))
+        throw cause;
       invalidName ??= name;
       return "";
     }
   });
   if (invalidName !== undefined)
-    return { problem: `invalid path param: ${invalidName}` };
+    return { ok: false, 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;
+    return { ok: false, problem: `unexpected path param: ${unusedName}` };
+  return { ok: true, path };
 };
-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));
+
+// src/request.ts
+var isQueryValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var encodeRequest = (config, definition, path, built = {}) => {
+  const { params = {}, files = {}, query: queryParams = {} } = built;
+  const { token, app } = config.credentials;
+  const url = `${config.origin}${path}`;
+  const queryEntries = Object.entries(queryParams).filter(([, value]) => value !== undefined);
+  if (definition.method === "GET") {
+    if (queryEntries.length > 0)
+      return;
+    const query = new URLSearchParams;
+    for (const [key, value] of Object.entries(params)) {
+      if (value === undefined)
+        continue;
+      if (!isQueryValue(value))
+        return;
+      query.set(key, String(value));
+    }
+    query.set("token", token);
+    query.set("app", app);
+    return { url: `${url}?${query.toString()}` };
   }
-  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));
+  const bodyQuery = new URLSearchParams;
+  for (const [key, value] of queryEntries) {
+    if (!isQueryValue(value) || key === "token" || key === "app")
+      return;
+    bodyQuery.set(key, String(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);
+  const target = bodyQuery.size === 0 ? url : `${url}?${bodyQuery.toString()}`;
+  switch (definition.encoding) {
+    case "form":
+    case "form-files": {
+      const form = new FormData;
+      for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || key === "token" || key === "app")
+          continue;
+        if (!isQueryValue(value))
+          return;
+        form.append(key, String(value));
+      }
+      if (definition.encoding === "form-files") {
+        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);
+        }
+      }
+      form.append("token", token);
+      form.append("app", app);
+      return { url: target, body: form };
+    }
+    case "json":
+      return {
+        url: target,
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...params, token, app })
+      };
   }
-  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
-    };
+};
+
+// src/executor.ts
+var UNAVAILABLE_REASON = {
+  TIMEOUT: "timeout",
+  ABORTED: "aborted",
+  NETWORK: "network"
+};
+var failure = (error, response, attempts) => ({ ok: false, error, response, attempts });
+var effectFor = (definition, effect) => definition.write === undefined ? undefined : effect;
+var refused = (definition, code) => failure(buildError(code, definition.name, { effect: effectFor(definition, "none") }), null, 0);
+var decodeBody = (text) => {
+  if (text === "")
+    return { kind: "empty" };
+  try {
+    return { kind: "json", value: JSON.parse(text) };
+  } catch (cause) {
+    if (!(cause instanceof SyntaxError))
+      throw cause;
+    return { kind: "text", text };
   }
-  return {
-    method: spec.method,
-    headers: { "content-type": "application/json" },
-    body: buildJsonBody(config, spec),
-    redirect: "manual",
-    signal
-  };
 };
-var parseJson = (text) => {
+var REDACTED = "<redacted>";
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var MIN_REDACTED_VALUE_LENGTH = 8;
+var credentialValues = ({ token, app }) => {
+  const values = [...new Set([token, app, encodeURIComponent(token), encodeURIComponent(app)])].filter((value) => value.length >= MIN_REDACTED_VALUE_LENGTH).sort((first, second) => second.length - first.length);
+  return values.length === 0 ? undefined : new RegExp(values.map(escapeRegExp).join("|"), "g");
+};
+var CREDENTIAL_PARAMETER = /([?&;#](?:token|app)=)[^&;#>,\s"]*/gi;
+var readHeaders = (headers, values) => {
+  const captured = {};
+  headers.forEach((value, name) => {
+    const byParameter = value.replace(CREDENTIAL_PARAMETER, `$1${REDACTED}`);
+    captured[name] = values === undefined ? byParameter : byParameter.replace(values, REDACTED);
+  });
+  return captured;
+};
+var ignore = () => {
+  return;
+};
+var discardLateResponse = (pending) => {
+  pending.then((late) => late.body?.cancel().catch(ignore), ignore);
+};
+var readBody = async (raw, budget, failureFor) => {
+  let text;
   try {
-    return { isJson: true, value: JSON.parse(text) };
+    text = await budget.race(raw.text());
   } catch {
-    return { isJson: false };
+    return { ok: false, failure: failureFor() };
   }
+  return { ok: true, body: decodeBody(text) };
 };
-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;
+var forDecoding = (body) => body.kind === "json" ? { kind: "json", value: structuredClone(body.value) } : body;
+var snapshotOf = (input) => {
   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) };
+    return { ok: true, value: structuredClone(input) };
+  } catch {
+    return { ok: false };
   }
-  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 };
+};
+var settingsOf = (options) => {
+  try {
+    if (!isRecord(options))
+      return;
+    const { timeoutMs, maxRetries, abortSignal } = options;
+    if (timeoutMs !== undefined && !isValidTimeoutMs(timeoutMs))
+      return;
+    if (maxRetries !== undefined && !isValidMaxRetries(maxRetries))
+      return;
+    if (abortSignal === undefined) {
+      return { timeoutMs, maxRetries, abortSignal, isAborted: false };
+    }
+    if (!isAbortSignalLike(abortSignal))
+      return;
+    return { timeoutMs, maxRetries, abortSignal, isAborted: abortSignal.aborted };
+  } catch {
+    return;
   }
-  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)
+var execute = async (config, definition, input, options = {}) => {
+  const { name: operation } = definition;
+  const declared = definition;
+  if (declared.write !== undefined && declared.repeatable === true) {
+    throw new Error(`${operation}: a write can never be repeatable`);
+  }
+  const settings = settingsOf(options);
+  if (settings === undefined)
+    return refused(definition, "INVALID_INPUT");
+  const snapshot = snapshotOf(input);
+  if (!snapshot.ok)
+    return refused(definition, "INVALID_INPUT");
+  const built = definition.buildRequest(snapshot.value);
+  if (!built.ok)
+    return refused(definition, "INVALID_INPUT");
+  const resolved = resolvePath(definition.pathTemplate, built.pathParams);
+  if (!resolved.ok)
+    return refused(definition, "INVALID_INPUT");
+  const request = encodeRequest(config, definition, resolved.path, built);
+  if (request === undefined)
+    return refused(definition, "INVALID_INPUT");
+  if (settings.isAborted)
+    return refused(definition, "ABORTED");
+  const hooks = createHookRunner(config.hooks);
+  const callId = crypto.randomUUID();
+  const maxRetries = definition.repeatable === true ? settings.maxRetries ?? config.maxRetries : 0;
+  const { runtime } = config;
+  const secrets = credentialValues(config.credentials);
+  const budget = startBudget(settings.timeoutMs ?? config.timeoutMs, settings.abortSignal, runtime.now);
+  if (budget === undefined)
+    return refused(definition, "INVALID_INPUT");
+  try {
+    const transportFailure = () => {
+      const cause = budget.cause();
+      if (cause === "timeout")
+        return "TIMEOUT";
+      return cause === "aborted" ? "ABORTED" : "NETWORK";
+    };
+    const send = async (number2, metadata, startedAt) => {
+      hooks.onRequest(metadata);
+      const init = {
+        method: definition.method,
+        headers: request.headers,
+        body: request.body,
+        redirect: "manual",
+        signal: budget.signal
+      };
+      let raw;
+      let pending;
+      try {
+        pending = config.fetch(request.url, init);
+        raw = await budget.race(pending);
+      } catch {
+        const code = transportFailure();
+        if (code !== "NETWORK" && pending !== undefined)
+          discardLateResponse(pending);
+        const effect = effectFor(definition, "unknown");
+        return failure(buildError(code, operation, { effect }), null, number2);
+      }
+      hooks.onResponse({
+        ...metadata,
+        status: raw.status,
+        durationMs: performance.now() - startedAt
+      });
+      const headers = readHeaders(raw.headers, secrets);
+      const read = await readBody(raw, budget, transportFailure);
+      const body = read.ok ? read.body : { kind: "unavailable", reason: UNAVAILABLE_REASON[read.failure] };
+      const { exposure } = definition;
+      const response = {
+        status: raw.status,
+        headers,
+        body: exposedBody(body, exposure)
+      };
+      if (response.status < 200 || response.status >= 300) {
+        const { code, reason } = classifyStatus(response.status, body);
+        const sgp = exposedSgp(projectSgpFields(body), exposure);
+        const known = definition.write && findKnownRejection(definition.write, response.status, body);
+        const effect = effectFor(definition, definition.write?.effectUnknownAfterSend === true ? "unknown" : effectOfHttpFailure(response.status, body, known));
+        const error2 = buildError(code, operation, { reason: known?.reason ?? reason, sgp, effect });
+        return failure(error2, response, number2);
+      }
+      const unknownEffect = effectFor(definition, "unknown");
+      if (!read.ok) {
+        const error2 = buildError(read.failure, operation, { effect: unknownEffect });
+        return failure(error2, response, number2);
+      }
+      const refusal = definition.detectRefusal?.(body);
+      if (refusal !== undefined) {
+        const sgp = exposedSgp(projectSgpFields(body), exposure);
+        const error2 = buildError("REJECTED", operation, {
+          reason: refusal.reason,
+          sgp,
+          effect: unknownEffect
+        });
+        return failure(error2, response, number2);
+      }
+      const decoded = definition.decode(forDecoding(body));
+      if (decoded.ok) {
+        const { warnings } = decoded;
+        const success = { ok: true, data: decoded.data, response, attempts: number2 };
+        return warnings === undefined || warnings.length === 0 ? success : { ...success, warnings };
+      }
+      const error = buildError("INVALID_RESPONSE", operation, {
+        issues: decoded.issues,
+        effect: unknownEffect
+      });
+      return failure(error, response, number2);
     };
+    const attempt = async (number2) => {
+      const metadata = {
+        callId,
+        attempt: number2,
+        operation,
+        method: definition.method,
+        ...definition.omitPathFromHooks !== true && { pathTemplate: definition.pathTemplate }
+      };
+      const startedAt = performance.now();
+      const result = await send(number2, metadata, startedAt);
+      if (!result.ok) {
+        hooks.onError({
+          ...metadata,
+          code: result.error.code,
+          ...result.response !== null && { status: result.response.status },
+          durationMs: performance.now() - startedAt
+        });
+      }
+      return result;
+    };
+    const nextWait = (failed, number2) => {
+      if (number2 > maxRetries || budget.cause() !== undefined || !isTransientFailure(failed)) {
+        return;
+      }
+      const retryAfter = parseRetryAfter(failed.response === null ? null : failed.response.headers["retry-after"] ?? null, runtime.now());
+      const wait = Math.max(backoffMs(number2, runtime.random), retryAfter ?? 0);
+      return wait < budget.remainingMs() ? wait : undefined;
+    };
+    const sleepOrStop = async (ms) => {
+      try {
+        await budget.race(runtime.sleep(ms, budget.signal));
+      } catch (error) {
+        if (!isBudgetStopped(error))
+          throw error;
+      }
+      return budget.cause();
+    };
+    let number = 1;
+    let outcome = await attempt(number);
+    while (!outcome.ok) {
+      const wait = nextWait(outcome, number);
+      if (wait === undefined)
+        break;
+      const stoppedBy = await sleepOrStop(wait);
+      if (stoppedBy === "aborted") {
+        const effect = effectFor(definition, "unknown");
+        outcome = failure(buildError("ABORTED", operation, { effect }), outcome.response, number);
+        break;
+      }
+      if (stoppedBy === "timeout")
+        break;
+      number += 1;
+      outcome = await attempt(number);
+    }
+    const diagnostics = hooks.diagnostics();
+    return diagnostics.length === 0 ? outcome : { ...outcome, diagnostics };
+  } finally {
+    budget.dispose();
   }
-  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
+// src/operations/catalogs-list-billing-profiles.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;
+// src/tolerant.ts
+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 flat;
+  return current;
 };
-
-// src/endpoints/crm/create-contract.ts
-var formaCobrancaCodigo = {
-  boleto: 1,
-  debitoAutomatico: 2,
-  carne: 3,
-  cobrancaRecorrente: 4,
-  pix: 6
+var typeNameAt = (input, path) => {
+  const value = valueAt(input, path);
+  if (value === null)
+    return "null";
+  return Array.isArray(value) ? "array" : typeof value;
 };
-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
+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 isInvariant = (path, invariants) => invariants.some((invariant) => {
+  const segments = segmentsOf(invariant);
+  return path.length === segments.length && path.every((segment, index) => typeof segment === "number" ? segments[index] === "[]" : segments[index] === segment);
+});
+var hasInvariantInElements = (path, invariants) => invariants.some((invariant) => {
+  const segments = segmentsOf(invariant);
+  return segments.length > path.length && segments[path.length] === "[]" && path.every((segment, index) => typeof segment === "number" ? segments[index] === "[]" : segments[index] === segment);
+});
+var unionTypeNames = (issue) => {
+  if (issue.code !== "invalid_union")
+    return;
+  const names = new Set;
+  for (const optionIssues of issue.errors) {
+    const first = optionIssues[0];
+    if (first?.code !== "invalid_type")
+      return;
+    names.add(first.expected);
+  }
+  return names.size === 0 ? undefined : [...names].sort().join(" | ");
+};
+var expectedTypeOf = (issue) => issue.code === "invalid_type" ? issue.expected : unionTypeNames(issue) ?? "valid value";
+var findRemovalTarget = (input, path) => {
+  for (let end = path.length;end > 0; end -= 1) {
+    if (isRecord(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 (isRecord(parent) && key !== undefined)
+    Reflect.deleteProperty(parent, key);
+};
+var issuePaths = (issues) => [
+  ...new Set(issues.map((issue) => issue.path.join(".") || "(root)"))
+];
+var tolerantDecoder = (schema, invariants) => (body) => {
+  if (body.kind !== "json")
+    return { ok: false, issues: ["(body)"] };
+  const input = body.value;
+  const first = schema.safeParse(input);
+  if (first.success)
+    return { ok: true, data: first.data };
+  const pruned = structuredClone(input);
+  const droppedPaths = [];
+  for (const issue of first.error.issues) {
+    const target = findRemovalTarget(input, issue.path);
+    const isElementOfInvariantArray = target !== undefined && target.length < issue.path.length && hasInvariantInElements(target, invariants);
+    if (target === undefined || isInvariant(target, invariants) || isElementOfInvariantArray) {
+      return { ok: false, issues: issuePaths(first.error.issues) };
+    }
+    removeAt(pruned, target);
+    droppedPaths.push(formatPath(target));
+  }
+  const second = schema.safeParse(pruned);
+  if (!second.success)
+    return { ok: false, issues: issuePaths(second.error.issues) };
+  const warnings = first.error.issues.map((issue, index) => ({
+    path: formatPath(issue.path),
+    dropped: droppedPaths[index] ?? formatPath(issue.path),
+    expected: expectedTypeOf(issue),
+    received: typeNameAt(input, issue.path)
+  }));
+  return { ok: true, data: second.data, warnings };
+};
+
+// src/operations/catalogs-list-billing-profiles.ts
+var billingProfileSchema = z.looseObject({
+  id: z.number(),
+  descricao: z.string().optional().nullable(),
+  codigo_banco: z.string().optional().nullable()
+});
+var billingProfilesSchema = z.array(billingProfileSchema);
+var billingProfilesInvariants = ["[].id"];
+var buildRequest = () => ({ ok: true });
+var catalogsListBillingProfilesSensitivity = { input: [], output: [] };
+var catalogsListBillingProfiles = {
+  name: "catalogs.listBillingProfiles",
+  method: "GET",
+  pathTemplate: "/api/ura/portador/",
+  encoding: "json",
+  buildRequest,
+  repeatable: true,
+  decode: tolerantDecoder(billingProfilesSchema, billingProfilesInvariants),
+  sensitivity: catalogsListBillingProfilesSensitivity
 };
 
-// src/endpoints/crm/create-customer.ts
+// src/operations/catalogs-list-nas.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",
+var nasPopSchema = z2.looseObject({
+  id: z2.number().optional().nullable(),
+  cidade: z2.string().optional().nullable(),
+  uf: z2.string().optional().nullable(),
+  codigo_ibge: z2.number().optional().nullable(),
+  ativo: z2.boolean().optional().nullable()
+});
+var nasSchema = z2.looseObject({
+  id: z2.number(),
+  descricao: z2.string().optional().nullable(),
+  identificador: z2.string().optional().nullable(),
+  endereco_ip: z2.string().optional().nullable(),
+  ativo: z2.boolean().optional().nullable(),
+  pops: z2.array(nasPopSchema).optional().nullable()
+});
+var nasListSchema = z2.array(nasSchema);
+var nasInvariants = ["[].id"];
+var buildRequest2 = () => ({ ok: true });
+var catalogsListNasSensitivity = {
+  input: [],
+  output: [{ path: "[]", secretKeys: ["endereco_ip"], personalKeys: [] }]
+};
+var catalogsListNas = {
+  name: "catalogs.listNas",
   method: "POST",
-  path: "/api/crm/cliente/J",
-  schema: createCustomerSchema,
-  keyFields: createCustomerKeyFields,
-  itemPath: customerCreatedItemPath,
-  secretKeys: customerCreatedSecretKeys,
-  personalKeys: customerCreatedPersonalKeys
+  pathTemplate: "/api/ura/nas/list/",
+  encoding: "json",
+  buildRequest: buildRequest2,
+  repeatable: true,
+  decode: tolerantDecoder(nasListSchema, nasInvariants),
+  sensitivity: catalogsListNasSensitivity
 };
 
-// src/endpoints/crm/update-customer-status.ts
+// src/operations/catalogs-list-pops.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 popSchema = z3.looseObject({
+  id: z3.number(),
+  pop: z3.string().optional().nullable()
 });
-var updateCustomerStatusKeyFields = ["cliente_id", "novo_status.codigo"];
-var customerStatusItemPath = "";
-var customerStatusSecretKeys = [];
-var customerStatusPersonalKeys = ["message"];
-var updateCustomerStatusDefinition = {
-  kind: "write",
+var popsSchema = z3.array(popSchema);
+var popsInvariants = ["[].id"];
+var buildRequest3 = () => ({ ok: true });
+var catalogsListPopsSensitivity = { input: [], output: [] };
+var catalogsListPops = {
+  name: "catalogs.listPops",
   method: "POST",
-  path: "/api/crm/cliente/{cliente_id}/status/",
-  schema: updateCustomerStatusSchema,
-  keyFields: updateCustomerStatusKeyFields,
-  itemPath: customerStatusItemPath,
-  secretKeys: customerStatusSecretKeys,
-  personalKeys: customerStatusPersonalKeys
+  pathTemplate: "/api/ura/pops/",
+  encoding: "json",
+  buildRequest: buildRequest3,
+  repeatable: true,
+  decode: tolerantDecoder(popsSchema, popsInvariants),
+  sensitivity: catalogsListPopsSensitivity
 };
 
-// src/endpoints/os/list-occurrence-reasons.ts
+// src/operations/contracts-list.ts
+import { z as z5 } from "zod";
+
+// src/ids.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
-};
+var customerIdSchema = z4.number().brand();
 
-// 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/operations/contracts-list.ts
+var contractSummarySchema = z5.looseObject({
+  id_contrato: z5.number(),
+  id_cliente: customerIdSchema,
+  status: z5.string().optional().nullable(),
+  pop_id: z5.number().optional().nullable(),
+  nome: z5.string().optional().nullable(),
+  cpfcnpj: z5.string().optional().nullable(),
+  email: z5.string().optional().nullable(),
+  telefone: z5.string().optional().nullable(),
+  data_status: z5.string().optional().nullable(),
+  data_cadastro: z5.string().optional().nullable(),
+  motivo_status: z5.string().optional().nullable()
+});
+var contractsSchema = z5.array(contractSummarySchema);
+var contractsInvariants = ["[].id_contrato", "[].id_cliente"];
+var contractsListInputSchema = z5.strictObject({
+  contrato: z5.number().int().optional(),
+  plano: z5.number().int().optional(),
+  tipo: z5.string().optional(),
+  status: z5.number().int().optional(),
+  exibir_endereco: z5.boolean().optional()
+});
+var buildRequest4 = (input) => {
+  const parsed = contractsListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid contracts.list input" };
+  return { ok: true, params: parsed.data };
+};
+var contractsListSensitivity = {
+  input: [],
+  output: [
+    {
+      path: "[]",
+      secretKeys: [],
+      personalKeys: ["nome", "cpfcnpj", "email", "telefone", "motivo_status"]
+    }
+  ]
+};
+var contractsList = {
+  name: "contracts.list",
+  method: "POST",
+  pathTemplate: "/api/ura/listacontrato/",
+  encoding: "json",
+  buildRequest: buildRequest4,
+  repeatable: true,
+  decode: tolerantDecoder(contractsSchema, contractsInvariants),
+  sensitivity: contractsListSensitivity
 };
 
-// src/endpoints/precadastro/list-due-days.ts
+// src/operations/contracts-list-status-reasons.ts
 import { z as z6 } from "zod";
-var dueDaySchema = z6.object({
+var statusReasonSchema = z6.looseObject({
   id: z6.number(),
-  dia: z6.number()
-});
-var listDueDaysSchema = z6.array(dueDaySchema);
-var listDueDaysKeyFields = ["[].id", "[].dia"];
-var dueDayItemPath = "[]";
-var dueDaySecretKeys = [];
-var dueDayPersonalKeys = [];
-var listDueDaysDefinition = {
+  motivo: z6.string().optional().nullable()
+});
+var statusReasonsSchema = z6.array(statusReasonSchema);
+var statusReasonsInvariants = ["[].id"];
+var buildRequest5 = () => ({ ok: true });
+var contractsListStatusReasonsSensitivity = { input: [], output: [] };
+var contractsListStatusReasons = {
+  name: "contracts.listStatusReasons",
   method: "POST",
-  path: "/api/precadastro/vencimento/list",
-  schema: listDueDaysSchema,
-  keyFields: listDueDaysKeyFields,
-  itemPath: dueDayItemPath,
-  secretKeys: dueDaySecretKeys,
-  personalKeys: dueDayPersonalKeys
+  pathTemplate: "/api/ura/contrato/status/motivos/",
+  encoding: "json",
+  buildRequest: buildRequest5,
+  repeatable: true,
+  decode: tolerantDecoder(statusReasonsSchema, statusReasonsInvariants),
+  sensitivity: contractsListStatusReasonsSensitivity
 };
 
-// src/endpoints/precadastro/list-sellers.ts
+// src/operations/contracts-update.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 = {
+var id = z7.number().int().nonnegative();
+var contractsUpdateInputSchema = z7.strictObject({ contrato: id, forma_cobranca: id });
+var buildRequest6 = (input) => {
+  const parsed = contractsUpdateInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid contracts.update input" };
+  return { ok: true, params: parsed.data };
+};
+var contractUpdatedSchema = z7.looseObject({
+  resposta: z7.looseObject({
+    mensagem: z7.string().optional().nullable(),
+    contrato: z7.number(),
+    alterados: z7.array(z7.string())
+  })
+});
+var contractUpdatedInvariants = ["resposta", "resposta.contrato", "resposta.alterados"];
+var contractsUpdateSensitivity = { input: [], output: [] };
+var contractsUpdate = {
+  name: "contracts.update",
   method: "POST",
-  path: "/api/precadastro/vendedor/list",
-  schema: listSellersSchema,
-  keyFields: listSellersKeyFields,
-  itemPath: sellerItemPath,
-  secretKeys: sellerSecretKeys,
-  personalKeys: sellerPersonalKeys
+  pathTemplate: "/api/ura/contrato/edit/",
+  encoding: "json",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest6,
+  decode: tolerantDecoder(contractUpdatedSchema, contractUpdatedInvariants),
+  sensitivity: contractsUpdateSensitivity
 };
 
-// src/endpoints/suporte/add-customer-document.ts
+// src/operations/contracts-update-status.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
+var id2 = z8.number().int().nonnegative();
+var contractsUpdateStatusInputSchema = z8.strictObject({
+  contrato: id2,
+  status: id2,
+  motivo: id2.optional()
+});
+var buildRequest7 = (input) => {
+  const parsed = contractsUpdateStatusInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid contracts.updateStatus input" };
+  return { ok: true, params: parsed.data };
+};
+var statusChangedSchema = z8.looseObject({
+  resposta: z8.looseObject({
+    mensagem: z8.string().optional().nullable(),
+    contrato: z8.number(),
+    contrato_status: z8.string()
+  })
+});
+var statusChangedInvariants = [
+  "resposta",
+  "resposta.contrato",
+  "resposta.contrato_status"
+];
+var STATUS_NOT_CHANGED_TEXT = /^status de contrato não alterado\.?$/i;
+var statusNotChanged = errorStringRejection(400, STATUS_NOT_CHANGED_TEXT, "STATUS_NOT_CHANGED");
+var contractsUpdateStatusSensitivity = { input: [], output: [] };
+var contractsUpdateStatus = {
+  name: "contracts.updateStatus",
+  method: "POST",
+  pathTemplate: "/api/ura/contrato/status/edit/",
+  encoding: "json",
+  repeatable: false,
+  write: { knownRejections: [statusNotChanged] },
+  buildRequest: buildRequest7,
+  decode: tolerantDecoder(statusChangedSchema, statusChangedInvariants),
+  sensitivity: contractsUpdateStatusSensitivity
 };
 
-// src/endpoints/suporte/list-customer-documents.ts
+// src/operations/coverage-check.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 = {
+var coverageCheckInputSchema = z9.strictObject({
+  gateway: z9.number().int().positive(),
+  raio: z9.number().nonnegative(),
+  coordenada: z9.string().min(1)
+});
+var buildRequest8 = (input) => {
+  const parsed = coverageCheckInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid coverage.check input" };
+  const { gateway, raio, coordenada } = parsed.data;
+  return { ok: true, params: { gateway, raio, coordenada } };
+};
+var numberOrText = z9.union([z9.number(), z9.string()]);
+var ctoSchema = z9.looseObject({
+  lat: numberOrText.optional().nullable(),
+  lng: numberOrText.optional().nullable(),
+  distancia: numberOrText.optional().nullable(),
+  id: numberOrText.optional().nullable(),
+  nome: z9.string().optional().nullable()
+});
+var ctoListDecoder = tolerantDecoder(z9.array(ctoSchema), []);
+var setOwn = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+};
+var failed = (...issues) => ({ ok: false, issues });
+var decode = (body) => {
+  if (body.kind !== "json")
+    return failed("(body)");
+  const root = body.value;
+  if (!Array.isArray(root))
+    return failed("(root)");
+  const data = [];
+  const warnings = [];
+  const entries = root;
+  for (const [index, entry] of entries.entries()) {
+    if (!isRecord(entry))
+      return failed(String(index));
+    const answers = {};
+    for (const [gateway, answer] of Object.entries(entry)) {
+      if (typeof answer === "string") {
+        setOwn(answers, gateway, answer);
+        continue;
+      }
+      const where = `${index}.${gateway}`;
+      if (!Array.isArray(answer))
+        return failed(where);
+      const ctos = ctoListDecoder({ kind: "json", value: structuredClone(answer) });
+      if (!ctos.ok)
+        return failed(...ctos.issues.map((issue) => `${where}.${issue}`));
+      setOwn(answers, gateway, ctos.data);
+      for (const warning of ctos.warnings ?? []) {
+        const prefix = `[${index}].${gateway}`;
+        warnings.push({
+          ...warning,
+          path: `${prefix}${warning.path}`,
+          dropped: `${prefix}${warning.dropped}`
+        });
+      }
+    }
+    data.push(answers);
+  }
+  return warnings.length === 0 ? { ok: true, data } : { ok: true, data, warnings };
+};
+var coverageCheckSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["coordenada"] }],
+  output: []
+};
+var coverageCheck = {
+  name: "coverage.check",
   method: "GET",
-  path: "/api/suporte/cliente/{cliente_id}/documento/list/",
-  schema: listCustomerDocumentsSchema,
-  keyFields: listCustomerDocumentsKeyFields,
-  itemPath: customerDocumentItemPath,
-  secretKeys: customerDocumentSecretKeys,
-  personalKeys: customerDocumentPersonalKeys
+  pathTemplate: "/api/ura/viabilidadeinstalacao",
+  encoding: "json",
+  buildRequest: buildRequest8,
+  repeatable: true,
+  decode,
+  sensitivity: coverageCheckSensitivity
 };
 
-// src/endpoints/ura/check-coverage.ts
+// src/operations/crm-contracts-create.ts
+import { z as z12 } from "zod";
+
+// src/address.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
+var addressShape = {
+  logradouro: z10.string().optional(),
+  numero: z10.union([z10.string(), z10.number()]).optional(),
+  complemento: z10.string().optional(),
+  bairro: z10.string().optional(),
+  cidade: z10.string().optional(),
+  cep: z10.string().optional(),
+  uf: z10.string().optional(),
+  pais: z10.string().optional(),
+  pontoreferencia: z10.string().optional(),
+  map_ll: z10.string().optional(),
+  condominio: z10.union([z10.string(), z10.number()]).optional()
+};
+var flatAddress = (address) => {
+  const flat = {};
+  for (const [key, value] of Object.entries(address)) {
+    if (value !== undefined)
+      flat[key] = value;
+  }
+  return flat;
 };
 
-// src/endpoints/ura/list-clients.ts
+// src/validation.ts
 import { z as z11 } from "zod";
-var addressSchema = z11.object({
-  logradouro: z11.string().optional().nullable(),
-  numero: z11.number().optional().nullable(),
-  bairro: z11.string().optional().nullable(),
-  cidade: z11.string().optional().nullable(),
-  uf: z11.string().optional().nullable(),
-  cep: z11.string().optional().nullable(),
-  complemento: z11.string().optional().nullable(),
-  latitude: z11.string().optional().nullable(),
-  longitude: z11.string().optional().nullable()
-});
-var contactsSchema = z11.object({
-  telefones: z11.array(z11.string()).optional().nullable(),
-  celulares: z11.array(z11.string()).optional().nullable(),
-  emails: z11.array(z11.string()).optional().nullable(),
-  outros: z11.array(z11.string()).optional().nullable()
-});
-var clientSchema = z11.object({
-  id: z11.number(),
-  nome: z11.string(),
-  tipo: z11.string(),
-  cpfcnpj: z11.string(),
-  sexo: z11.string().optional().nullable(),
-  dataCadastro: z11.string().optional().nullable(),
-  endereco: addressSchema.optional().nullable(),
-  contratos: z11.array(z11.object({})).optional().nullable(),
-  titulos: z11.array(z11.object({})).optional().nullable(),
+var nonBlank = z11.string().refine((value) => value.trim() !== "", "blank");
+
+// src/operations/crm-contracts-create.ts
+var addressSchema = z12.strictObject({
+  ...addressShape,
+  logradouro: nonBlank,
+  bairro: nonBlank,
+  cidade: nonBlank,
+  cep: nonBlank,
+  uf: nonBlank
+});
+var customerId = customerIdSchema.int().positive();
+var id3 = z12.number().int().nonnegative();
+var amount = z12.number().nonnegative();
+var crmContractsCreateInputSchema = z12.strictObject({
+  cliente_id: customerId,
+  pop_id: id3,
+  plano_id: id3.brand(),
+  portador_id: id3,
+  forma_cobranca_codigo: id3,
+  vencimento_dia: id3,
+  endereco_instalacao: addressSchema,
+  endereco_cobranca: addressSchema,
+  login: z12.string().optional(),
+  senha: z12.string().optional(),
+  modoaquisicao: z12.union([z12.literal(0), z12.literal(1)]).optional(),
+  nas: z12.string().optional(),
+  isento: amount.optional(),
+  autocobranca: z12.boolean().optional(),
+  servicodesc: z12.string().optional(),
+  observacao: z12.string().optional(),
+  vendedor_id: id3.optional(),
+  comissao_tipo: z12.union([z12.literal(1), z12.literal(2)]).optional(),
+  comissao: amount.optional(),
+  contrato_id: id3.optional(),
+  fidelidade_id: id3.optional(),
+  midia_id: id3.optional(),
+  central_login: z12.string().optional(),
+  central_senha: z12.string().optional(),
+  ip: z12.string().optional(),
+  ippool_id: id3.optional(),
+  mac_dhcp: z12.string().optional(),
+  mac: z12.string().optional(),
+  logins_simult: id3.optional(),
+  splitter_id: id3.optional(),
+  splitter_port: id3.optional(),
+  tipo_equipamento: z12.string().optional(),
+  usuarioalt_id: id3.optional(),
+  os_instalacao: z12.boolean().optional(),
+  conteudo: z12.string().optional(),
+  instalacao_quantidade_parcelas: id3.optional(),
+  instalacao_preco: amount.optional(),
+  instalacao_desconto: amount.optional(),
+  instalacao_entrada: amount.optional(),
+  instalacao_entrada_forma: id3.optional(),
+  instalacao_parcela_forma: id3.optional(),
+  instalacao_portador: id3.optional()
+});
+var crmContractBody = ({
+  endereco_instalacao,
+  endereco_cobranca,
+  ...fields
+}) => {
+  const installation = flatAddress(endereco_instalacao);
+  return {
+    ...fields,
+    endereco_instalacao: installation,
+    endereco_cobranca: flatAddress(endereco_cobranca),
+    ...installation
+  };
+};
+var buildRequest9 = (input) => {
+  const parsed = crmContractsCreateInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid crm.contracts.create input" };
+  const { cliente_id, ...contract } = parsed.data;
+  return { ok: true, pathParams: { cliente_id }, params: crmContractBody(contract) };
+};
+var crmContractCreatedSchema = z12.looseObject({
+  message: z12.string().optional().nullable(),
+  clientecontrato: z12.number(),
+  cliente: z12.string().optional().nullable()
+});
+var crmContractCreatedInvariants = ["clientecontrato"];
+var CUSTOMER_NOT_IN_CRM_TEXT = /^ocorreu um erro: não encontrado cliente crm com id \d+\.?$/i;
+var customerNotInCrm = singleErrorsEntryRejection(400, CUSTOMER_NOT_IN_CRM_TEXT, "CUSTOMER_NOT_IN_CRM");
+var crmContractsCreateSensitivity = {
+  input: [
+    {
+      path: "",
+      secretKeys: ["login", "senha", "central_login", "central_senha", "ip", "mac", "mac_dhcp"],
+      personalKeys: [
+        "endereco_instalacao",
+        "endereco_cobranca",
+        "servicodesc",
+        "observacao",
+        "conteudo"
+      ]
+    }
+  ],
+  output: [{ path: "", secretKeys: [], personalKeys: ["cliente"] }]
+};
+var crmContractsCreate = {
+  name: "crm.contracts.create",
+  method: "POST",
+  pathTemplate: "/api/crm/cliente/{cliente_id}/contratos/",
+  encoding: "json",
+  repeatable: false,
+  write: { knownRejections: [customerNotInCrm] },
+  buildRequest: buildRequest9,
+  decode: tolerantDecoder(crmContractCreatedSchema, crmContractCreatedInvariants),
+  sensitivity: crmContractsCreateSensitivity
+};
+
+// src/operations/crm-contracts-create-by-cpf-cnpj.ts
+var crmContractsCreateByCpfCnpjInputSchema = crmContractsCreateInputSchema.omit({ cliente_id: true }).extend({ cpfcnpj: nonBlank });
+var buildRequest10 = (input) => {
+  const parsed = crmContractsCreateByCpfCnpjInputSchema.safeParse(input);
+  if (!parsed.success) {
+    return { ok: false, problem: "invalid crm.contracts.createByCpfCnpj input" };
+  }
+  const { cpfcnpj, ...contract } = parsed.data;
+  return { ok: true, query: { cpfcnpj }, params: crmContractBody(contract) };
+};
+var CUSTOMER_NOT_IN_CRM_TEXT2 = /^ocorreu um erro: não encontrado cliente crm com documento [\d./-]+\.?$/i;
+var customerNotInCrm2 = singleErrorsEntryRejection(400, CUSTOMER_NOT_IN_CRM_TEXT2, "CUSTOMER_NOT_IN_CRM");
+var crmContractsCreateByCpfCnpjSensitivity = {
+  input: crmContractsCreateSensitivity.input.map((scope) => ({
+    ...scope,
+    personalKeys: [...scope.personalKeys, "cpfcnpj"]
+  })),
+  output: crmContractsCreateSensitivity.output
+};
+var crmContractsCreateByCpfCnpj = {
+  name: "crm.contracts.createByCpfCnpj",
+  method: "POST",
+  pathTemplate: "/api/crm/cliente/contratos/",
+  encoding: "json",
+  repeatable: false,
+  write: { knownRejections: [customerNotInCrm2] },
+  buildRequest: buildRequest10,
+  decode: tolerantDecoder(crmContractCreatedSchema, crmContractCreatedInvariants),
+  sensitivity: crmContractsCreateByCpfCnpjSensitivity
+};
+
+// src/operations/crm-contracts-list.ts
+import { z as z13 } from "zod";
+var crmContractsListInputSchema = z13.strictObject({ cpfcnpj: nonBlank });
+var buildRequest11 = (input) => {
+  const parsed = crmContractsListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid crm.contracts.list input" };
+  return { ok: true, params: parsed.data };
+};
+var serviceSchema = z13.looseObject({
+  plano: z13.string().optional().nullable(),
+  login: z13.string().optional().nullable(),
+  contrato_tipo: z13.string().optional().nullable(),
+  situacao: z13.string().optional().nullable(),
+  aquisicao: z13.string().optional().nullable()
+});
+var contractSchema = z13.looseObject({
+  cliente_contrato_id: z13.number(),
+  data_cadastro: z13.string().optional().nullable(),
+  vencimento_dia: z13.number().optional().nullable(),
+  pop: z13.string().optional().nullable(),
+  endereco: z13.string().optional().nullable(),
+  forma_cobranca: z13.string().optional().nullable(),
+  status: z13.string().optional().nullable(),
+  data_status: z13.string().optional().nullable(),
+  modo_status: z13.string().optional().nullable(),
+  motivo_status: z13.string().optional().nullable(),
+  vendedor: z13.string().optional().nullable(),
+  servicos: z13.array(serviceSchema).optional().nullable()
+});
+var contractsSchema2 = z13.looseObject({
+  cliente: z13.string().optional().nullable(),
+  cpf_cnpj: z13.string().optional().nullable(),
+  contratos: z13.array(contractSchema)
+});
+var contractsInvariants2 = ["contratos", "contratos[].cliente_contrato_id"];
+var crmContractsListSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["cpfcnpj"] }],
+  output: [
+    { path: "", secretKeys: [], personalKeys: ["cliente", "cpf_cnpj"] },
+    {
+      path: "contratos[]",
+      secretKeys: [],
+      personalKeys: ["endereco", "motivo_status", "vendedor"]
+    },
+    { path: "contratos[].servicos[]", secretKeys: ["login"], personalKeys: ["email"] }
+  ]
+};
+var crmContractsList = {
+  name: "crm.contracts.list",
+  method: "GET",
+  pathTemplate: "/api/crm/cliente/contratos/",
+  encoding: "json",
+  buildRequest: buildRequest11,
+  repeatable: true,
+  decode: tolerantDecoder(contractsSchema2, contractsInvariants2),
+  sensitivity: crmContractsListSensitivity
+};
+
+// src/operations/crm-customers-create.ts
+import { z as z14 } from "zod";
+var crmCustomerAddressSchema = z14.strictObject({
+  ...addressShape,
+  logradouro: nonBlank,
+  bairro: nonBlank,
+  cidade: nonBlank,
+  cep: nonBlank,
+  uf: nonBlank
+});
+var commonShape = {
+  nome: nonBlank,
+  cpfcnpj: nonBlank,
+  endereco: crmCustomerAddressSchema,
+  email: z14.string().optional(),
+  celular: z14.string().optional(),
+  observacao: z14.string().optional()
+};
+var crmCustomersCreateInputSchema = z14.discriminatedUnion("personType", [
+  z14.strictObject({
+    personType: z14.literal("F"),
+    ...commonShape,
+    datanasc: z14.string().optional(),
+    rg: z14.string().optional(),
+    rg_emissor: z14.string().optional(),
+    sexo: z14.enum(["M", "F"]).optional(),
+    estadocivil: z14.enum(["C", "S", "V", "D"]).optional(),
+    nomemae: z14.string().optional(),
+    nomepai: z14.string().optional(),
+    profissao: z14.string().optional(),
+    nacionalidade: z14.string().optional(),
+    naturalidade: z14.string().optional()
+  }),
+  z14.strictObject({
+    personType: z14.literal("J"),
+    ...commonShape,
+    nomefantasia: z14.string().optional(),
+    respempresa: z14.string().optional(),
+    respcpf: z14.string().optional(),
+    insc_estadual: z14.string().optional(),
+    insc_municipal: z14.string().optional(),
+    datafundacao: z14.string().optional()
+  })
+]);
+var buildRequest12 = (input) => {
+  const parsed = crmCustomersCreateInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid crm.customers.create input" };
+  const { personType, endereco, ...fields } = parsed.data;
+  const flat = flatAddress(endereco);
+  return { ok: true, pathParams: { personType }, params: { ...fields, endereco: flat, ...flat } };
+};
+var createdSchema = z14.looseObject({
+  cliente_id: customerIdSchema,
+  message: z14.string().optional().nullable()
+});
+var createdInvariants = ["cliente_id"];
+var crmCustomersCreateSensitivity = {
+  input: [
+    {
+      path: "",
+      secretKeys: [],
+      personalKeys: [
+        "nome",
+        "cpfcnpj",
+        "endereco",
+        "email",
+        "celular",
+        "observacao",
+        "datanasc",
+        "rg",
+        "rg_emissor",
+        "sexo",
+        "estadocivil",
+        "nomemae",
+        "nomepai",
+        "profissao",
+        "nacionalidade",
+        "naturalidade",
+        "nomefantasia",
+        "respempresa",
+        "respcpf",
+        "insc_estadual",
+        "insc_municipal",
+        "datafundacao"
+      ]
+    }
+  ],
+  output: [{ path: "", secretKeys: [], personalKeys: ["message"] }]
+};
+var crmCustomersCreate = {
+  name: "crm.customers.create",
+  method: "POST",
+  pathTemplate: "/api/crm/cliente/{personType}",
+  encoding: "json",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest12,
+  decode: tolerantDecoder(createdSchema, createdInvariants),
+  sensitivity: crmCustomersCreateSensitivity
+};
+
+// src/operations/crm-customers-update-status.ts
+import { z as z15 } from "zod";
+var customerId2 = customerIdSchema.int().positive();
+var crmCustomersUpdateStatusInputSchema = z15.strictObject({
+  cliente_id: customerId2,
+  status_id: z15.number().int().nonnegative(),
+  motivo: z15.string().optional()
+});
+var buildRequest13 = (input) => {
+  const parsed = crmCustomersUpdateStatusInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid crm.customers.updateStatus input" };
+  const { cliente_id, ...fields } = parsed.data;
+  return { ok: true, pathParams: { cliente_id }, params: fields };
+};
+var statusUpdatedSchema = z15.looseObject({
+  cliente_id: customerIdSchema,
+  message: z15.string().optional().nullable(),
+  novo_status: z15.looseObject({
+    codigo: z15.number(),
+    descricao: z15.string().optional().nullable()
+  })
+});
+var statusUpdatedInvariants = ["cliente_id", "novo_status", "novo_status.codigo"];
+var crmCustomersUpdateStatusSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["motivo"] }],
+  output: [{ path: "", secretKeys: [], personalKeys: ["message"] }]
+};
+var crmCustomersUpdateStatus = {
+  name: "crm.customers.updateStatus",
+  method: "POST",
+  pathTemplate: "/api/crm/cliente/{cliente_id}/status/",
+  encoding: "json",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest13,
+  decode: tolerantDecoder(statusUpdatedSchema, statusUpdatedInvariants),
+  sensitivity: crmCustomersUpdateStatusSensitivity
+};
+
+// src/operations/customers-list.ts
+import { z as z16 } from "zod";
+var addressSchema2 = z16.looseObject({
+  logradouro: z16.string().optional().nullable(),
+  numero: z16.union([z16.number(), z16.string()]).optional().nullable(),
+  bairro: z16.string().optional().nullable(),
+  cidade: z16.string().optional().nullable(),
+  uf: z16.string().optional().nullable(),
+  cep: z16.string().optional().nullable(),
+  complemento: z16.string().optional().nullable(),
+  latitude: z16.string().optional().nullable(),
+  longitude: z16.string().optional().nullable()
+});
+var planSchema = z16.looseObject({
+  id: z16.number().brand(),
+  descricao: z16.string().optional().nullable()
+});
+var serviceSchema2 = z16.looseObject({
+  id: z16.number(),
+  tipo: z16.string().optional().nullable(),
+  plano: planSchema.optional().nullable(),
+  status: z16.string().optional().nullable(),
+  endereco: addressSchema2.optional().nullable()
+});
+var contractSchema2 = z16.looseObject({
+  id: z16.number(),
+  status: z16.string().optional().nullable(),
+  endereco: addressSchema2.optional().nullable(),
+  servicos: z16.array(serviceSchema2).optional().nullable()
+});
+var contactsSchema = z16.looseObject({
+  telefones: z16.array(z16.string()).optional().nullable(),
+  celulares: z16.array(z16.string()).optional().nullable(),
+  emails: z16.array(z16.string()).optional().nullable(),
+  outros: z16.array(z16.unknown()).optional().nullable()
+});
+var customerSchema = z16.looseObject({
+  id: customerIdSchema,
+  nome: z16.string(),
+  tipo: z16.string(),
+  cpfcnpj: z16.string(),
+  sexo: z16.string().optional().nullable(),
+  dataCadastro: z16.string().optional().nullable(),
+  endereco: addressSchema2.optional().nullable(),
+  contratos: z16.array(contractSchema2).optional().nullable(),
+  titulos: z16.array(z16.looseObject({})).optional().nullable(),
   contatos: contactsSchema.optional().nullable()
 });
-var listClientsSchema = z11.object({
-  paginacao: z11.object({
-    offset: z11.number().optional().nullable(),
-    limit: z11.number().optional().nullable(),
-    parcial: z11.number().optional().nullable(),
-    total: z11.number()
+var pageSchema = z16.looseObject({
+  paginacao: z16.looseObject({
+    offset: z16.number().optional().nullable(),
+    limit: z16.number().optional().nullable(),
+    parcial: z16.number().optional().nullable(),
+    total: z16.number()
   }),
-  clientes: z11.array(clientSchema)
+  clientes: z16.array(customerSchema)
 });
-var listClientsKeyFields = [
+var pageInvariants = [
+  "paginacao",
   "paginacao.total",
   "clientes",
   "clientes[].id",
   "clientes[].nome",
   "clientes[].cpfcnpj",
-  "clientes[].tipo"
+  "clientes[].tipo",
+  "clientes[].contratos[].id",
+  "clientes[].contratos[].servicos[].id",
+  "clientes[].contratos[].servicos[].plano.id"
 ];
-var clientItemPath = "clientes[]";
-var clientSecretKeys = [];
-var clientPersonalKeys = ["nome", "cpfcnpj", "sexo", "endereco", "contatos"];
-var listClientsDefinition = {
+var customersListInputSchema = z16.strictObject({
+  offset: z16.number().int().nonnegative().optional(),
+  limit: z16.number().int().nonnegative().optional(),
+  cliente_id: customerIdSchema.int().optional(),
+  cpfcnpj: z16.string().optional(),
+  cliente_nome: z16.string().optional()
+});
+var buildRequest14 = (input) => {
+  const parsed = customersListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid customers.list input" };
+  return { ok: true, params: parsed.data };
+};
+var customersListSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["cpfcnpj", "cliente_nome"] }],
+  output: [
+    {
+      path: "clientes[]",
+      secretKeys: [],
+      personalKeys: ["nome", "cpfcnpj", "sexo", "endereco", "contatos"]
+    },
+    {
+      path: "clientes[].contratos[]",
+      secretKeys: ["contratoCentralLogin", "contratoCentralSenha"],
+      personalKeys: ["motivo_status", "endereco"]
+    },
+    {
+      path: "clientes[].contratos[].servicos[]",
+      secretKeys: [
+        "login",
+        "senha",
+        "mac",
+        "serial",
+        "ip",
+        "wifi_ssid",
+        "wifi_password",
+        "wifi_ssid_5",
+        "wifi_password_5"
+      ],
+      personalKeys: ["endereco"]
+    }
+  ]
+};
+var customersList = {
+  name: "customers.list",
   method: "POST",
-  path: "/api/ura/clientes/",
-  schema: listClientsSchema,
-  keyFields: listClientsKeyFields,
-  itemPath: clientItemPath,
-  secretKeys: clientSecretKeys,
-  personalKeys: clientPersonalKeys
+  pathTemplate: "/api/ura/clientes/",
+  encoding: "json",
+  buildRequest: buildRequest14,
+  repeatable: true,
+  decode: tolerantDecoder(pageSchema, pageInvariants),
+  sensitivity: customersListSensitivity
 };
 
-// src/endpoints/ura/list-contracts.ts
-import { z as z12 } from "zod";
-var contractSummarySchema = z12.object({
-  id_contrato: z12.number(),
-  id_cliente: z12.number(),
-  status: z12.string(),
-  pop_id: z12.number(),
-  nome: z12.string().optional().nullable(),
-  cpfcnpj: z12.string().optional().nullable(),
-  email: z12.string().optional().nullable(),
-  telefone: z12.string().optional().nullable(),
-  data_status: z12.string().optional().nullable(),
-  data_cadastro: z12.string().optional().nullable(),
-  motivo_status: z12.string().optional().nullable()
-});
-var listContractsSchema = z12.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 = {
+// src/operations/customers-search.ts
+import { z as z17 } from "zod";
+var contactSchema = z17.looseObject({
+  inscricoes: z17.array(z17.string()).optional().nullable(),
+  tipoContato: z17.string().optional().nullable(),
+  contato: z17.string().optional().nullable()
+});
+var tagSchema = z17.looseObject({
+  color: z17.string().optional().nullable(),
+  font: z17.string().optional().nullable(),
+  tag: z17.string().optional().nullable(),
+  id: z17.number().optional().nullable(),
+  categoria_id: z17.unknown().optional()
+});
+var loyaltySchema = z17.looseObject({
+  data_inicio: z17.string().optional().nullable(),
+  descricao: z17.string().optional().nullable(),
+  data_fim: z17.string().optional().nullable()
+});
+var candidateSchema = z17.looseObject({
+  contratoId: z17.number(),
+  clienteId: customerIdSchema,
+  contratoStatus: z17.number().optional().nullable(),
+  contratoStatusDisplay: z17.string().optional().nullable(),
+  contratoValorAberto: z17.number().optional().nullable(),
+  contratoTitulosAReceber: z17.number().optional().nullable(),
+  cobVencimento: z17.number().optional().nullable(),
+  contratoStatusModo: z17.number().optional().nullable(),
+  motivo_status: z17.string().optional().nullable(),
+  dataCadastro: z17.string().optional().nullable(),
+  dataAlteracao: z17.string().optional().nullable(),
+  popId: z17.number().optional().nullable(),
+  popNome: z17.string().optional().nullable(),
+  cobPermuta: z17.boolean().optional().nullable(),
+  cobIsento: z17.number().optional().nullable(),
+  promessasPagamentoMes: z17.number().optional().nullable(),
+  link_quitacao: z17.string().optional().nullable(),
+  planointernet: z17.string().optional().nullable(),
+  fidelidade: loyaltySchema.optional().nullable(),
+  contrato_unificado_principal: z17.unknown().optional(),
+  contrato_unificado_filhos: z17.unknown().optional(),
+  tags: z17.array(tagSchema).optional().nullable(),
+  anotacoes: z17.array(z17.unknown()).optional().nullable(),
+  contratoCentralLogin: z17.string().optional().nullable(),
+  contratoCentralSenha: z17.string().optional().nullable(),
+  servico_login: z17.string().optional().nullable(),
+  servico_senha: z17.string().optional().nullable(),
+  servico_plano: z17.string().optional().nullable(),
+  servico_grupo: z17.string().optional().nullable(),
+  servico_tipo_conexao: z17.string().optional().nullable(),
+  servico_vlan: z17.string().optional().nullable(),
+  servico_mac: z17.string().optional().nullable(),
+  servico_mac2: z17.string().optional().nullable(),
+  servico_wifi_ssid: z17.string().optional().nullable(),
+  servico_wifi_ssid_5: z17.string().optional().nullable(),
+  servico_wifi_password: z17.string().optional().nullable(),
+  servico_wifi_password_5: z17.string().optional().nullable(),
+  servico_wifi_channel: z17.string().optional().nullable(),
+  servico_wifi_channel_5: z17.string().optional().nullable(),
+  razaoSocial: z17.string().optional().nullable(),
+  cpfCnpj: z17.string().optional().nullable(),
+  dataNascimento: z17.string().optional().nullable(),
+  telefones: z17.array(contactSchema).optional().nullable(),
+  telefones_cargos: z17.array(z17.unknown()).optional().nullable(),
+  emails: z17.array(contactSchema).optional().nullable(),
+  outros: z17.array(z17.unknown()).optional().nullable(),
+  endereco_logradouro: z17.string().optional().nullable(),
+  endereco_numero: z17.union([z17.number(), z17.string()]).optional().nullable(),
+  endereco_complemento: z17.string().optional().nullable(),
+  endereco_bairro: z17.string().optional().nullable(),
+  endereco_cidade: z17.string().optional().nullable(),
+  endereco_uf: z17.string().optional().nullable(),
+  endereco_cep: z17.string().optional().nullable(),
+  endereco_pontoreferencia: z17.unknown().optional(),
+  endereco_ll: z17.string().optional().nullable()
+});
+var searchSchema = z17.looseObject({
+  msg: z17.string().optional().nullable(),
+  contratos: z17.array(candidateSchema)
+});
+var searchInvariants = ["contratos", "contratos[].contratoId", "contratos[].clienteId"];
+var customersSearchInputSchema = z17.strictObject({
+  cpfcnpj: z17.string().min(1).optional(),
+  contrato: z17.number().int().optional(),
+  nome: z17.string().min(1).optional(),
+  login: z17.string().min(1).optional(),
+  telefone: z17.string().min(1).optional()
+}).refine((criteria) => Object.values(criteria).some((value) => value !== undefined), {
+  message: "at least one criterion is required"
+});
+var buildRequest15 = (input) => {
+  const parsed = customersSearchInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid customers.search input" };
+  return { ok: true, params: parsed.data };
+};
+var customersSearchSensitivity = {
+  input: [
+    {
+      path: "",
+      secretKeys: ["login"],
+      personalKeys: ["cpfcnpj", "nome", "telefone"]
+    }
+  ],
+  output: [
+    {
+      path: "contratos[]",
+      secretKeys: [
+        "contratoCentralLogin",
+        "contratoCentralSenha",
+        "servico_login",
+        "servico_senha",
+        "servico_vlan",
+        "servico_mac",
+        "servico_mac2",
+        "servico_wifi_ssid",
+        "servico_wifi_ssid_5",
+        "servico_wifi_password",
+        "servico_wifi_password_5",
+        "link_quitacao"
+      ],
+      personalKeys: [
+        "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"
+      ]
+    },
+    {
+      path: "contratos[].tags[]",
+      secretKeys: [],
+      personalKeys: ["tag"]
+    },
+    {
+      path: "contratos[].fidelidade",
+      secretKeys: [],
+      personalKeys: ["descricao"]
+    }
+  ]
+};
+var customersSearch = {
+  name: "customers.search",
   method: "POST",
-  path: "/api/ura/listacontrato/",
-  schema: listContractsSchema,
-  keyFields: listContractsKeyFields,
-  itemPath: contractSummaryItemPath,
-  secretKeys: contractSummarySecretKeys,
-  personalKeys: contractSummaryPersonalKeys
+  pathTemplate: "/api/ura/consultacliente/",
+  encoding: "json",
+  buildRequest: buildRequest15,
+  repeatable: true,
+  decode: tolerantDecoder(searchSchema, searchInvariants),
+  sensitivity: customersSearchSensitivity
 };
 
-// src/endpoints/ura/list-invoices.ts
-import { z as z13 } from "zod";
-var invoiceSchema = z13.object({
-  id: z13.number(),
-  status: z13.string(),
-  valor: z13.number(),
-  dataVencimento: z13.string(),
-  clienteNome: z13.string().optional().nullable(),
-  clienteCpfcnpj: z13.string().optional().nullable(),
-  clienteContrato: z13.number().optional().nullable(),
-  portador: z13.string().optional().nullable(),
-  numeroDocumento: z13.number().optional().nullable(),
-  nossoNumero: z13.string().optional().nullable(),
-  link: z13.string().optional().nullable(),
-  link_cobranca: z13.string().optional().nullable(),
-  valorDesconto: z13.number().optional().nullable(),
-  valorCorrigido: z13.number().optional().nullable(),
-  valorPago: z13.number().optional().nullable(),
-  valorPagoParcial: z13.number().optional().nullable(),
-  codigoBarras: z13.string().optional().nullable(),
-  linhaDigitavel: z13.string().optional().nullable(),
-  codigoPix: z13.string().optional().nullable(),
-  dataEmissao: z13.string().optional().nullable(),
-  dataPagamento: z13.string().optional().nullable(),
-  dataCancelamento: z13.string().optional().nullable(),
-  demonstrativo: z13.string().optional().nullable(),
-  acordoPagamento: z13.object({
-    acordados: z13.array(z13.object({})).optional().nullable(),
-    cobrados: z13.array(z13.object({})).optional().nullable()
-  }).optional().nullable(),
-  formaPagamento: z13.string().optional().nullable(),
-  usuario_baixa: z13.string().optional().nullable()
-});
-var listInvoicesSchema = z13.object({
-  paginacao: z13.object({
-    offset: z13.number().optional().nullable(),
-    limit: z13.number().optional().nullable(),
-    parcial: z13.number().optional().nullable(),
-    total: z13.number()
+// src/operations/documents-add.ts
+import { z as z18 } from "zod";
+var isFileData = (value) => value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer;
+var fileSchema = z18.strictObject({
+  data: z18.custom(isFileData),
+  filename: nonBlank,
+  contentType: z18.string().optional()
+});
+var documentsAddInputSchema = z18.strictObject({
+  cliente_id: customerIdSchema.int().positive(),
+  file: fileSchema,
+  descricao: z18.string().optional()
+});
+var buildRequest16 = (input) => {
+  const parsed = documentsAddInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid documents.add input" };
+  const { cliente_id, file, ...fields } = parsed.data;
+  return { ok: true, pathParams: { cliente_id }, params: fields, files: { file } };
+};
+var documentsAddSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["file", "descricao"] }],
+  output: []
+};
+var documentsAdd = {
+  name: "documents.add",
+  method: "PUT",
+  pathTemplate: "/api/suporte/cliente/{cliente_id}/documento/add/",
+  encoding: "form-files",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest16,
+  decode: (body) => body.kind === "empty" ? { ok: true, data: null } : { ok: false, issues: ["(body)"] },
+  sensitivity: documentsAddSensitivity
+};
+
+// src/operations/documents-list.ts
+import { z as z19 } from "zod";
+var documentsListInputSchema = z19.strictObject({
+  cliente_id: customerIdSchema.int().positive()
+});
+var buildRequest17 = (input) => {
+  const parsed = documentsListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid documents.list input" };
+  return { ok: true, pathParams: { cliente_id: parsed.data.cliente_id } };
+};
+var documentSchema = z19.looseObject({
+  id: z19.number(),
+  cliente_id: customerIdSchema,
+  arquivo: z19.string().optional().nullable(),
+  descricao: z19.string().optional().nullable(),
+  usuario: z19.string().optional().nullable()
+});
+var documentsSchema = z19.array(documentSchema);
+var documentsInvariants = ["[].id", "[].cliente_id"];
+var documentsListSensitivity = {
+  input: [],
+  output: [{ path: "[]", secretKeys: [], personalKeys: ["arquivo", "descricao", "usuario"] }]
+};
+var documentsList = {
+  name: "documents.list",
+  method: "GET",
+  pathTemplate: "/api/suporte/cliente/{cliente_id}/documento/list/",
+  encoding: "json",
+  buildRequest: buildRequest17,
+  repeatable: true,
+  decode: tolerantDecoder(documentsSchema, documentsInvariants),
+  sensitivity: documentsListSensitivity
+};
+
+// src/operations/experimental-annotations-list.ts
+import { z as z20 } from "zod";
+
+// src/annotation-selection.ts
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var NESTED_CUSTOMER = "[].(nested).cliente";
+var NESTED_CONTRACT = "[].(nested).clientecontrato";
+var CUSTOMER_KEY = /^(id_?)?clientes?(_?id)?$/i;
+var CONTRACT_KEY = /^(id_?)?(cliente_?)?contratos?(_?id)?$/i;
+var isIdentity = (value, expected) => Array.isArray(value) ? value.every((item) => isNumber(item) && item === expected) : isNumber(value) && value === expected;
+var nestedProblem = (record, { cliente_id: customer, contrato_id: contract }) => {
+  const expectedCustomer = customer ?? record.cliente;
+  const pending = [{ value: record, isTop: true }];
+  while (pending.length > 0) {
+    const { value, isTop } = pending.pop() ?? { value: undefined, isTop: false };
+    const children = Array.isArray(value) ? value : isRecord(value) ? Object.values(value) : [];
+    if (isRecord(value)) {
+      let hasCustomerKey = false;
+      let hasContractKey = false;
+      for (const [key, item] of Object.entries(value)) {
+        if (isTop && (key === "cliente" || key === "clientecontrato"))
+          continue;
+        if (CUSTOMER_KEY.test(key)) {
+          hasCustomerKey = true;
+          if (!isIdentity(item, expectedCustomer))
+            return NESTED_CUSTOMER;
+        } else if (CONTRACT_KEY.test(key)) {
+          hasContractKey = true;
+          if (contract !== undefined && !isIdentity(item, contract))
+            return NESTED_CONTRACT;
+        }
+      }
+      if (!isTop && customer !== undefined && contract === undefined) {
+        if (hasContractKey && !hasCustomerKey)
+          return NESTED_CUSTOMER;
+      }
+    }
+    for (const child of children) {
+      if (typeof child === "object" && child !== null)
+        pending.push({ value: child, isTop: false });
+    }
+  }
+  return;
+};
+var selectAnnotations = (rows, filters) => {
+  const { cliente_id: customer, contrato_id: contract } = filters;
+  const selected = [];
+  for (const row of rows) {
+    const record = isRecord(row) ? row : {};
+    const customerIsNumber = isNumber(record.cliente);
+    const contractIsNumber = isNumber(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 undecidable = [];
+    if (customer !== undefined && !customerIsNumber)
+      undecidable.push("[].cliente");
+    if (contract !== undefined && !contractIsNumber)
+      undecidable.push("[].clientecontrato");
+    if (undecidable.length > 0)
+      return { ok: false, paths: undecidable };
+    const nested = nestedProblem(record, filters);
+    if (nested !== undefined)
+      return { ok: false, paths: [nested] };
+    selected.push(row);
+  }
+  return { ok: true, selected };
+};
+
+// src/operations/experimental-annotations-list.ts
+var annotationSchema = z20.looseObject({
+  id: z20.number(),
+  cliente: customerIdSchema,
+  clientecontrato: z20.number().nullable(),
+  anotacao: z20.string(),
+  usuario: z20.number().optional().nullable(),
+  tipo: z20.number().optional().nullable(),
+  alerta_modo: z20.number().optional().nullable(),
+  data_cadastro: z20.string().optional().nullable(),
+  data_alteracao: z20.string().optional().nullable()
+});
+var annotationsSchema = z20.array(annotationSchema);
+var annotationInvariants = ["[].id", "[].cliente", "[].clientecontrato", "[].anotacao"];
+var identity = z20.number().int().positive();
+var customerIdentity = customerIdSchema.int().positive();
+var experimentalAnnotationsListInputSchema = z20.strictObject({
+  cliente_id: customerIdentity.optional(),
+  contrato_id: identity.optional()
+}).refine((filters) => filters.cliente_id !== undefined || filters.contrato_id !== undefined);
+var experimentalAnnotationsListSensitivity = {
+  input: [],
+  output: [
+    {
+      path: "[]",
+      secretKeys: [],
+      personalKeys: ["anotacao", "usuario", "raw"]
+    }
+  ]
+};
+var NAME = "experimental.annotations.list";
+var refuseWithoutFilters = () => ({
+  ok: false,
+  problem: "experimental.annotations.list needs a positive cliente_id and/or contrato_id"
+});
+var failClosed = () => ({
+  ok: false,
+  issues: ["(filters)"]
+});
+var base = {
+  name: NAME,
+  method: "GET",
+  pathTemplate: "/api/ura/cliente/anotacao/list/",
+  encoding: "json",
+  sensitivity: experimentalAnnotationsListSensitivity,
+  exposure: { body: "withhold", sgp: "strings-only" },
+  repeatable: true
+};
+var experimentalAnnotationsList = { ...base, buildRequest: refuseWithoutFilters, decode: failClosed };
+var decodeSelection = tolerantDecoder(annotationsSchema, annotationInvariants);
+var decodeSelected = (filters) => (body) => {
+  if (body.kind !== "json")
+    return { ok: false, issues: ["(body)"] };
+  if (!Array.isArray(body.value))
+    return { ok: false, issues: ["(root)"] };
+  const rows = body.value;
+  const selection = selectAnnotations(rows, filters);
+  if (!selection.ok)
+    return { ok: false, issues: selection.paths };
+  const decoded = decodeSelection({ kind: "json", value: selection.selected });
+  if (!decoded.ok)
+    return decoded;
+  const data = [];
+  for (const [index, typed] of decoded.data.entries()) {
+    const raw = structuredClone(selection.selected[index]);
+    if (!isRecord(raw))
+      return { ok: false, issues: [`[${index}]`] };
+    data.push({ ...typed, raw });
+  }
+  return decoded.warnings === undefined ? { ok: true, data } : { ok: true, data, warnings: decoded.warnings };
+};
+var annotationsListForCall = () => {
+  let decode2 = failClosed;
+  return {
+    ...base,
+    buildRequest: (input) => {
+      const parsed = experimentalAnnotationsListInputSchema.safeParse(input);
+      if (!parsed.success)
+        return refuseWithoutFilters();
+      decode2 = decodeSelected(parsed.data);
+      return { ok: true, params: parsed.data };
+    },
+    decode: (body) => decode2(body)
+  };
+};
+
+// src/operations/invoices-list.ts
+import { z as z21 } from "zod";
+var agreementSchema = z21.looseObject({
+  acordados: z21.array(z21.unknown()).optional().nullable(),
+  cobrados: z21.array(z21.unknown()).optional().nullable()
+});
+var invoiceSchema = z21.looseObject({
+  id: z21.number(),
+  status: z21.string().optional().nullable(),
+  valor: z21.number().optional().nullable(),
+  dataVencimento: z21.string().optional().nullable(),
+  clienteNome: z21.string().optional().nullable(),
+  clienteCpfcnpj: z21.string().optional().nullable(),
+  clienteContrato: z21.number().optional().nullable(),
+  portador: z21.string().optional().nullable(),
+  numeroDocumento: z21.union([z21.number(), z21.string()]).optional().nullable(),
+  nossoNumero: z21.string().optional().nullable(),
+  link: z21.string().optional().nullable(),
+  link_cobranca: z21.string().optional().nullable(),
+  valorDesconto: z21.number().optional().nullable(),
+  valorCorrigido: z21.number().optional().nullable(),
+  valorPago: z21.number().optional().nullable(),
+  valorPagoParcial: z21.number().optional().nullable(),
+  codigoBarras: z21.string().optional().nullable(),
+  linhaDigitavel: z21.string().optional().nullable(),
+  codigoPix: z21.string().optional().nullable(),
+  dataEmissao: z21.string().optional().nullable(),
+  dataPagamento: z21.string().optional().nullable(),
+  dataCancelamento: z21.string().optional().nullable(),
+  demonstrativo: z21.string().optional().nullable(),
+  acordoPagamento: agreementSchema.optional().nullable(),
+  formaPagamento: z21.string().optional().nullable(),
+  usuario_baixa: z21.string().optional().nullable()
+});
+var pageSchema2 = z21.looseObject({
+  paginacao: z21.looseObject({
+    offset: z21.number().optional().nullable(),
+    limit: z21.number().optional().nullable(),
+    parcial: z21.number().optional().nullable(),
+    total: z21.number()
   }),
-  titulos: z13.array(invoiceSchema)
+  titulos: z21.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 = {
+var pageInvariants2 = ["paginacao", "paginacao.total", "titulos", "titulos[].id"];
+var invoicesListInputSchema = z21.strictObject({
+  offset: z21.number().int().nonnegative().optional(),
+  limit: z21.number().int().nonnegative().optional(),
+  titulo_id: z21.number().int().optional(),
+  cliente_id: customerIdSchema.int().optional(),
+  cpfcnpj: z21.string().optional(),
+  contrato: z21.number().int().optional(),
+  status: z21.enum(["abertos", "pagos", "cancelados"]).optional(),
+  portador: z21.number().int().optional(),
+  ordenar: z21.enum(["data_documento", "data_vencimento", "data_pagamento"]).optional(),
+  ordenar_ordem: z21.enum(["asc", "desc"]).optional(),
+  empresa_cnpj: z21.string().optional(),
+  tipo_pessoa: z21.enum(["F", "J", "E", "EJ"]).optional(),
+  data_vencimento_inicio: z21.string().optional(),
+  data_vencimento_fim: z21.string().optional(),
+  data_pagamento_inicio: z21.string().optional(),
+  data_pagamento_fim: z21.string().optional(),
+  data_cancelamento_inicio: z21.string().optional(),
+  data_cancelamento_fim: z21.string().optional(),
+  data_acordo_inicio: z21.string().optional(),
+  data_acordo_fim: z21.string().optional()
+});
+var buildRequest18 = (input) => {
+  const parsed = invoicesListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid invoices.list input" };
+  return { ok: true, params: parsed.data };
+};
+var invoicesListSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["cpfcnpj"] }],
+  output: [
+    {
+      path: "titulos[]",
+      secretKeys: [],
+      personalKeys: [
+        "clienteNome",
+        "clienteCpfcnpj",
+        "demonstrativo",
+        "link",
+        "link_cobranca",
+        "codigoPix",
+        "usuario_baixa"
+      ]
+    }
+  ]
+};
+var invoicesList = {
+  name: "invoices.list",
   method: "POST",
-  path: "/api/ura/titulos/",
-  schema: listInvoicesSchema,
-  keyFields: listInvoicesKeyFields,
-  itemPath: invoiceItemPath,
-  secretKeys: invoiceSecretKeys,
-  personalKeys: invoicePersonalKeys
+  pathTemplate: "/api/ura/titulos/",
+  encoding: "json",
+  buildRequest: buildRequest18,
+  repeatable: true,
+  decode: tolerantDecoder(pageSchema2, pageInvariants2),
+  sensitivity: invoicesListSensitivity
 };
 
-// src/endpoints/ura/list-nas.ts
-import { z as z14 } from "zod";
-var nasPopSchema = z14.object({
-  id: z14.number().optional().nullable(),
-  cidade: z14.string().optional().nullable(),
-  uf: z14.string().optional().nullable(),
-  codigo_ibge: z14.number().optional().nullable(),
-  ativo: z14.boolean().optional().nullable()
-});
-var nasSchema = z14.object({
-  id: z14.number(),
-  descricao: z14.string(),
-  identificador: z14.string(),
-  endereco_ip: z14.string().optional().nullable(),
-  ativo: z14.boolean().optional().nullable(),
-  pops: z14.array(nasPopSchema).optional().nullable()
-});
-var listNasSchema = z14.array(nasSchema);
-var listNasKeyFields = ["[].id", "[].descricao", "[].identificador"];
-var nasItemPath = "[]";
-var nasSecretKeys = ["endereco_ip"];
-var nasPersonalKeys = [];
-var listNasDefinition = {
+// src/operations/occurrences-create.ts
+import { z as z22 } from "zod";
+var id4 = z22.number().int().nonnegative();
+var flag = z22.union([z22.literal(0), z22.literal(1)]);
+var occurrencesCreateInputSchema = z22.strictObject({
+  contrato: z22.number().int().positive(),
+  conteudo: z22.string().optional(),
+  conteudolimpo: flag.optional(),
+  observacao: z22.string().optional(),
+  ocorrenciatipo: id4.optional(),
+  tipoclassificacoes: z22.array(id4).optional(),
+  metodo: id4.optional(),
+  setor: id4.optional(),
+  usuario: z22.string().optional(),
+  responsaveloc: z22.string().optional(),
+  contato_nome: z22.string().optional(),
+  contato_telefone: z22.string().optional(),
+  desativa_os: flag.optional(),
+  status_encerrado: flag.optional(),
+  notificar_cliente: flag.optional(),
+  motivoos: id4.optional(),
+  motivoclassificacoes: z22.array(id4).optional(),
+  responsavel: z22.string().optional(),
+  tecnicos: z22.array(z22.string()).optional(),
+  data_hora_agendamento: z22.string().optional(),
+  sms_tecnico: flag.optional(),
+  tipo_servico: z22.enum(["internet", "telefonia", "tv", "multimidia", "generico"]).optional(),
+  servico_id: id4.optional(),
+  empresa_id: id4.optional()
+});
+var buildRequest19 = (input) => {
+  const parsed = occurrencesCreateInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid occurrences.create input" };
+  return { ok: true, params: parsed.data };
+};
+var detectRefusal = (body) => body.kind === "json" && isRecord(body.value) && body.value.status === 0 ? {} : undefined;
+var openedSchema = z22.looseObject({
+  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 openedInvariants = ["status", "protocolo", "id"];
+var occurrencesCreateSensitivity = {
+  input: [
+    {
+      path: "",
+      secretKeys: [],
+      personalKeys: [
+        "conteudo",
+        "observacao",
+        "contato_nome",
+        "contato_telefone",
+        "usuario",
+        "responsaveloc",
+        "responsavel",
+        "tecnicos"
+      ]
+    }
+  ],
+  output: [{ path: "", secretKeys: [], personalKeys: ["razaoSocial", "cpfCnpj"] }]
+};
+var occurrencesCreate = {
+  name: "occurrences.create",
   method: "POST",
-  path: "/api/ura/nas/list/",
-  schema: listNasSchema,
-  keyFields: listNasKeyFields,
-  itemPath: nasItemPath,
-  secretKeys: nasSecretKeys,
-  personalKeys: nasPersonalKeys
+  pathTemplate: "/api/ura/chamado/",
+  encoding: "json",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest19,
+  detectRefusal,
+  decode: tolerantDecoder(openedSchema, openedInvariants),
+  sensitivity: occurrencesCreateSensitivity
 };
 
-// src/endpoints/ura/list-occurrence-methods.ts
-import { z as z15 } from "zod";
-var occurrenceMethodSchema = z15.object({
-  codigo: z15.number(),
-  descricao: z15.string()
-});
-var listOccurrenceMethodsSchema = z15.array(occurrenceMethodSchema);
-var listOccurrenceMethodsKeyFields = ["[].codigo", "[].descricao"];
-var occurrenceMethodItemPath = "[]";
-var occurrenceMethodSecretKeys = [];
-var occurrenceMethodPersonalKeys = [];
-var listOccurrenceMethodsDefinition = {
+// src/operations/occurrences-list-methods.ts
+import { z as z23 } from "zod";
+var occurrenceMethodSchema = z23.looseObject({
+  codigo: z23.number(),
+  descricao: z23.string().optional().nullable()
+});
+var occurrenceMethodsSchema = z23.array(occurrenceMethodSchema);
+var occurrenceMethodsInvariants = ["[].codigo"];
+var buildRequest20 = () => ({ ok: true });
+var occurrencesListMethodsSensitivity = { input: [], output: [] };
+var occurrencesListMethods = {
+  name: "occurrences.listMethods",
   method: "GET",
-  path: "/api/ura/ocorrencia/metodo/list/",
-  schema: listOccurrenceMethodsSchema,
-  keyFields: listOccurrenceMethodsKeyFields,
-  itemPath: occurrenceMethodItemPath,
-  secretKeys: occurrenceMethodSecretKeys,
-  personalKeys: occurrenceMethodPersonalKeys
+  pathTemplate: "/api/ura/ocorrencia/metodo/list/",
+  encoding: "json",
+  buildRequest: buildRequest20,
+  repeatable: true,
+  decode: tolerantDecoder(occurrenceMethodsSchema, occurrenceMethodsInvariants),
+  sensitivity: occurrencesListMethodsSensitivity
 };
 
-// src/endpoints/ura/list-payment-carriers.ts
-import { z as z16 } from "zod";
-var paymentCarrierSchema = z16.object({
-  id: z16.number(),
-  descricao: z16.string(),
-  codigo_banco: z16.string().optional().nullable()
-});
-var listPaymentCarriersSchema = z16.array(paymentCarrierSchema);
-var listPaymentCarriersKeyFields = ["[].id", "[].descricao"];
-var paymentCarrierItemPath = "[]";
-var paymentCarrierSecretKeys = [];
-var paymentCarrierPersonalKeys = [];
-var listPaymentCarriersDefinition = {
+// src/operations/occurrences-list-types.ts
+import { z as z24 } from "zod";
+var occurrenceTypeSchema = z24.looseObject({
+  id: z24.number(),
+  codigo: z24.number(),
+  descricao: z24.string().optional().nullable(),
+  ativo: z24.boolean().optional().nullable(),
+  classificacoes: z24.array(z24.unknown()).optional().nullable(),
+  classificacoes_obrigatorio: z24.boolean().optional().nullable(),
+  setores: z24.array(z24.unknown()).optional().nullable(),
+  classificacoes_obrigatorio_encerramento: z24.boolean().optional().nullable()
+});
+var occurrenceTypesSchema = z24.array(occurrenceTypeSchema);
+var occurrenceTypesInvariants = ["[].id", "[].codigo"];
+var buildRequest21 = () => ({ ok: true });
+var occurrencesListTypesSensitivity = { input: [], output: [] };
+var occurrencesListTypes = {
+  name: "occurrences.listTypes",
   method: "GET",
-  path: "/api/ura/portador/",
-  schema: listPaymentCarriersSchema,
-  keyFields: listPaymentCarriersKeyFields,
-  itemPath: paymentCarrierItemPath,
-  secretKeys: paymentCarrierSecretKeys,
-  personalKeys: paymentCarrierPersonalKeys
+  pathTemplate: "/api/os/ocorrencia/tipo/list/",
+  encoding: "json",
+  buildRequest: buildRequest21,
+  repeatable: true,
+  decode: tolerantDecoder(occurrenceTypesSchema, occurrenceTypesInvariants),
+  sensitivity: occurrencesListTypesSensitivity
 };
 
-// src/endpoints/ura/list-plans.ts
-import { z as z17 } from "zod";
-var planPopSchema = z17.object({
-  id: z17.number().optional().nullable(),
-  uf: z17.string().optional().nullable(),
-  pop: z17.string().optional().nullable()
-});
-var planSchema = z17.object({
-  id: z17.number(),
-  descricao: z17.string(),
-  preco: z17.number(),
-  ativo: z17.boolean(),
-  grupo: z17.string().optional().nullable(),
-  tipo: z17.string().optional().nullable(),
-  pos_pago: z17.boolean().optional().nullable(),
-  desconto: z17.number().optional().nullable(),
-  desconto_venc: z17.number().optional().nullable(),
-  desconto_venc_modo: z17.string().optional().nullable(),
-  valor_desconto_temporario: z17.number().optional().nullable(),
-  desconto_temporario_modo: z17.string().optional().nullable(),
-  desconto_temporario_quantidade: z17.number().optional().nullable(),
-  descricao_desconto_temporario: z17.string().optional().nullable(),
-  desconto_temporario_proporcional: z17.boolean().optional().nullable(),
-  observacao: z17.string().optional().nullable(),
-  instalacao_qtd_parcelas: z17.number().optional().nullable(),
-  instalacao_valor: z17.number().optional().nullable(),
-  instalacao_desconto_max: z17.number().optional().nullable(),
-  instalacao_desconto_min: z17.number().optional().nullable(),
-  disponivel_pre_cadastro: z17.boolean().optional().nullable(),
-  disponivel_pre_cadastro_publico: z17.boolean().optional().nullable(),
-  data_validade: z17.string().optional().nullable(),
-  pops: z17.array(planPopSchema).optional().nullable(),
-  auto_bloqueio: z17.boolean().optional().nullable(),
-  dias_bloqueio_pos_venc: z17.number().optional().nullable(),
-  dias_bloqueio_aviso: z17.number().optional().nullable(),
-  dias_reducao_velocidade: z17.number().optional().nullable(),
-  download: z17.number().optional().nullable(),
-  upload: z17.number().optional().nullable(),
-  trafego_mensal: z17.number().optional().nullable(),
-  contabilizacao_trafego_mensal: z17.string().optional().nullable(),
-  trafego_excedente_acao: z17.string().optional().nullable(),
-  valor_trafego_excedido: z17.number().optional().nullable(),
-  duplicacao_noturna: z17.boolean().optional().nullable(),
-  inicio_duplicacao_noturna: z17.string().optional().nullable(),
-  fim_duplicacao_noturna: z17.string().optional().nullable(),
-  modo_velocidade_reduzida: z17.string().optional().nullable(),
-  download_red_financeiro: z17.number().optional().nullable(),
-  upload_red_financeiro: z17.number().optional().nullable(),
-  modo_velocidade_red_franquia: z17.string().optional().nullable(),
-  download_red_franquia: z17.number().optional().nullable(),
-  upload_red_franquia: z17.number().optional().nullable(),
-  combo: z17.array(z17.object({})).optional().nullable(),
-  qtd_servicos: z17.number().optional().nullable()
-});
-var listPlansSchema = z17.object({
-  planos: z17.array(planSchema),
-  total_planos: z17.number().optional().nullable(),
-  total_qtd_servicos: z17.number().optional().nullable()
-});
-var listPlansKeyFields = [
-  "planos",
-  "planos[].id",
-  "planos[].descricao",
-  "planos[].preco",
-  "planos[].ativo"
-];
-var planItemPath = "planos[]";
-var planSecretKeys = [];
-var planPersonalKeys = [];
-var listPlansDefinition = {
+// src/operations/plans-list.ts
+import { z as z25 } from "zod";
+var popSchema2 = z25.looseObject({
+  id: z25.number().optional().nullable(),
+  uf: z25.string().optional().nullable(),
+  pop: z25.string().optional().nullable()
+});
+var planSchema2 = z25.looseObject({
+  id: z25.number().brand(),
+  descricao: z25.string().optional().nullable(),
+  preco: z25.number().optional().nullable(),
+  ativo: z25.boolean().optional().nullable(),
+  grupo: z25.string().optional().nullable(),
+  tipo: z25.string().optional().nullable(),
+  pos_pago: z25.boolean().optional().nullable(),
+  desconto: z25.number().optional().nullable(),
+  desconto_venc: z25.number().optional().nullable(),
+  desconto_venc_modo: z25.string().optional().nullable(),
+  valor_desconto_temporario: z25.number().optional().nullable(),
+  desconto_temporario_modo: z25.string().optional().nullable(),
+  desconto_temporario_quantidade: z25.number().optional().nullable(),
+  descricao_desconto_temporario: z25.string().optional().nullable(),
+  desconto_temporario_proporcional: z25.boolean().optional().nullable(),
+  observacao: z25.string().optional().nullable(),
+  instalacao_qtd_parcelas: z25.number().optional().nullable(),
+  instalacao_valor: z25.number().optional().nullable(),
+  instalacao_desconto_max: z25.number().optional().nullable(),
+  instalacao_desconto_min: z25.number().optional().nullable(),
+  disponivel_pre_cadastro: z25.boolean().optional().nullable(),
+  disponivel_pre_cadastro_publico: z25.boolean().optional().nullable(),
+  data_validade: z25.string().optional().nullable(),
+  pops: z25.array(popSchema2).optional().nullable(),
+  auto_bloqueio: z25.boolean().optional().nullable(),
+  dias_bloqueio_pos_venc: z25.number().optional().nullable(),
+  dias_bloqueio_aviso: z25.number().optional().nullable(),
+  dias_reducao_velocidade: z25.number().optional().nullable(),
+  download: z25.number().optional().nullable(),
+  upload: z25.number().optional().nullable(),
+  trafego_mensal: z25.number().optional().nullable(),
+  contabilizacao_trafego_mensal: z25.string().optional().nullable(),
+  trafego_excedente_acao: z25.string().optional().nullable(),
+  valor_trafego_excedido: z25.number().optional().nullable(),
+  duplicacao_noturna: z25.boolean().optional().nullable(),
+  inicio_duplicacao_noturna: z25.string().optional().nullable(),
+  fim_duplicacao_noturna: z25.string().optional().nullable(),
+  modo_velocidade_reduzida: z25.string().optional().nullable(),
+  download_red_financeiro: z25.number().optional().nullable(),
+  upload_red_financeiro: z25.number().optional().nullable(),
+  modo_velocidade_red_franquia: z25.string().optional().nullable(),
+  download_red_franquia: z25.number().optional().nullable(),
+  upload_red_franquia: z25.number().optional().nullable(),
+  combo: z25.array(z25.unknown()).optional().nullable(),
+  qtd_servicos: z25.number().optional().nullable()
+});
+var catalogSchema = z25.looseObject({
+  planos: z25.array(planSchema2),
+  total_planos: z25.number().optional().nullable(),
+  total_qtd_servicos: z25.number().optional().nullable()
+});
+var catalogInvariants = ["planos", "planos[].id"];
+var buildRequest22 = () => ({ ok: true });
+var plansListSensitivity = { input: [], output: [] };
+var plansList = {
+  name: "plans.list",
   method: "GET",
-  path: "/api/ura/consultaplano/",
-  schema: listPlansSchema,
-  keyFields: listPlansKeyFields,
-  itemPath: planItemPath,
-  secretKeys: planSecretKeys,
-  personalKeys: planPersonalKeys
+  pathTemplate: "/api/ura/consultaplano/",
+  encoding: "json",
+  buildRequest: buildRequest22,
+  repeatable: true,
+  decode: tolerantDecoder(catalogSchema, catalogInvariants),
+  sensitivity: plansListSensitivity
 };
 
-// src/endpoints/ura/list-pops.ts
-import { z as z18 } from "zod";
-var popSchema = z18.object({
-  id: z18.number(),
-  pop: z18.string()
-});
-var listPopsSchema = z18.array(popSchema);
-var listPopsKeyFields = ["[].id", "[].pop"];
-var popItemPath = "[]";
-var popSecretKeys = [];
-var popPersonalKeys = [];
-var listPopsDefinition = {
+// src/operations/pre-registrations-create.ts
+import { z as z26 } from "zod";
+var id5 = z26.number().int().nonnegative();
+var amount2 = z26.number().nonnegative();
+var commonShape2 = {
+  nome: nonBlank,
+  cpfcnpj: z26.string().optional(),
+  ...addressShape,
+  logradouro: nonBlank,
+  email: z26.string().optional(),
+  celular: z26.string().optional(),
+  datanasc: z26.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  observacao: z26.string().optional(),
+  usuariocad_id: id5.optional(),
+  precadastro_ativar: z26.literal(1).optional(),
+  pop_id: id5.optional(),
+  portador_id: id5.optional(),
+  nas_id: id5.optional(),
+  plano_id: id5.brand().optional(),
+  vencimento_id: id5.optional(),
+  formacobranca_id: id5.optional(),
+  fidelidade_id: id5.optional(),
+  login: z26.string().optional(),
+  senha: z26.string().optional(),
+  central_senha: z26.string().optional(),
+  modoaquisicao: z26.union([z26.literal(0), z26.literal(1)]).optional(),
+  servicodesc: z26.string().optional(),
+  midia_id: id5.optional(),
+  vendedor_id: id5.optional(),
+  tecnico_id: id5.optional(),
+  os_instalacao: z26.literal(1).optional(),
+  instalacao_preco: amount2.optional(),
+  instalacao_desconto: amount2.optional(),
+  instalacao_entrada: amount2.optional(),
+  instalacao_quantidade_parcelas: id5.optional(),
+  instalacao_entrada_forma: id5.optional(),
+  instalacao_parcela_forma: id5.optional()
+};
+var preRegistrationsCreateInputSchema = z26.discriminatedUnion("personType", [
+  z26.strictObject({
+    personType: z26.literal("F"),
+    ...commonShape2,
+    rg: z26.string().optional(),
+    rg_emissor: z26.string().optional(),
+    nomepai: z26.string().optional(),
+    nomemae: z26.string().optional(),
+    nacionalidade: z26.string().optional(),
+    naturalidade: z26.string().optional(),
+    estadocivil: z26.enum(["S", "C", "D", "V"]).optional(),
+    sexo: z26.enum(["M", "F"]).optional(),
+    profissao: z26.string().optional()
+  }),
+  z26.strictObject({
+    personType: z26.literal("J"),
+    ...commonShape2,
+    nomefantasia: z26.string().optional(),
+    respempresa: z26.string().optional(),
+    respcpf: z26.string().optional()
+  })
+]);
+var buildRequest23 = (input) => {
+  const parsed = preRegistrationsCreateInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid preRegistrations.create input" };
+  const {
+    personType,
+    logradouro,
+    numero,
+    complemento,
+    bairro,
+    cidade,
+    cep,
+    uf,
+    pais,
+    pontoreferencia,
+    map_ll,
+    condominio,
+    ...fields
+  } = parsed.data;
+  const address = {
+    logradouro,
+    numero,
+    complemento,
+    bairro,
+    cidade,
+    cep,
+    uf,
+    pais,
+    pontoreferencia,
+    map_ll,
+    condominio
+  };
+  return {
+    ok: true,
+    pathParams: { personType },
+    params: { ...fields, ...flatAddress(address) }
+  };
+};
+var createdSchema2 = z26.looseObject({ message: z26.string() });
+var createdInvariants2 = ["message"];
+var DOCUMENT_ALREADY_REGISTERED_TEXT = /^já existe um cliente com o cpf informado\.?$/i;
+var documentAlreadyRegistered = errorStringRejection(402, DOCUMENT_ALREADY_REGISTERED_TEXT, "DOCUMENT_ALREADY_REGISTERED");
+var preRegistrationsCreateSensitivity = {
+  input: [
+    {
+      path: "",
+      secretKeys: ["senha", "central_senha", "login"],
+      personalKeys: [
+        "nome",
+        "cpfcnpj",
+        "logradouro",
+        "numero",
+        "complemento",
+        "bairro",
+        "cidade",
+        "cep",
+        "uf",
+        "pais",
+        "pontoreferencia",
+        "map_ll",
+        "condominio",
+        "email",
+        "celular",
+        "datanasc",
+        "observacao",
+        "servicodesc",
+        "rg",
+        "rg_emissor",
+        "nomepai",
+        "nomemae",
+        "nacionalidade",
+        "naturalidade",
+        "estadocivil",
+        "sexo",
+        "profissao",
+        "nomefantasia",
+        "respempresa",
+        "respcpf"
+      ]
+    }
+  ],
+  output: []
+};
+var preRegistrationsCreate = {
+  name: "preRegistrations.create",
   method: "POST",
-  path: "/api/ura/pops/",
-  schema: listPopsSchema,
-  keyFields: listPopsKeyFields,
-  itemPath: popItemPath,
-  secretKeys: popSecretKeys,
-  personalKeys: popPersonalKeys
+  pathTemplate: "/api/precadastro/{personType}",
+  encoding: "form",
+  repeatable: false,
+  write: { knownRejections: [documentAlreadyRegistered] },
+  buildRequest: buildRequest23,
+  decode: tolerantDecoder(createdSchema2, createdInvariants2),
+  sensitivity: preRegistrationsCreateSensitivity
 };
 
-// src/endpoints/ura/list-service-orders.ts
-import { z as z19 } from "zod";
-var serviceOrderSchema = z19.object({
-  id: z19.number(),
-  contrato: z19.number(),
-  status_id: z19.number(),
-  status: z19.string(),
-  tipo_id: z19.number(),
-  data_cadastro: z19.string(),
-  cliente: z19.string().optional().nullable(),
-  contrato_status: z19.string().optional().nullable(),
-  contrato_status_id: z19.number().optional().nullable(),
-  ocorrencia: z19.string().optional().nullable(),
-  hora_cadastro: z19.string().optional().nullable(),
-  data_agendamento: z19.string().optional().nullable(),
-  hora_agendamento: z19.string().optional().nullable(),
-  data_finalizacao: z19.string().optional().nullable(),
-  hora_finalizacao: z19.string().optional().nullable(),
-  tipo: z19.string().optional().nullable(),
-  motivo: z19.string().optional().nullable(),
-  pop: z19.string().optional().nullable(),
-  conteudo: z19.string().optional().nullable(),
-  responsavel: z19.string().optional().nullable(),
-  tecnicos_auxiliares: z19.array(z19.object({})).optional().nullable(),
-  usuario: z19.string().optional().nullable(),
-  usuario_finalizacao: z19.string().optional().nullable(),
-  classificacoes: z19.array(z19.object({})).optional().nullable()
-});
-var listServiceOrdersSchema = z19.object({
-  paginacao: z19.object({
-    offset: z19.number().optional().nullable(),
-    limit: z19.number().optional().nullable(),
-    parcial: z19.number().optional().nullable(),
-    total: z19.number()
+// src/operations/pre-registrations-list-due-days.ts
+import { z as z27 } from "zod";
+var dueDaySchema = z27.looseObject({
+  id: z27.number(),
+  dia: z27.number().optional().nullable()
+});
+var dueDaysSchema = z27.array(dueDaySchema);
+var dueDaysInvariants = ["[].id"];
+var buildRequest24 = () => ({ ok: true });
+var preRegistrationsListDueDaysSensitivity = { input: [], output: [] };
+var preRegistrationsListDueDays = {
+  name: "preRegistrations.listDueDays",
+  method: "POST",
+  pathTemplate: "/api/precadastro/vencimento/list",
+  encoding: "json",
+  buildRequest: buildRequest24,
+  repeatable: true,
+  decode: tolerantDecoder(dueDaysSchema, dueDaysInvariants),
+  sensitivity: preRegistrationsListDueDaysSensitivity
+};
+
+// src/operations/pre-registrations-list-plans.ts
+import { z as z28 } from "zod";
+var gatewaySchema = z28.looseObject({
+  gateway_id: z28.union([z28.string(), z28.number()]).optional().nullable(),
+  id: z28.union([z28.string(), z28.number()]).optional().nullable(),
+  descricao: z28.string().optional().nullable()
+});
+var preRegistrationPlanSchema = z28.looseObject({
+  id: z28.number().brand(),
+  tipo: z28.string().optional().nullable(),
+  valor: z28.number().optional().nullable(),
+  descricao: z28.string().optional().nullable(),
+  observacao: z28.string().optional().nullable(),
+  gateway: gatewaySchema.optional().nullable()
+});
+var preRegistrationPlansSchema = z28.array(preRegistrationPlanSchema);
+var preRegistrationPlansInvariants = ["[].id"];
+var buildRequest25 = () => ({ ok: true });
+var preRegistrationsListPlansSensitivity = { input: [], output: [] };
+var preRegistrationsListPlans = {
+  name: "preRegistrations.listPlans",
+  method: "POST",
+  pathTemplate: "/api/precadastro/plano/list",
+  encoding: "form",
+  buildRequest: buildRequest25,
+  repeatable: true,
+  decode: tolerantDecoder(preRegistrationPlansSchema, preRegistrationPlansInvariants),
+  sensitivity: preRegistrationsListPlansSensitivity
+};
+
+// src/operations/pre-registrations-list-sellers.ts
+import { z as z29 } from "zod";
+var sellerSchema = z29.looseObject({
+  id: z29.number(),
+  nome: z29.string().optional().nullable(),
+  cpf: z29.string().optional().nullable(),
+  email: z29.string().optional().nullable()
+});
+var sellersSchema = z29.array(sellerSchema);
+var sellersInvariants = ["[].id"];
+var buildRequest26 = () => ({ ok: true });
+var preRegistrationsListSellersSensitivity = {
+  input: [],
+  output: [{ path: "[]", secretKeys: [], personalKeys: ["nome", "cpf", "email"] }]
+};
+var preRegistrationsListSellers = {
+  name: "preRegistrations.listSellers",
+  method: "POST",
+  pathTemplate: "/api/precadastro/vendedor/list",
+  encoding: "json",
+  buildRequest: buildRequest26,
+  repeatable: true,
+  decode: tolerantDecoder(sellersSchema, sellersInvariants),
+  sensitivity: preRegistrationsListSellersSensitivity
+};
+
+// src/operations/services-add-tv.ts
+import { z as z30 } from "zod";
+var id6 = z30.number().int().positive();
+var servicesAddTvInputSchema = z30.strictObject({
+  clientecontrato_id: id6,
+  planobase_id: id6.brand(),
+  info_extra: z30.string().optional(),
+  tipo_equipamento: id6.optional(),
+  endereco_id: id6.optional()
+});
+var buildRequest27 = (input) => {
+  const parsed = servicesAddTvInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid services.addTv input" };
+  return { ok: true, params: parsed.data };
+};
+var tvAddedSchema = z30.looseObject({
+  msg: z30.string(),
+  clientecontrato_id: z30.string().optional(),
+  servico_id: z30.number()
+});
+var tvAddedInvariants = ["servico_id", "msg"];
+var CONTRACT_NOT_ACTIVE_TEXT = /^clientecontrato_id: só é possível adicionar serviços em contratos ativos\.?$/i;
+var contractNotActive = singleErrorsEntryRejection(400, CONTRACT_NOT_ACTIVE_TEXT, "CONTRACT_NOT_ACTIVE");
+var servicesAddTvSensitivity = {
+  input: [{ path: "", secretKeys: [], personalKeys: ["info_extra"] }],
+  output: []
+};
+var servicesAddTv = {
+  name: "services.addTv",
+  method: "POST",
+  pathTemplate: "/api/servico/tv",
+  encoding: "form",
+  repeatable: false,
+  write: { knownRejections: [contractNotActive] },
+  buildRequest: buildRequest27,
+  decode: tolerantDecoder(tvAddedSchema, tvAddedInvariants),
+  sensitivity: servicesAddTvSensitivity
+};
+
+// src/operations/services-change-plan.ts
+import { z as z31 } from "zod";
+var id7 = z31.number().int().positive();
+var servicesChangePlanInputSchema = z31.strictObject({
+  servico_id: id7,
+  servico_tipo: id7,
+  plano_id: id7.brand()
+});
+var buildRequest28 = (input) => {
+  const parsed = servicesChangePlanInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid services.changePlan input" };
+  const { servico_id, servico_tipo, plano_id } = parsed.data;
+  return {
+    ok: true,
+    pathParams: { servico_id },
+    params: { servico_tipo, action: "change_plano", plano_id }
+  };
+};
+var planChangedSchema = z31.looseObject({ msg: z31.string() });
+var planChangedInvariants = ["msg"];
+var servicesChangePlanSensitivity = { input: [], output: [] };
+var servicesChangePlan = {
+  name: "services.changePlan",
+  method: "POST",
+  pathTemplate: "/api/suporte/service/update/{servico_id}/",
+  encoding: "form",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest28,
+  decode: tolerantDecoder(planChangedSchema, planChangedInvariants),
+  sensitivity: servicesChangePlanSensitivity
+};
+
+// src/operations/services-remove-tv.ts
+import { z as z32 } from "zod";
+var id8 = z32.number().int().positive();
+var servicesRemoveTvInputSchema = z32.strictObject({
+  servico_id: id8,
+  clientecontrato_id: id8
+});
+var buildRequest29 = (input) => {
+  const parsed = servicesRemoveTvInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid services.removeTv input" };
+  const { servico_id, clientecontrato_id } = parsed.data;
+  return { ok: true, pathParams: { servico_id }, params: { clientecontrato_id } };
+};
+var tvRemovedSchema = z32.looseObject({
+  msg: z32.string(),
+  clientecontrato_id: z32.string().optional(),
+  servico_id: z32.number()
+});
+var tvRemovedInvariants = ["servico_id", "msg"];
+var servicesRemoveTvSensitivity = { input: [], output: [] };
+var servicesRemoveTv = {
+  name: "services.removeTv",
+  method: "DELETE",
+  pathTemplate: "/api/servico/tv/{servico_id}",
+  encoding: "form",
+  repeatable: false,
+  write: {},
+  buildRequest: buildRequest29,
+  decode: tolerantDecoder(tvRemovedSchema, tvRemovedInvariants),
+  sensitivity: servicesRemoveTvSensitivity
+};
+
+// src/operations/work-orders-list.ts
+import { z as z33 } from "zod";
+var workOrderSchema = z33.looseObject({
+  id: z33.number(),
+  contrato: z33.number().optional().nullable(),
+  status_id: z33.number().optional().nullable(),
+  status: z33.string().optional().nullable(),
+  tipo_id: z33.number().optional().nullable(),
+  data_cadastro: z33.string().optional().nullable(),
+  cliente: z33.string().optional().nullable(),
+  contrato_status: z33.string().optional().nullable(),
+  contrato_status_id: z33.number().optional().nullable(),
+  ocorrencia: z33.string().optional().nullable(),
+  hora_cadastro: z33.string().optional().nullable(),
+  data_agendamento: z33.string().optional().nullable(),
+  hora_agendamento: z33.string().optional().nullable(),
+  data_finalizacao: z33.string().optional().nullable(),
+  hora_finalizacao: z33.string().optional().nullable(),
+  tipo: z33.string().optional().nullable(),
+  motivo: z33.string().optional().nullable(),
+  pop: z33.string().optional().nullable(),
+  conteudo: z33.string().optional().nullable(),
+  responsavel: z33.string().optional().nullable(),
+  tecnicos_auxiliares: z33.array(z33.unknown()).optional().nullable(),
+  usuario: z33.string().optional().nullable(),
+  usuario_finalizacao: z33.string().optional().nullable(),
+  classificacoes: z33.array(z33.unknown()).optional().nullable()
+});
+var pageSchema3 = z33.looseObject({
+  paginacao: z33.looseObject({
+    offset: z33.number().optional().nullable(),
+    limit: z33.number().optional().nullable(),
+    parcial: z33.number().optional().nullable(),
+    total: z33.number()
   }),
-  ordens_servicos: z19.array(serviceOrderSchema)
+  ordens_servicos: z33.array(workOrderSchema)
 });
-var listServiceOrdersKeyFields = [
+var pageInvariants3 = [
+  "paginacao",
   "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"
+  "ordens_servicos[].id"
 ];
-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
+var workOrdersListInputSchema = z33.strictObject({
+  offset: z33.number().int().nonnegative().optional(),
+  limit: z33.number().int().nonnegative().optional(),
+  ordem_servico: z33.number().int().optional(),
+  status: z33.number().int().optional(),
+  pop: z33.number().int().optional(),
+  motivo: z33.number().int().optional(),
+  contrato: z33.number().int().optional()
+});
+var buildRequest30 = (input) => {
+  const parsed = workOrdersListInputSchema.safeParse(input);
+  if (!parsed.success)
+    return { ok: false, problem: "invalid workOrders.list input" };
+  return { ok: true, params: parsed.data };
 };
-
-// src/endpoints/ura/lookup-customer.ts
-import { z as z20 } from "zod";
-var contactEntrySchema = z20.object({
-  inscricoes: z20.array(z20.string()).optional().nullable(),
-  tipoContato: z20.string().optional().nullable(),
-  contato: z20.string().optional().nullable()
-});
-var tagSchema = z20.object({
-  color: z20.string().optional().nullable(),
-  font: z20.string().optional().nullable(),
-  tag: z20.string().optional().nullable(),
-  id: z20.number().optional().nullable(),
-  categoria_id: z20.number().optional().nullable()
-});
-var loyaltySchema = z20.object({
-  data_inicio: z20.string().optional().nullable(),
-  descricao: z20.string().optional().nullable(),
-  data_fim: z20.string().optional().nullable()
-});
-var customerContractSchema = z20.object({
-  contratoId: z20.number(),
-  clienteId: z20.number(),
-  contratoStatus: z20.number(),
-  contratoStatusDisplay: z20.string(),
-  contratoValorAberto: z20.number(),
-  contratoTitulosAReceber: z20.number(),
-  cobVencimento: z20.number(),
-  contratoStatusModo: z20.number().optional().nullable(),
-  motivo_status: z20.string().optional().nullable(),
-  dataCadastro: z20.string().optional().nullable(),
-  dataAlteracao: z20.string().optional().nullable(),
-  popId: z20.number().optional().nullable(),
-  popNome: z20.string().optional().nullable(),
-  cobPermuta: z20.boolean().optional().nullable(),
-  cobIsento: z20.number().optional().nullable(),
-  promessasPagamentoMes: z20.number().optional().nullable(),
-  link_quitacao: z20.string().optional().nullable(),
-  planointernet: z20.string().optional().nullable(),
-  fidelidade: loyaltySchema.optional().nullable(),
-  contrato_unificado_principal: z20.number().optional().nullable(),
-  contrato_unificado_filhos: z20.array(z20.number()).optional().nullable(),
-  tags: z20.array(tagSchema).optional().nullable(),
-  anotacoes: z20.array(z20.object({})).optional().nullable(),
-  contratoCentralLogin: z20.string().optional().nullable(),
-  contratoCentralSenha: z20.string().optional().nullable(),
-  servico_login: z20.string().optional().nullable(),
-  servico_senha: z20.string().optional().nullable(),
-  servico_plano: z20.string().optional().nullable(),
-  servico_grupo: z20.string().optional().nullable(),
-  servico_tipo_conexao: z20.string().optional().nullable(),
-  servico_vlan: z20.string().optional().nullable(),
-  servico_mac: z20.string().optional().nullable(),
-  servico_mac2: z20.string().optional().nullable(),
-  servico_wifi_ssid: z20.string().optional().nullable(),
-  servico_wifi_ssid_5: z20.string().optional().nullable(),
-  servico_wifi_password: z20.string().optional().nullable(),
-  servico_wifi_password_5: z20.string().optional().nullable(),
-  servico_wifi_channel: z20.string().optional().nullable(),
-  servico_wifi_channel_5: z20.string().optional().nullable(),
-  razaoSocial: z20.string().optional().nullable(),
-  cpfCnpj: z20.string().optional().nullable(),
-  dataNascimento: z20.string().optional().nullable(),
-  telefones: z20.array(contactEntrySchema).optional().nullable(),
-  telefones_cargos: z20.array(z20.object({})).optional().nullable(),
-  emails: z20.array(contactEntrySchema).optional().nullable(),
-  outros: z20.array(z20.object({})).optional().nullable(),
-  endereco_logradouro: z20.string().optional().nullable(),
-  endereco_numero: z20.number().optional().nullable(),
-  endereco_complemento: z20.string().optional().nullable(),
-  endereco_bairro: z20.string().optional().nullable(),
-  endereco_cidade: z20.string().optional().nullable(),
-  endereco_uf: z20.string().optional().nullable(),
-  endereco_cep: z20.string().optional().nullable(),
-  endereco_pontoreferencia: z20.string().optional().nullable(),
-  endereco_ll: z20.string().optional().nullable()
-});
-var lookupCustomerSchema = z20.object({
-  msg: z20.string().optional().nullable(),
-  contratos: z20.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 = {
+var workOrdersListSensitivity = {
+  input: [],
+  output: [
+    {
+      path: "ordens_servicos[]",
+      secretKeys: [],
+      personalKeys: [
+        "cliente",
+        "conteudo",
+        "responsavel",
+        "tecnicos_auxiliares",
+        "usuario",
+        "usuario_finalizacao"
+      ]
+    }
+  ]
+};
+var workOrdersList = {
+  name: "workOrders.list",
   method: "POST",
-  path: "/api/ura/consultacliente/",
-  schema: lookupCustomerSchema,
-  keyFields: lookupCustomerKeyFields,
-  itemPath: customerContractItemPath,
-  secretKeys: customerContractSecretKeys,
-  personalKeys: customerContractPersonalKeys
+  pathTemplate: "/api/ura/ordemservico/list/",
+  encoding: "json",
+  buildRequest: buildRequest30,
+  repeatable: true,
+  decode: tolerantDecoder(pageSchema3, pageInvariants3),
+  sensitivity: workOrdersListSensitivity
 };
 
-// src/endpoints/ura/open-ticket.ts
-import { z as z21 } from "zod";
-var openTicketSchema = z21.object({
-  status: z21.literal(1),
-  protocolo: z21.string(),
-  id: z21.number(),
-  contratoId: z21.number().optional().nullable(),
-  razaoSocial: z21.string().optional().nullable(),
-  cpfCnpj: z21.string().optional().nullable(),
-  msg: z21.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/operations/work-orders-list-reasons.ts
+import { z as z34 } from "zod";
+var workOrderReasonSchema = z34.looseObject({
+  id: z34.number(),
+  codigo: z34.number(),
+  descricao: z34.string().optional().nullable(),
+  ativo: z34.boolean().optional().nullable(),
+  classificacoes: z34.array(z34.unknown()).optional().nullable(),
+  classificacoes_obrigatorio: z34.boolean().optional().nullable(),
+  setores: z34.array(z34.unknown()).optional().nullable()
+});
+var workOrderReasonsSchema = z34.array(workOrderReasonSchema);
+var workOrderReasonsInvariants = ["[].id", "[].codigo"];
+var buildRequest31 = () => ({ ok: true });
+var workOrdersListReasonsSensitivity = { input: [], output: [] };
+var workOrdersListReasons = {
+  name: "workOrders.listReasons",
+  method: "GET",
+  pathTemplate: "/api/os/ocorrencia/motivo/list/",
+  encoding: "json",
+  buildRequest: buildRequest31,
+  repeatable: true,
+  decode: tolerantDecoder(workOrderReasonsSchema, workOrderReasonsInvariants),
+  sensitivity: workOrdersListReasonsSensitivity
 };
 
-// src/client.ts
-var createSgpClient = (config) => ({
-  ura: {
-    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/raw-request.ts
+var METHODS = ["GET", "POST", "PUT", "DELETE"];
+var ENCODINGS = ["json", "form"];
+var isAllowedPath = (path, base2) => {
+  if (typeof path !== "string" || !path.startsWith("/api/"))
+    return false;
+  if (path.includes("//") || path.includes("%"))
+    return false;
+  return new URL(path, base2).pathname === path;
+};
+var snapshotOf2 = (body, method, encoding) => {
+  try {
+    if (!isRecord(body))
+      return;
+    const copy = encoding === "json" && method !== "GET" ? JSON.parse(JSON.stringify(body)) : Object.fromEntries(Object.entries(body));
+    return isRecord(copy) ? copy : undefined;
+  } catch {
+    return;
+  }
+};
+var readFields = (input) => {
+  try {
+    if (!isRecord(input))
+      return;
+    const { method, path, body, encoding = "json" } = input;
+    return { method, path, body, encoding };
+  } catch {
+    return;
+  }
+};
+var ANNOTATIONS_ROUTE = "/api/ura/cliente/anotacao/list";
+var isAnnotationsRoute = (path) => path.toLowerCase().split(";")[0]?.startsWith(ANNOTATIONS_ROUTE) === true;
+var ANNOTATIONS_ROUTE_MESSAGE = "This route answers with other customers' notes; use experimental.annotations.list. Nothing was sent.";
+var check = (base2, input) => {
+  const fields = readFields(input);
+  if (fields === undefined)
+    return;
+  const { method, path, body, encoding } = fields;
+  const knownMethod = METHODS.find((candidate) => candidate === method);
+  const knownEncoding = ENCODINGS.find((candidate) => candidate === encoding);
+  if (knownMethod === undefined || knownEncoding === undefined)
+    return;
+  if (!isAllowedPath(path, base2))
+    return;
+  if (body === undefined) {
+    return { method: knownMethod, path, body, encoding: knownEncoding };
+  }
+  const snapshot = snapshotOf2(body, knownMethod, knownEncoding);
+  if (snapshot === undefined)
+    return;
+  return { method: knownMethod, path, body: snapshot, encoding: knownEncoding };
+};
+var rawDefinition = (checked) => ({
+  name: "request",
+  method: checked.method,
+  pathTemplate: checked.path,
+  omitPathFromHooks: true,
+  encoding: checked.encoding,
+  sensitivity: { input: [], output: [] },
+  write: { effectUnknownAfterSend: true },
+  buildRequest: () => ({ ok: true, params: checked.body }),
+  decode: (body) => {
+    switch (body.kind) {
+      case "json":
+        return { ok: true, data: body.value };
+      case "text":
+        return { ok: true, data: body.text };
+      case "empty":
+        return { ok: true, data: undefined };
+      case "unavailable":
+      case "withheld":
+        return { ok: false, issues: ["body"] };
+    }
   }
 });
+var refusal = (error) => ({
+  ok: false,
+  error,
+  response: null,
+  attempts: 0
+});
+var executeRawRequest = async (config, input, options) => {
+  const checked = check(config.origin, input);
+  if (checked === undefined) {
+    return refusal(buildError("INVALID_INPUT", "request", { effect: "none" }));
+  }
+  if (isAnnotationsRoute(checked.path)) {
+    const error = buildError("ROUTE_NOT_ALLOWED", "request", { effect: "none" });
+    return refusal({ ...error, message: ANNOTATIONS_ROUTE_MESSAGE });
+  }
+  return await execute(config, rawDefinition(checked), undefined, options);
+};
+
+// src/client.ts
+var createSgpClient = (options) => {
+  const config = resolveConfig(options);
+  return {
+    request: (input, callOptions) => executeRawRequest(config, input, callOptions),
+    catalogs: {
+      listPops: (callOptions) => execute(config, catalogsListPops, undefined, callOptions),
+      listNas: (callOptions) => execute(config, catalogsListNas, undefined, callOptions),
+      listBillingProfiles: (callOptions) => execute(config, catalogsListBillingProfiles, undefined, callOptions)
+    },
+    contracts: {
+      list: (input = {}, callOptions) => execute(config, contractsList, input, callOptions),
+      update: (input, callOptions) => execute(config, contractsUpdate, input, callOptions),
+      listStatusReasons: (callOptions) => execute(config, contractsListStatusReasons, undefined, callOptions),
+      updateStatus: (input, callOptions) => execute(config, contractsUpdateStatus, input, callOptions)
+    },
+    coverage: {
+      check: (input, callOptions) => execute(config, coverageCheck, input, callOptions)
+    },
+    crm: {
+      customers: {
+        create: (input, callOptions) => execute(config, crmCustomersCreate, input, callOptions),
+        updateStatus: (input, callOptions) => execute(config, crmCustomersUpdateStatus, input, callOptions)
+      },
+      contracts: {
+        create: (input, callOptions) => execute(config, crmContractsCreate, input, callOptions),
+        createByCpfCnpj: (input, callOptions) => execute(config, crmContractsCreateByCpfCnpj, input, callOptions),
+        list: (input, callOptions) => execute(config, crmContractsList, input, callOptions)
+      }
+    },
+    customers: {
+      list: (input = {}, callOptions) => execute(config, customersList, input, callOptions),
+      search: (input, callOptions) => execute(config, customersSearch, input, callOptions)
+    },
+    experimental: {
+      annotations: {
+        list: (input, callOptions) => execute(config, annotationsListForCall(), input, callOptions)
+      }
+    },
+    documents: {
+      add: (input, callOptions) => execute(config, documentsAdd, input, callOptions),
+      list: (input, callOptions) => execute(config, documentsList, input, callOptions)
+    },
+    invoices: {
+      list: (input = {}, callOptions) => execute(config, invoicesList, input, callOptions)
+    },
+    occurrences: {
+      create: (input, callOptions) => execute(config, occurrencesCreate, input, callOptions),
+      listTypes: (callOptions) => execute(config, occurrencesListTypes, undefined, callOptions),
+      listMethods: (callOptions) => execute(config, occurrencesListMethods, undefined, callOptions)
+    },
+    plans: {
+      list: (callOptions) => execute(config, plansList, undefined, callOptions)
+    },
+    preRegistrations: {
+      create: (input, callOptions) => execute(config, preRegistrationsCreate, input, callOptions),
+      listPlans: (callOptions) => execute(config, preRegistrationsListPlans, undefined, callOptions),
+      listDueDays: (callOptions) => execute(config, preRegistrationsListDueDays, undefined, callOptions),
+      listSellers: (callOptions) => execute(config, preRegistrationsListSellers, undefined, callOptions)
+    },
+    workOrders: {
+      list: (input = {}, callOptions) => execute(config, workOrdersList, input, callOptions),
+      listReasons: (callOptions) => execute(config, workOrdersListReasons, undefined, callOptions)
+    },
+    services: {
+      addTv: (input, callOptions) => execute(config, servicesAddTv, input, callOptions),
+      changePlan: (input, callOptions) => execute(config, servicesChangePlan, input, callOptions),
+      removeTv: (input, callOptions) => execute(config, servicesRemoveTv, input, callOptions)
+    }
+  };
+};
+// src/constants.ts
+var ACQUISITION_MODE = { owned: 0, loan: 1 };
+var BILLING_METHOD = {
+  boleto: 1,
+  automaticDebit: 2,
+  booklet: 3,
+  recurringCharge: 4,
+  pix: 6
+};
+var CONTRACT_STATUS = {
+  active: 1,
+  inactive: 2,
+  canceled: 3,
+  suspended: 4,
+  technicalInfeasibility: 5,
+  new: 6,
+  activeReducedSpeed: 7
+};
+var SERVICE_TYPE = { internet: 1 };
+var CRM_STATUS = {
+  underAnalysis: 1,
+  approved: 2,
+  rejected: 3,
+  awaitingContact: 4,
+  tryingContact: 5,
+  contractMadeInSgp: 6,
+  technicalInfeasibility: 7,
+  contractInProspecting: 8,
+  rejectedCreditBureau: 9,
+  technicalFeasibilityAnalysis: 10
+};
+// src/operation-sensitivity.ts
+var shippedOperations = [
+  customersList,
+  customersSearch,
+  preRegistrationsCreate,
+  contractsUpdateStatus,
+  contractsUpdate,
+  contractsList,
+  invoicesList,
+  plansList,
+  workOrdersList,
+  servicesChangePlan,
+  servicesAddTv,
+  servicesRemoveTv,
+  experimentalAnnotationsList,
+  catalogsListPops,
+  catalogsListNas,
+  catalogsListBillingProfiles,
+  occurrencesListTypes,
+  occurrencesListMethods,
+  workOrdersListReasons,
+  preRegistrationsListPlans,
+  preRegistrationsListDueDays,
+  preRegistrationsListSellers,
+  contractsListStatusReasons,
+  documentsList,
+  coverageCheck,
+  crmCustomersCreate,
+  crmCustomersUpdateStatus,
+  crmContractsCreate,
+  crmContractsCreateByCpfCnpj,
+  crmContractsList,
+  occurrencesCreate,
+  documentsAdd
+];
+var getSensitivity = (operation) => {
+  const found = shippedOperations.find((definition) => definition.name === operation);
+  if (found === undefined)
+    throw new Error(`unknown operation: ${operation}`);
+  return found.sensitivity;
+};
 // src/sensitivity.ts
-var omitSensitive = (obj, keys) => {
-  const copy = { ...obj };
-  for (const key of keys)
-    Reflect.deleteProperty(copy, key);
-  return copy;
+var ITEMS = "[]";
+var RAW_RESPONSE_KEYS = new Set(["body", "headers"]);
+var EVERYTHING = { all: true, children: new Map };
+var SEGMENT = /^([^.[\]]*)((?:\[\])*)$/;
+var parsePath = (path) => {
+  const steps = [];
+  for (const segment of path.split(".")) {
+    const parts = SEGMENT.exec(segment);
+    if (parts === null)
+      return;
+    const [, name = "", items = ""] = parts;
+    if (name === "" && items === "")
+      return;
+    if (name !== "")
+      steps.push(name);
+    for (let index = 0;index < items.length; index += ITEMS.length)
+      steps.push(ITEMS);
+  }
+  return steps;
+};
+var buildAllowed = (allowlist) => {
+  const root = { all: false, children: new Map };
+  for (const path of allowlist) {
+    const steps = parsePath(path);
+    if (steps === undefined)
+      continue;
+    let node = root;
+    for (const step of steps) {
+      let next = node.children.get(step);
+      if (next === undefined) {
+        next = { all: false, children: new Map };
+        node.children.set(step, next);
+      }
+      node = next;
+    }
+    node.all = true;
+  }
+  const response = root.children.get("response");
+  if (response?.all)
+    response.withheld = RAW_RESPONSE_KEYS;
+  return root;
+};
+var isPlainObject = (value) => {
+  if (!isRecord(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var setOwn2 = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+};
+var project = (value, allowed, ancestors) => {
+  if (typeof value !== "object" || value === null) {
+    const isJson = value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    return isJson && allowed.all ? value : undefined;
+  }
+  if (ancestors.has(value))
+    return;
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const itemAllowed = allowed.all ? EVERYTHING : allowed.children.get(ITEMS);
+      if (itemAllowed === undefined)
+        return;
+      const items = [];
+      for (const item of value) {
+        const projected = project(item, itemAllowed, ancestors);
+        if (projected !== undefined)
+          items.push(projected);
+      }
+      return items;
+    }
+    if (!isPlainObject(value))
+      return;
+    const output = {};
+    for (const key of Object.keys(value)) {
+      const named = allowed.children.get(key);
+      const child = allowed.all && !allowed.withheld?.has(key) ? EVERYTHING : named;
+      if (child === undefined || key === ITEMS)
+        continue;
+      const projected = project(value[key], child, ancestors);
+      if (projected !== undefined)
+        setOwn2(output, key, projected);
+    }
+    return output;
+  } finally {
+    ancestors.delete(value);
+  }
+};
+var pick = (source, allowlist) => project(source, buildAllowed(allowlist), new Set) ?? {};
+var SAFE_LOG_PATHS = [
+  "ok",
+  "attempts",
+  "diagnostics",
+  "warnings",
+  "response.status",
+  "error.code",
+  "error.message",
+  "error.operation",
+  "error.reason",
+  "error.effect",
+  "error.issues",
+  "error.sgpFields"
+];
+var toSafeLog = (result) => {
+  const view = result.ok ? result : { ...result, error: { ...result.error, sgpFields: Object.keys(result.error.sgp ?? {}) } };
+  return pick(view, SAFE_LOG_PATHS);
 };
 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,
-  invoiceSecretKeys,
-  invoicePersonalKeys,
-  invoiceItemPath,
-  formaCobrancaCodigo,
-  dueDaySecretKeys,
-  dueDayPersonalKeys,
-  dueDayItemPath,
-  customerStatusSecretKeys,
-  customerStatusPersonalKeys,
-  customerStatusItemPath,
-  customerDocumentSecretKeys,
-  customerDocumentPersonalKeys,
-  customerDocumentItemPath,
-  customerDocumentAddedSecretKeys,
-  customerDocumentAddedPersonalKeys,
-  customerDocumentAddedItemPath,
-  customerCreatedSecretKeys,
-  customerCreatedPersonalKeys,
-  customerCreatedItemPath,
-  customerContractSecretKeys,
-  customerContractPersonalKeys,
-  customerContractItemPath,
-  crmStatus,
+  toSafeLog,
+  pick,
+  getSensitivity,
   createSgpClient,
-  createIndividualCustomerDefinition,
-  createCustomerKeyFields,
-  createContractKeyFields,
-  createContractDefinition,
-  createCompanyCustomerDefinition,
-  coverageSecretKeys,
-  coveragePersonalKeys,
-  coverageItemPath,
-  contractSummarySecretKeys,
-  contractSummaryPersonalKeys,
-  contractSummaryItemPath,
-  contractCreatedSecretKeys,
-  contractCreatedPersonalKeys,
-  contractCreatedItemPath,
-  clientSecretKeys,
-  clientPersonalKeys,
-  clientItemPath,
-  checkCoverageKeyFields,
-  checkCoverageDefinition,
-  addCustomerDocumentKeyFields,
-  addCustomerDocumentDefinition
+  SERVICE_TYPE,
+  MAX_TIMEOUT_MS,
+  InvalidConfigurationError,
+  DEFAULT_TIMEOUT_MS,
+  CRM_STATUS,
+  CONTRACT_STATUS,
+  BILLING_METHOD,
+  ACQUISITION_MODE
 };