@eva_solutions/auth-sdk 0.0.0-stage → 3.0.0-dev-20261109133200

package/dist/contracts/index.js

@@ -0,0 +1,817 @@
+import { a as HEADERS, c as USERS_BATCH_MAX_IDS, i as ERROR_CODES, l as WEBHOOK_HEADERS, n as ACTIVITY_STATES, o as INTERNAL_HEADERS, r as DELIVERY_STATUSES, s as PRIVACY_STATES, t as ACCOUNT_STATES, u as WEBHOOK_TIMESTAMP_WINDOW_SECONDS } from "../constants-rNuD5qJn.js";
+import { t as EVENT_CODES } from "../event-codes-DR5_VlaR.js";
+import { a as productoSlugSchema, c as errorResponseSchema, i as loginResponseSchema, n as getCodeResponseSchema, o as setActiveEmpresaRequestSchema, r as loginRequestSchema, s as setActiveEmpresaResponseSchema, t as getCodeRequestSchema } from "../auth-19r-Q6X2.js";
+import { a as INTER_EMPRESA_PERMISSION_LIST, c as interEmpresaPermissionOwner, d as isInterEmpresaPermission, f as isScopeOfAudience, i as INTER_EMPRESA_PERMISSIONS, l as isDelegableAudience, n as DELEGABLE_AUDIENCE_SCOPES, o as SERVICE_AUDIENCES, p as isServiceAudience, r as DELEGABLE_SCOPES, s as SERVICE_AUDIENCE_SCOPES, t as DELEGABLE_AUDIENCES, u as isDelegableScope } from "../catalog-DqPhtCKZ.js";
+import { a as INTERNAL_AUTORIZACION_ROUTES, c as INTERNAL_TOKEN_EXCHANGE_ROUTES, d as SESSION_ROUTES, f as USER_ROUTES, i as DIRECTORIO_ROUTES, l as INTERNAL_TOKEN_ROUTES, n as API_PREFIX, o as INTERNAL_EMPRESA_ROUTES, p as WEBHOOK_ROUTES, r as AUTH_ROUTES, s as INTERNAL_GRUPO_ROUTES, t as ADMIN_ROUTES, u as INTERNAL_USER_ROUTES } from "../routes-F1g5aVqP.js";
+import { _ as TOKEN_EXCHANGE_GRANT_TYPE, a as DELEGATED_TOKEN_TYP, b as USER_TOKEN_TYP, c as SERVICE_KID_PREFIX, d as SERVICE_TOKEN_TYP, f as SUBJECT_TOKEN_HEADER, g as TOKEN_EXCHANGE_ERROR_CODES, h as TOKEN_BEARING_KEYS, i as DELEGATED_TOKEN_MAX_DEPTH, l as SERVICE_TOKEN_ERROR_CODES, m as SUBJECT_TOKEN_INVALID_STATUS, n as AUTH_SERVICE_SUB, o as INTERNAL_SERVICE_TOKEN_LIFETIME_SECONDS, p as SUBJECT_TOKEN_INVALID_CODE, r as DELEGATED_TOKEN_LIFETIME_SECONDS, s as RESERVED_SERVICE_CLIENT_SLUGS, t as ACCESS_TOKEN_TYPE, u as SERVICE_TOKEN_LIFETIME_SECONDS, v as TOKEN_ISSUER, x as isReservedServiceClientSlug, y as USER_KID_PREFIX } from "../tokens-C3Z40qd7.js";
+import { z } from "zod";
+// ../auth-contracts/dist/empresa-vocab.js
+/**
+* PURE module: it must never reference `zod` or any schema module of this package (see
+* `constants.ts`). Vocabulary of companies shared by the API, the SDK and the products: roles,
+* company and contract states, directions of an authorization listing.
+*/
+/** Role of a person in a company, from the most to the least powerful. Auth reads it from the DB on every operation. */
+const EMPRESA_ROLES = [
+	"titular",
+	"administrador",
+	"miembro"
+];
+/** True when `role` is at least `minimum` (`titular` > `administrador` > `miembro`). */
+function empresaRoleAtLeast(role, minimum) {
+	return EMPRESA_ROLES.indexOf(role) <= EMPRESA_ROLES.indexOf(minimum);
+}
+/** States of a company. A company in `baja` answers 404 to every mutation except `reactivar`. */
+const EMPRESA_ESTADOS = ["activa", "baja"];
+/** States of the contract of a product by a company (`empresa_productos.estado`). */
+const CONTRATACION_ESTADOS = [
+	"prueba",
+	"pendiente_pago",
+	"activo",
+	"suspendido",
+	"cancelado"
+];
+/**
+* The only states that count as contracted (and only while `hasta` is empty or in the future; Auth
+* evaluates it on every read, no event fires when `hasta` passes).
+*/
+const CONTRATACION_ESTADOS_VIGENTES = ["prueba", "activo"];
+/** States billing or the Auth admin can write on any contract row (a product only asks for `pendiente_pago` or `cancelado`). */
+const CONTRATACION_ESTADOS_FACTURACION = [
+	"prueba",
+	"activo",
+	"suspendido",
+	"cancelado"
+];
+/** True when a contract in `estado` counts as contracted, ignoring `hasta`. */
+function isContratacionVigente(estado) {
+	return CONTRATACION_ESTADOS_VIGENTES.includes(estado);
+}
+/** Directions of the authorizations listing of a company. */
+const AUTORIZACION_DIRECCIONES = ["otorgadas", "recibidas"];
+/** What happens to the previous holder when the Auth admin reassigns the holder of a company. */
+const TITULAR_ANTERIOR_DESTINOS = ["miembro", "fuera"];
+// ../auth-contracts/dist/common.js
+/**
+* SCHEMA module: generic confirmation responses shared by several routes. Descriptions are wire
+* text and must not name routes.
+*/
+/** Response with a confirmation message. */
+const messageResponseSchema = z.object({ data: z.object({ message: z.string().meta({ description: "Mensaje de confirmación" }) }) });
+/** Response with a confirmation message and the number of affected items. */
+const messageWithCountResponseSchema = z.object({ data: z.object({
+	message: z.string().meta({ description: "Mensaje de confirmación" }),
+	count: z.number().meta({ description: "Cantidad de elementos afectados" })
+}) });
+// ../auth-contracts/dist/empresas.js
+/**
+* SCHEMA module: companies, their branches and members, as exposed by the service-to-service API
+* and the admin surface. Request bodies are strict BASE objects with no refinements (the API adds
+* rules like "at least one field").
+*
+* One mechanism for every action of a person on a company: the backend of a product sends its
+* service token (Bearer, `aud: auth-api`, the route permission) PLUS the access token of the person
+* as `subjectToken` in the body (`SUBJECT_TOKEN_HEADER` on the requests that have no body). The
+* company comes from the route, never from the session. What is reserved to the Auth admin or to
+* billing carries no `subjectToken`.
+*/
+const idSchema$2 = z.string().min(1).max(64);
+/** Access token (`at+jwt`) of the person on whose behalf a product acts. */
+const subjectTokenSchema = z.string().min(1).max(4096).meta({ description: "Access token de la persona que pide la acción" });
+/** Body of the requests that carry nothing but the person (`DELETE` and the like). */
+const subjectTokenRequestSchema = z.object({ subjectToken: subjectTokenSchema }).strict();
+/** Branch of a company. */
+const sucursalSchema = z.object({
+	id: z.string().meta({ description: "ID de la sucursal" }),
+	empresaId: z.string().meta({ description: "ID de la empresa" }),
+	nombre: z.string().meta({ description: "Nombre de la sucursal" }),
+	direccion: z.string().nullable().meta({ description: "Dirección de la sucursal" }),
+	activa: z.boolean().meta({ description: "false tras la baja lógica de la sucursal" })
+});
+/** Branch as seen by an actor with no product: no address. */
+const sucursalRecortadaSchema = sucursalSchema.pick({
+	id: true,
+	empresaId: true,
+	nombre: true,
+	activa: true
+});
+/** Public profile of a company (the directory shows only these fields, and only when `visible`). */
+const empresaPerfilSchema = z.object({
+	visible: z.boolean().meta({ description: "La empresa aparece en el directorio (false por defecto)" }),
+	rubro: z.string().nullable(),
+	ciudad: z.string().nullable(),
+	descripcion: z.string().nullable()
+});
+const rubroSchema = z.string().trim().min(1).max(100);
+const ciudadSchema = z.string().trim().min(1).max(100);
+const descripcionSchema = z.string().trim().min(1).max(1e3);
+/** Profile fields of the update body: `null` clears the value. */
+const updateEmpresaPerfilSchema = z.object({
+	visible: z.boolean().optional(),
+	rubro: rubroSchema.nullable().optional(),
+	ciudad: ciudadSchema.nullable().optional(),
+	descripcion: descripcionSchema.nullable().optional()
+}).strict();
+const rucSchema = z.string().trim().min(1).max(20);
+const razonSocialSchema = z.string().trim().min(1).max(200);
+const direccionSchema = z.string().min(1).max(500);
+const celularSchema = z.string().min(1).max(30);
+const emailSchema = z.string().trim().toLowerCase().max(254).email();
+const imgSchema = z.string().trim().url().max(2048);
+/**
+* `POST /internal/empresas`. The person of `subjectToken` becomes the holder (`titular`) and the
+* product of the actor is contracted in `prueba`. An actor with no product cannot create companies.
+*/
+const createEmpresaRequestSchema = z.object({
+	ruc: rucSchema.meta({ description: "RUC de la empresa" }),
+	razonSocial: razonSocialSchema,
+	slug: z.string().regex(/^[a-z0-9][a-z0-9-]{1,63}$/, { error: "slug debe matchear ^[a-z0-9][a-z0-9-]{1,63}$" }),
+	direccion: direccionSchema.optional(),
+	celular: celularSchema.optional(),
+	email: emailSchema.optional(),
+	subjectToken: subjectTokenSchema
+}).strict();
+/**
+* `PATCH /internal/empresas/{id}`: master data, profile and directory visibility. `ruc` and `slug`
+* are immutable (a body carrying them is rejected by `.strict()`).
+*/
+const updateEmpresaRequestSchema = z.object({
+	razonSocial: razonSocialSchema.optional(),
+	direccion: direccionSchema.nullable().optional(),
+	celular: celularSchema.nullable().optional(),
+	email: emailSchema.nullable().optional(),
+	img: imgSchema.nullable().optional(),
+	perfil: updateEmpresaPerfilSchema.optional(),
+	subjectToken: subjectTokenSchema
+}).strict();
+/** Query of `GET /internal/empresas`: the companies that contracted the product of the actor. */
+const listEmpresasQuerySchema = z.object({
+	q: z.string().trim().min(1).max(100).optional(),
+	cursor: z.string().min(1).max(256).optional()
+}).strict();
+const addEmpresaMemberRequestSchema = z.object({
+	userId: idSchema$2,
+	subjectToken: subjectTokenSchema
+}).strict();
+/** `PATCH /internal/empresas/{id}/miembros/{userId}`: only the holder changes roles. */
+const updateEmpresaMemberRequestSchema = z.object({
+	rol: z.enum(EMPRESA_ROLES),
+	subjectToken: subjectTokenSchema
+}).strict();
+/** `DELETE /internal/empresas/{id}/miembros/{userId}`: `userId` = the person of the token leaves by their own account. */
+const removeEmpresaMemberRequestSchema = subjectTokenRequestSchema;
+const createSucursalRequestSchema = z.object({
+	nombre: z.string().trim().min(1).max(100),
+	direccion: direccionSchema.optional(),
+	subjectToken: subjectTokenSchema
+}).strict();
+const updateSucursalRequestSchema = z.object({
+	nombre: z.string().trim().min(1).max(100).optional(),
+	direccion: direccionSchema.nullable().optional(),
+	subjectToken: subjectTokenSchema
+}).strict();
+/** `DELETE /internal/empresas/{id}/sucursales/{sucursalId}` is a logical deactivation (`activa = false`). */
+const deactivateSucursalRequestSchema = subjectTokenRequestSchema;
+/**
+* `POST /admin/empresas/{id}/titular`: dispute over a RUC or a company with no holder. The person
+* becomes the holder; the previous holder (if any) stays as a `miembro` or leaves, as the runbook says.
+*/
+const reassignTitularRequestSchema = z.object({
+	userId: idSchema$2,
+	titularAnterior: z.enum(TITULAR_ANTERIOR_DESTINOS).optional().default("miembro")
+}).strict();
+const empresaFields = {
+	id: z.string().meta({ description: "ID de la empresa" }),
+	ruc: z.string().meta({ description: "RUC de la empresa" }),
+	razonSocial: z.string().meta({ description: "Razón social" }),
+	slug: z.string().meta({ description: "Slug identificador" }),
+	direccion: z.string().nullable().meta({ description: "Dirección de la empresa" }),
+	celular: z.string().nullable().meta({ description: "Celular de contacto" }),
+	email: z.string().nullable().meta({ description: "Email de contacto" }),
+	img: z.string().nullable().meta({ description: "URL de imagen/logo" }),
+	estado: z.enum(EMPRESA_ESTADOS),
+	grupoId: z.string().nullable().meta({ description: "Grupo de empresas al que pertenece, si tiene" }),
+	perfil: empresaPerfilSchema
+};
+/** Company as answered by its creation (201) and its update (200). */
+const empresaResponseSchema = z.object({ data: z.object(empresaFields) });
+/** Page of companies; `nextCursor` is `null` on the last page. */
+const listEmpresasResponseSchema = z.object({ data: z.object({
+	empresas: z.array(z.object(empresaFields)),
+	nextCursor: z.string().nullable()
+}) });
+/** Full view (`GET /internal/empresas/{id}`) for an actor whose product the company contracted. */
+const empresaDetailResponseSchema = z.object({ data: z.object({
+	vista: z.literal("completa"),
+	...empresaFields,
+	sucursales: z.array(sucursalSchema),
+	miembros: z.array(z.object({
+		userId: z.string(),
+		rol: z.enum(EMPRESA_ROLES)
+	}))
+}) });
+/** Trimmed view for an actor with no product (a shared service): no contact data, no members. */
+const empresaRecortadaResponseSchema = z.object({ data: z.object({
+	vista: z.literal("recortada"),
+	id: z.string(),
+	razonSocial: z.string(),
+	estado: z.enum(EMPRESA_ESTADOS),
+	sucursales: z.array(sucursalRecortadaSchema)
+}) });
+/** `GET /internal/empresas/{id}`: one of the two views, told apart by `data.vista`. */
+const getEmpresaResponseSchema = z.object({ data: z.discriminatedUnion("vista", [empresaDetailResponseSchema.shape.data, empresaRecortadaResponseSchema.shape.data]) });
+/** Answer of adding a member (201) and of changing a role (200). */
+const empresaMemberResponseSchema = z.object({ data: z.object({
+	empresaId: z.string(),
+	userId: z.string(),
+	rol: z.enum(EMPRESA_ROLES)
+}) });
+/** Answer of creating (201) and updating (200) a branch. */
+const sucursalResponseSchema = z.object({ data: sucursalSchema });
+/** Answer of `baja` and `reactivar` (internal with `empresas:baja`, and admin). */
+const empresaEstadoResponseSchema = z.object({ data: z.object({
+	id: z.string(),
+	estado: z.enum(EMPRESA_ESTADOS)
+}) });
+/** Answer of the holder reassignment. */
+const reassignTitularResponseSchema = z.object({ data: z.object({
+	empresaId: z.string(),
+	titularUserId: z.string(),
+	titularAnteriorUserId: z.string().nullable()
+}) });
+// ../auth-contracts/dist/users.js
+/**
+* SCHEMA module: the user profile and its update body. The update body is the strict BASE object
+* with no `.refine`, so the API can plug it into `createRoute` without changing the OpenAPI
+* document; the API adds its own rules ("at least one field", "latitude and longitude together").
+*/
+/** Public profile of a user (allowlist: it carries no internal fields). */
+const publicProfileSchema = z.object({
+	id: z.string().meta({ description: "ID del usuario" }),
+	phone: z.string().meta({ description: "Teléfono del usuario" }),
+	name: z.string().nullable().meta({ description: "Nombre" }),
+	lastName: z.string().nullable().meta({ description: "Apellido" }),
+	email: z.string().nullable().meta({ description: "Correo electrónico" }),
+	dni: z.string().nullable().meta({ description: "Documento de identidad" }),
+	stateActivity: z.enum(ACTIVITY_STATES).meta({ description: "Estado de actividad" }),
+	statePrivacy: z.enum(PRIVACY_STATES).meta({ description: "Estado de privacidad" }),
+	createdAt: z.string().meta({ description: "Fecha de creación" })
+});
+const profileResponseSchema = z.object({ data: publicProfileSchema });
+/** Group a company belongs to (grouping only: it grants no access). */
+const companyGroupSchema = z.object({
+	id: z.string().meta({ description: "ID del grupo" }),
+	nombre: z.string().meta({ description: "Nombre del grupo" })
+});
+const companyIdentityFields = {
+	id: z.string().meta({ description: "ID de la empresa" }),
+	ruc: z.string().meta({ description: "RUC de la empresa" }),
+	razonSocial: z.string().meta({ description: "Razón social" }),
+	slug: z.string().meta({ description: "Slug identificador" }),
+	rol: z.enum(EMPRESA_ROLES).meta({ description: "Rol de la persona en la empresa (para mostrar u ocultar pantallas)" }),
+	grupo: companyGroupSchema.nullable().meta({ description: "Grupo de la empresa, si tiene" })
+};
+/** Company the user belongs to that has the product of the token contracted. */
+const contractedCompanySchema = z.object({
+	...companyIdentityFields,
+	contratado: z.literal(true),
+	direccion: z.string().nullable().meta({ description: "Dirección de la empresa" }),
+	celular: z.string().nullable().meta({ description: "Celular de contacto" }),
+	email: z.string().nullable().meta({ description: "Email de contacto" }),
+	img: z.string().nullable().meta({ description: "URL de imagen/logo" }),
+	sucursales: z.array(sucursalSchema).meta({ description: "Sucursales de la empresa" })
+});
+/**
+* Company the user HOLDS (`titular`) that has not contracted the product of the token: no contact
+* data and no branches, only what is needed to ask for the contract.
+*/
+const uncontractedCompanySchema = z.object({
+	...companyIdentityFields,
+	contratado: z.literal(false)
+});
+/** Company of the user: with the product contracted (full data) or not (holder only, trimmed). */
+const companySchema = z.discriminatedUnion("contratado", [contractedCompanySchema, uncontractedCompanySchema]);
+/**
+* Companies the user belongs to: the active ones that have the product of the token contracted,
+* plus those the user holds without it (`contratado: false`).
+*/
+const companyListResponseSchema = z.object({ data: z.array(companySchema).meta({ description: "Lista de empresas" }) });
+/** Update body: strict BASE object, every field optional. */
+const updateUserRequestSchema = z.object({
+	name: z.string().min(1).max(100).nullable().optional().meta({ description: "Nombre" }),
+	lastName: z.string().min(1).max(100).nullable().optional().meta({ description: "Apellido" }),
+	email: z.string().trim().toLowerCase().max(254).email().nullable().optional().meta({ description: "Correo electrónico" }),
+	dni: z.string().trim().toUpperCase().min(1).max(20).nullable().optional().meta({ description: "Documento de identidad" }),
+	address: z.string().min(1).max(500).nullable().optional().meta({ description: "Dirección" }),
+	locationLat: z.string().regex(/^-?(?:[0-8]?\d(?:\.\d+)?|90(?:\.0+)?)$/, { error: "Formato de latitud inválido" }).nullable().optional().meta({
+		description: "Latitud",
+		example: "-34.6037"
+	}),
+	locationLon: z.string().regex(/^-?(?:\d{1,2}(?:\.\d+)?|1[0-7]\d(?:\.\d+)?|180(?:\.0+)?)$/, { error: "Formato de longitud inválido" }).nullable().optional().meta({
+		description: "Longitud",
+		example: "-58.3816"
+	})
+}).strict();
+// ../auth-contracts/dist/sessions.js
+/** SCHEMA module: the active sessions of the authenticated user. */
+/** Response of the active sessions list. */
+const sessionListResponseSchema = z.object({ data: z.array(z.object({
+	sessionId: z.uuid().meta({ description: "ID de la sesión" }),
+	deviceType: z.string().meta({ description: "Tipo de dispositivo" }),
+	os: z.string().meta({ description: "Sistema operativo" }),
+	browser: z.string().meta({ description: "Navegador" }),
+	ipAddress: z.string().meta({ description: "Dirección IP" }),
+	createdAt: z.string().meta({ description: "Fecha de creación de la sesión" }),
+	current: z.boolean().meta({ description: "Indica si es la sesión actual" })
+})).meta({ description: "Lista de sesiones" }) });
+// ../auth-contracts/dist/internal-users.js
+/**
+* SCHEMA module: service-to-service users batch. `ids` is capped at `USERS_BATCH_MAX_IDS`
+* (constants), the hard upper bound: the API env `USERS_BATCH_MAX_IDS` can only lower it, and the
+* published OpenAPI document carries it as `maxItems`.
+*/
+const usersBatchRequestSchema = z.object({ ids: z.array(z.string()).max(100).meta({ description: "IDs de usuarios. Strings que no sean UUID v4 se filtran tolerantemente." }) }).strict();
+const usersBatchResponseSchema = z.object({ data: z.object({ users: z.array(publicProfileSchema).meta({ description: "Usuarios activos encontrados. No se garantiza el orden." }) }) });
+// ../auth-contracts/dist/webhooks.js
+/**
+* SCHEMA module: webhook subscriptions and their deliveries. Request bodies are strict BASE
+* objects with no refinements, and descriptions are wire text: they must not name routes.
+*/
+const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const webhookUrlSchema = z.string().regex(/^[hH][tT][tT][pP][sS]?:\/\/[^\s\x00-\x1F\x7F]+$/).url({ protocol: /^https?$/ }).max(2048);
+const eventCodesSchema = z.array(z.enum(EVENT_CODES)).min(1).max(32);
+const createSubscriptionRequestSchema = z.object({
+	url: webhookUrlSchema,
+	eventCodes: eventCodesSchema,
+	enabled: z.boolean().optional().default(true)
+}).strict();
+const updateSubscriptionRequestSchema = z.object({
+	url: webhookUrlSchema.optional(),
+	eventCodes: eventCodesSchema.optional(),
+	enabled: z.boolean().optional()
+}).strict();
+/** Query of the deliveries listing: numbers arrive as strings and are coerced. */
+const deliveriesQuerySchema = z.object({
+	event_id: z.string().regex(UUID_REGEX).optional(),
+	subscription_id: z.string().regex(UUID_REGEX).optional(),
+	status: z.enum(DELIVERY_STATUSES).optional(),
+	limit: z.coerce.number().int().min(1).max(100).default(50),
+	offset: z.coerce.number().int().min(0).default(0)
+}).strict();
+/**
+* Query of `POST /admin/webhooks/republish-pending`: pending deliveries older than
+* `older_than_minutes` (default 10, at most one week) are republished, `limit` per call (default
+* and maximum 100, one QStash batch). Strict: a misspelled parameter fails instead of being ignored.
+*/
+const republishPendingQuerySchema = z.object({
+	older_than_minutes: z.coerce.number().int().min(1).max(10080).default(10),
+	limit: z.coerce.number().int().min(1).max(100).default(100)
+}).strict();
+const republishPendingResponseSchema = z.object({ data: z.object({
+	republished: z.number().int().meta({ description: "Entregas republicadas en QStash en esta llamada" }),
+	hasMore: z.boolean().meta({ description: "true si quedan más entregas pending viejas: vuelve a llamar" })
+}) });
+const subscriptionSchema = z.object({
+	id: z.string().meta({ description: "ID de la subscription" }),
+	clientId: z.string().meta({ description: "ID del cliente" }),
+	url: z.string().meta({ description: "URL del webhook" }),
+	eventCodes: z.array(z.string()).meta({ description: "Eventos suscritos" }),
+	enabled: z.boolean().meta({ description: "Estado activo" }),
+	createdAt: z.string().meta({ description: "Fecha de creación" }),
+	updatedAt: z.string().meta({ description: "Fecha de actualización" })
+});
+/** Creation answer: the signing key travels only here, one time. */
+const subscriptionWithSecretResponseSchema = z.object({ data: z.object({
+	subscription: subscriptionSchema,
+	signingKey: z.string().meta({ description: "Signing key one-time" })
+}) });
+const subscriptionResponseSchema = z.object({ data: subscriptionSchema });
+const subscriptionListResponseSchema = z.object({ data: z.object({ subscriptions: z.array(subscriptionSchema).meta({ description: "Lista de subscriptions del cliente" }) }) });
+const rotateSubscriptionSecretResponseSchema = z.object({ data: z.object({
+	id: z.string().meta({ description: "ID de la subscription" }),
+	signingKey: z.string().meta({ description: "Nueva signing key one-time" }),
+	updatedAt: z.string().meta({ description: "Fecha de actualización" })
+}) });
+const deliverySchema = z.object({
+	id: z.string().meta({ description: "ID del delivery" }),
+	subscriptionId: z.string().meta({ description: "ID de la subscription" }),
+	eventId: z.string().meta({ description: "ID del evento" }),
+	status: z.enum(DELIVERY_STATUSES).meta({ description: "Estado del delivery" }),
+	attempts: z.number().meta({ description: "Número de intentos" }),
+	lastAttemptAt: z.string().nullable().meta({ description: "Último intento" }),
+	nextRetryAt: z.string().nullable().meta({ description: "Próximo retry" }),
+	responseStatus: z.number().nullable().meta({ description: "HTTP status de respuesta" }),
+	createdAt: z.string().meta({ description: "Fecha de creación" })
+});
+const deliveryListResponseSchema = z.object({ data: z.object({ deliveries: z.array(deliverySchema).meta({ description: "Lista de deliveries" }) }) });
+// ../auth-contracts/dist/maintenance.js
+/**
+* SCHEMA module: on-demand cleanup of expired data (admin). The query is a strict BASE object with
+* no refinements, and descriptions are wire text: they must not name routes.
+*/
+/**
+* Query of `POST /admin/maintenance/cleanup`: `limit` (default and maximum 100) caps each of the two
+* batches of one call. Strict: a misspelled parameter fails instead of being ignored.
+*/
+const maintenanceCleanupQuerySchema = z.object({ limit: z.coerce.number().int().min(1).max(100).default(100) }).strict();
+const maintenanceCleanupResponseSchema = z.object({ data: z.object({
+	usersPurged: z.number().int().meta({ description: "Cuentas eliminadas con la ventana de restauración vencida, purgadas en esta llamada" }),
+	eventsDeleted: z.number().int().meta({ description: "Eventos de webhook sin entregas vivas y fuera de la retención, borrados en esta llamada" }),
+	hasMore: z.boolean().meta({ description: "true si queda más por limpiar: vuelve a llamar" })
+}) });
+// ../auth-contracts/dist/service-clients.js
+/**
+* SCHEMA module: service client provisioning (admin) and the user restore answer. The update body
+* is the strict BASE object: the API adds its own "at least one field" rule on top of it, so this
+* package never carries a refinement. The format of the generated key stays in the API.
+*/
+/** Human readable slug: starts with a lower case letter, 3 to 64 chars of `[a-z0-9-]`. */
+const serviceClientSlugSchema = z.string().regex(/^[a-z][a-z0-9-]{2,63}$/, { error: "slug debe matchear ^[a-z][a-z0-9-]{2,63}$" });
+/**
+* Permissions of one audience without repeats. Duplicates are removed (first order kept) instead
+* of rejected: repeating a scope does not change what is granted. At least one is required (a
+* grant with no permissions is removed, not stored) and the input list is bounded (repeats
+* included) so a request cannot carry an arbitrarily long array.
+*/
+const scopesOf$1 = (scopes) => z.array(z.enum(scopes)).min(1).max(16).transform((list) => [...new Set(list)]);
+/**
+* Create or replace the grant of a service client on one audience. One variant per audience of the
+* catalog, so a permission typo or a permission of another audience (`admin` on `auth-api`) is
+* rejected by the schema itself. A test pins that every audience has its variant.
+*/
+const setServiceClientGrantRequestSchema = z.discriminatedUnion("audience", [z.object({
+	audience: z.literal("auth-api"),
+	scopes: scopesOf$1(SERVICE_AUDIENCE_SCOPES["auth-api"])
+}).strict(), z.object({
+	audience: z.literal("whatsapp-api"),
+	scopes: scopesOf$1(SERVICE_AUDIENCE_SCOPES["whatsapp-api"])
+}).strict()]);
+const serviceClientGrantSchema = z.object({
+	audience: z.enum(SERVICE_AUDIENCES),
+	scopes: z.array(z.string())
+}).meta({ id: "ServiceClientGrant" });
+/**
+* Identity of a backend: the product it belongs to (FK to `productos`) and the service audience it
+* IS. Both are set by the admin and may be absent. Product slugs and audiences never coincide.
+* `null` clears the value on update.
+*/
+const productoOfClientSchema = productoSlugSchema.meta({ description: "Producto al que pertenece el backend" });
+const audienciaOfClientSchema = z.enum(SERVICE_AUDIENCES).meta({ description: "Servicio que ES el backend (audiencia del catálogo, única)" });
+const createServiceClientRequestSchema = z.object({
+	slug: serviceClientSlugSchema,
+	name: z.string().min(1).max(100).optional(),
+	producto: productoOfClientSchema.optional(),
+	audiencia: audienciaOfClientSchema.optional(),
+	esAdmin: z.boolean().optional().default(false).meta({ description: "Marca de administrador de Auth: autoriza la superficie /admin firmada" })
+}).strict();
+/** Update body: strict BASE object, every field optional. */
+const updateServiceClientRequestSchema = z.object({
+	enabled: z.boolean().optional(),
+	esAdmin: z.boolean().optional(),
+	name: z.string().min(1).max(100).optional(),
+	producto: productoOfClientSchema.nullable().optional(),
+	audiencia: audienciaOfClientSchema.nullable().optional()
+}).strict();
+/** Public view of a service client: it never carries the stored key material. */
+const serviceClientPublicSchema = z.object({
+	id: z.string().uuid(),
+	slug: z.string(),
+	name: z.string(),
+	enabled: z.boolean(),
+	esAdmin: z.boolean(),
+	producto: z.string().nullable(),
+	audiencia: z.enum(SERVICE_AUDIENCES).nullable(),
+	grants: z.array(serviceClientGrantSchema),
+	lastUsedAt: z.union([z.string(), z.null()]),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "ServiceClientPublic" });
+/** Creation answer: the generated key travels only here, one time. */
+const createServiceClientResponseSchema = z.object({ data: z.object({
+	id: z.string().uuid(),
+	slug: z.string(),
+	name: z.string(),
+	esAdmin: z.boolean(),
+	producto: z.string().nullable(),
+	audiencia: z.enum(SERVICE_AUDIENCES).nullable(),
+	enabled: z.literal(true),
+	secret: z.string(),
+	warning: z.string()
+}) }).meta({ id: "AdminCreateResponse" });
+const listServiceClientsResponseSchema = z.object({ data: z.object({ clientes: z.array(serviceClientPublicSchema) }) }).meta({ id: "AdminListResponse" });
+const getServiceClientResponseSchema = z.object({ data: z.object({ cliente: serviceClientPublicSchema }) }).meta({ id: "AdminDetailResponse" });
+const listServiceClientGrantsResponseSchema = z.object({ data: z.object({ grants: z.array(serviceClientGrantSchema) }) }).meta({ id: "AdminGrantsResponse" });
+const setServiceClientGrantResponseSchema = z.object({ data: z.object({ grant: serviceClientGrantSchema }) }).meta({ id: "AdminGrantResponse" });
+const updateServiceClientResponseSchema = z.object({ data: z.object({
+	cliente: serviceClientPublicSchema,
+	warning: z.string().optional()
+}) }).meta({ id: "AdminUpdateResponse" });
+const rotateServiceClientSecretResponseSchema = z.object({ data: z.object({
+	slug: z.string(),
+	secret: z.string(),
+	warning: z.string()
+}) }).meta({ id: "AdminRotateSecretResponse" });
+const restoreUserResponseSchema = z.object({ data: z.object({
+	userId: z.string().uuid().meta({ description: "ID del usuario restaurado" }),
+	stateAccount: z.literal("no_verificado").meta({ description: "Estado de cuenta tras la restauración (siempre no_verificado)" }),
+	previouslyDeletedAt: z.string().nullable().meta({ description: "Timestamp ISO 8601 de cuando fue eliminado originalmente" }),
+	restoredAt: z.string().meta({ description: "Timestamp ISO 8601 de la restauración" })
+}) }).meta({ id: "AdminRestaurarUsuarioResponse" });
+// ../auth-contracts/dist/service-tokens.js
+/**
+* SCHEMA module: the service token endpoint. Unlike the rest of the API its bodies are NOT wrapped
+* in `{ data }` nor `{ error: { code, message } }`: they follow RFC 6749 (5.1 success, 5.2 errors),
+* so any OAuth-aware client can read them.
+*
+* `audience` is a plain string on purpose: an unknown audience is answered with `invalid_target`
+* (RFC 8707), not with a validation error. The API checks it against the audience catalog.
+*/
+const serviceTokenRequestSchema = z.object({
+	audience: z.string().min(1).max(64).meta({
+		description: "Servicio destino del token (audiencia del catálogo)",
+		example: "whatsapp-api"
+	}),
+	scope: z.string().min(1).max(512).optional().meta({ description: "Permisos pedidos separados por espacio; si falta se conceden todos los concedidos para la audiencia" })
+}).strict();
+const serviceTokenResponseSchema = z.object({
+	access_token: z.string().meta({ description: "JWT de servicio firmado" }),
+	token_type: z.literal("Bearer"),
+	expires_in: z.number().int().positive().meta({ description: "Segundos de vida desde la respuesta" }),
+	scope: z.string().meta({ description: "Permisos concedidos separados por espacio" })
+}).meta({ id: "ServiceTokenResponse" });
+const serviceTokenErrorSchema = z.object({
+	error: z.enum(SERVICE_TOKEN_ERROR_CODES),
+	error_description: z.string().optional()
+}).meta({ id: "ServiceTokenError" });
+// ../auth-contracts/dist/productos.js
+/**
+* SCHEMA module: products (the audience of the user access token) as administered through the
+* signed `/admin` surface. There is no delete: a product is disabled. The API applies the rules
+* the contract does not carry (no refinements here): a slug that equals a service audience
+* (`isServiceAudience`) is a 400, and an update body with no field is a 400.
+*/
+const nombreSchema$1 = z.string().trim().min(1).max(100);
+const productoSchema = z.object({
+	slug: z.string(),
+	nombre: z.string(),
+	enabled: z.boolean()
+}).meta({ id: "Producto" });
+const createProductoRequestSchema = z.object({
+	slug: productoSlugSchema,
+	nombre: nombreSchema$1,
+	enabled: z.boolean().optional().default(true)
+}).strict();
+/** Update body: strict BASE object, every field optional. */
+const updateProductoRequestSchema = z.object({
+	nombre: nombreSchema$1.optional(),
+	enabled: z.boolean().optional()
+}).strict();
+const listProductosResponseSchema = z.object({ data: z.object({ productos: z.array(productoSchema) }) }).meta({ id: "AdminProductosResponse" });
+/** Answer of creating (201) and of updating (200) a product. */
+const productoResponseSchema = z.object({ data: z.object({ producto: productoSchema }) }).meta({ id: "AdminProductoResponse" });
+// ../auth-contracts/dist/token-exchange.js
+const tokenExchangeRequestSchema = z.object({
+	grant_type: z.literal(TOKEN_EXCHANGE_GRANT_TYPE),
+	subject_token: z.string().min(1).max(4096).meta({ description: "Access token del usuario (aud = producto del actor) o token delegado (aud = audiencia del actor)" }),
+	subject_token_type: z.literal(ACCESS_TOKEN_TYPE),
+	audience: z.string().min(1).max(64).meta({
+		description: "Servicio destino del token delegado (una sola audiencia)",
+		example: "whatsapp-api"
+	}),
+	scope: z.string().min(1).max(512).optional().meta({ description: "Permisos pedidos separados por espacio; si falta se emite todo lo delegable para esa arista" })
+}).strict();
+const tokenExchangeResponseSchema = z.object({
+	access_token: z.string().meta({ description: "JWT delegado firmado" }),
+	issued_token_type: z.literal(ACCESS_TOKEN_TYPE),
+	token_type: z.literal("Bearer"),
+	expires_in: z.number().int().positive().meta({ description: "Segundos de vida desde la respuesta" }),
+	scope: z.string().meta({ description: "Permisos emitidos separados por espacio" })
+}).meta({ id: "TokenExchangeResponse" });
+const tokenExchangeErrorSchema = z.object({
+	error: z.enum(TOKEN_EXCHANGE_ERROR_CODES),
+	error_description: z.string().optional()
+}).meta({ id: "TokenExchangeError" });
+// ../auth-contracts/dist/contrataciones.js
+/**
+* SCHEMA module: contracts of a product by a company (`empresa_productos`). A product asks for
+* its own contract (`POST`) or cancels it (`DELETE`) with its service token (permission
+* `contrataciones:pedir`, grantable to products) plus the access token
+* of a holder (`subjectToken`, see `empresas.ts`); billing (permission `contrataciones:escribir`, never granted to a product,
+* no product) and the Auth admin write any row with `PUT`. Only `prueba` and `activo`, with
+* `hasta` empty or in the future, count as contracted.
+*/
+const contratacionSchema = z.object({
+	empresaId: z.string(),
+	producto: z.string(),
+	estado: z.enum(CONTRATACION_ESTADOS),
+	desde: z.string().meta({ description: "Timestamp ISO 8601 de inicio" }),
+	hasta: z.string().nullable().meta({ description: "Timestamp ISO 8601 de vencimiento; null = sin vencimiento" }),
+	actualizadoEn: z.string()
+});
+/**
+* `PUT .../productos/{producto}` (billing and the Auth admin). `hasta` omitted leaves it as is;
+* `null` removes the end; a value sets (or extends) it.
+*/
+const setContratacionRequestSchema = z.object({
+	estado: z.enum(CONTRATACION_ESTADOS_FACTURACION),
+	hasta: z.iso.datetime({ offset: true }).nullable().optional()
+}).strict();
+/** Answer of asking for (201) and of writing (200) a contract. */
+const contratacionResponseSchema = z.object({ data: contratacionSchema });
+/** `GET /internal/empresas/{id}/productos/{producto}`: for shared services that serve service-to-service calls. */
+const contratadoResponseSchema = z.object({ data: z.object({ contratado: z.boolean() }) });
+// ../auth-contracts/dist/grupos.js
+/**
+* SCHEMA module: groups of companies (grouping only, they grant no access: membership stays per
+* company). Only a holder (`titular`) groups: every request carries the `subjectToken` of a person
+* who holds the companies involved. A group left with no companies deletes itself.
+*/
+const idSchema$1 = z.string().min(1).max(64);
+const nombreSchema = z.string().trim().min(1).max(100);
+const grupoSchema = z.object({
+	id: z.string(),
+	nombre: z.string(),
+	empresaIds: z.array(z.string())
+});
+/** Creates a group with one company of the person. */
+const createGrupoRequestSchema = z.object({
+	nombre: nombreSchema,
+	empresaId: idSchema$1,
+	subjectToken: subjectTokenSchema
+}).strict();
+/** Renaming: a holder of any company of the group. */
+const renameGrupoRequestSchema = z.object({
+	nombre: nombreSchema,
+	subjectToken: subjectTokenSchema
+}).strict();
+const addGrupoEmpresaRequestSchema = z.object({
+	empresaId: idSchema$1,
+	subjectToken: subjectTokenSchema
+}).strict();
+const removeGrupoEmpresaRequestSchema = subjectTokenRequestSchema;
+/** Answer of creating (201), renaming (200) and adding a company (201). */
+const grupoResponseSchema = z.object({ data: grupoSchema });
+// ../auth-contracts/dist/directorio.js
+/**
+* SCHEMA module: the directory of companies, the only cross-company search. Open to users with the
+* access token of any enabled product (rate limited per user) and to services with
+* `directorio:leer`. Only active, opted-in companies, only the public profile fields, at most 50
+* per page.
+*/
+const directorioQuerySchema = z.object({
+	q: z.string().trim().min(1).max(100).optional(),
+	rubro: z.string().trim().min(1).max(100).optional(),
+	ciudad: z.string().trim().min(1).max(100).optional(),
+	cursor: z.string().min(1).max(256).optional()
+}).strict();
+const directorioEmpresaSchema = z.object({
+	id: z.string(),
+	razonSocial: z.string(),
+	rubro: z.string().nullable(),
+	ciudad: z.string().nullable(),
+	descripcion: z.string().nullable(),
+	img: z.string().nullable()
+});
+const directorioResponseSchema = z.object({ data: z.object({
+	empresas: z.array(directorioEmpresaSchema),
+	nextCursor: z.string().nullable()
+}) });
+// ../auth-contracts/dist/autorizaciones.js
+/**
+* SCHEMA module: authorizations between companies, only for private data. The permission is one
+* of the closed inter-company catalog (`INTER_EMPRESA_PERMISSIONS`), never a service permission.
+* An administrator or the holder of the grantor grants and revokes; one of the beneficiary can
+* renounce (all with the `subjectToken` mechanism of `empresas.ts`). Which permissions a product
+* may grant is administered with `producto_permisos_autorizables`.
+*/
+const idSchema = z.string().min(1).max(64);
+const interEmpresaPermissionSchema = z.enum(INTER_EMPRESA_PERMISSION_LIST);
+const createAutorizacionRequestSchema = z.object({
+	beneficiariaId: idSchema,
+	permiso: interEmpresaPermissionSchema,
+	subjectToken: subjectTokenSchema
+}).strict();
+/** `DELETE`: revocation by the grantor or renunciation by the beneficiary. */
+const deleteAutorizacionRequestSchema = subjectTokenRequestSchema;
+/** Query of `GET /internal/empresas/{id}/autorizaciones` (the person goes in `SUBJECT_TOKEN_HEADER`). */
+const listAutorizacionesQuerySchema = z.object({ direccion: z.enum(AUTORIZACION_DIRECCIONES) }).strict();
+/**
+* Query of `GET /internal/autorizaciones/verificar`: only for actors whose audience owns the
+* permission (the actor may also have a product). Valid only while both companies are active.
+*/
+const verificarAutorizacionQuerySchema = z.object({
+	otorgante: idSchema,
+	beneficiaria: idSchema,
+	permiso: interEmpresaPermissionSchema
+}).strict();
+/** Authorization in force. */
+const autorizacionSchema = z.object({
+	id: z.string(),
+	otorganteId: z.string(),
+	beneficiariaId: z.string(),
+	permiso: z.string(),
+	creadaEn: z.string(),
+	creadaPor: z.string().meta({ description: "Persona que la concedió" })
+});
+const autorizacionResponseSchema = z.object({ data: autorizacionSchema });
+const listAutorizacionesResponseSchema = z.object({ data: z.object({ autorizaciones: z.array(autorizacionSchema) }) });
+const verificarAutorizacionResponseSchema = z.object({ data: z.object({ autorizado: z.boolean() }) });
+/** Permissions of the inter-company catalog without repeats (first order kept); an empty list clears them. */
+const setProductoPermisosAutorizablesRequestSchema = z.object({ permisos: z.array(interEmpresaPermissionSchema).max(64).transform((list) => [...new Set(list)]) }).strict();
+/** Permissions a product may grant on behalf of its companies (admin). */
+const productoPermisosAutorizablesResponseSchema = z.object({ data: z.object({
+	producto: z.string(),
+	permisos: z.array(z.string())
+}) }).meta({ id: "AdminProductoPermisosAutorizablesResponse" });
+// ../auth-contracts/dist/delegations.js
+/**
+* SCHEMA module: delegation edges of a service client (admin), `service_client_delegations`. An
+* edge says "this client may exchange a token for a delegated one towards `audience`, carrying at
+* most `scopes`". `auth-api` is never a destination and `admin` is never delegable: the schemas
+* are built from `DELEGABLE_AUDIENCE_SCOPES`, so the typo or the forbidden value is rejected by the
+* schema itself.
+*
+* `requiere_scope_origen` (snake case, like the rest of the token vocabulary) makes the edge usable
+* for a RE-exchange: the incoming delegated token must carry at least one of those permissions. An
+* edge that does not define it admits no re-exchange (only the first hop from a user access token).
+*/
+/** Permissions of one audience without repeats (first order kept); at least one, bounded. */
+const scopesOf = (scopes) => z.array(z.enum(scopes)).min(1).max(16).transform((list) => [...new Set(list)]);
+const originScopes = z.array(z.enum(DELEGABLE_SCOPES)).min(1).max(16).transform((list) => [...new Set(list)]);
+/**
+* Create or replace the edge of a service client towards one audience. One variant per delegable
+* audience; a test pins that every delegable audience has its variant.
+*/
+const setServiceClientDelegationRequestSchema = z.discriminatedUnion("audience", [z.object({
+	audience: z.literal("whatsapp-api"),
+	scopes: scopesOf(DELEGABLE_AUDIENCE_SCOPES["whatsapp-api"]),
+	requiere_scope_origen: originScopes.optional()
+}).strict()]);
+const serviceClientDelegationSchema = z.object({
+	audience: z.enum(DELEGABLE_AUDIENCES),
+	scopes: z.array(z.string()),
+	requiere_scope_origen: z.array(z.string()).meta({ description: "Vacío = la arista no admite re-exchange" })
+}).meta({ id: "ServiceClientDelegation" });
+const listServiceClientDelegationsResponseSchema = z.object({ data: z.object({ delegations: z.array(serviceClientDelegationSchema) }) }).meta({ id: "AdminDelegationsResponse" });
+const setServiceClientDelegationResponseSchema = z.object({ data: z.object({ delegation: serviceClientDelegationSchema }) }).meta({ id: "AdminDelegationResponse" });
+// ../auth-contracts/dist/identity-events.js
+/**
+* SCHEMA module: `data` of the webhook events added by identity phase 2. Ids only: no contact
+* data travels in an event, so the receiver reads what it needs through the API (which applies the
+* contract and role rules). `empresa.*`, `grupo.*` and `autorizacion.*` reach only the clients that
+* contracted the product of the affected company, or have no product.
+*/
+const empresaId = z.string();
+const empresaEventPayloadSchema = z.object({ empresaId });
+const empresaMemberRoleChangedPayloadSchema = z.object({
+	empresaId,
+	userId: z.string(),
+	rol: z.enum(EMPRESA_ROLES)
+});
+const empresaBranchEventPayloadSchema = z.object({
+	empresaId,
+	sucursalId: z.string()
+});
+const empresaProductChangedPayloadSchema = z.object({
+	empresaId,
+	producto: z.string(),
+	estado: z.enum(CONTRATACION_ESTADOS)
+});
+/** Phase 1 events: `empresa.member_added` and `empresa.member_removed`. */
+const empresaMemberEventPayloadSchema = z.object({
+	empresaId,
+	userId: z.string()
+});
+const grupoEventPayloadSchema = z.object({ grupoId: z.string() });
+const grupoMemberEventPayloadSchema = z.object({
+	grupoId: z.string(),
+	empresaId
+});
+const autorizacionEventPayloadSchema = z.object({
+	autorizacionId: z.string(),
+	otorganteId: z.string(),
+	beneficiariaId: z.string(),
+	permiso: z.string()
+});
+/** `data` schema of each `empresa.*`, `grupo.*` and `autorizacion.*` event (ids only: no `slug`, no first member), by event code. */
+const IDENTITY_EVENT_PAYLOAD_SCHEMAS = {
+	[EVENT_CODES.EMPRESA_CREATED]: empresaEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_MEMBER_ADDED]: empresaMemberEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_MEMBER_REMOVED]: empresaMemberEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_BRANCH_CREATED]: empresaBranchEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_UPDATED]: empresaEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_DEACTIVATED]: empresaEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_REACTIVATED]: empresaEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_MEMBER_ROLE_CHANGED]: empresaMemberRoleChangedPayloadSchema,
+	[EVENT_CODES.EMPRESA_BRANCH_UPDATED]: empresaBranchEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_BRANCH_DEACTIVATED]: empresaBranchEventPayloadSchema,
+	[EVENT_CODES.EMPRESA_PRODUCT_CHANGED]: empresaProductChangedPayloadSchema,
+	[EVENT_CODES.GRUPO_UPDATED]: grupoEventPayloadSchema,
+	[EVENT_CODES.GRUPO_MEMBER_ADDED]: grupoMemberEventPayloadSchema,
+	[EVENT_CODES.GRUPO_MEMBER_REMOVED]: grupoMemberEventPayloadSchema,
+	[EVENT_CODES.AUTORIZACION_GRANTED]: autorizacionEventPayloadSchema,
+	[EVENT_CODES.AUTORIZACION_REVOKED]: autorizacionEventPayloadSchema
+};
+export { ACCESS_TOKEN_TYPE, ACCOUNT_STATES, ACTIVITY_STATES, ADMIN_ROUTES, API_PREFIX, AUTH_ROUTES, AUTH_SERVICE_SUB, AUTORIZACION_DIRECCIONES, CONTRATACION_ESTADOS, CONTRATACION_ESTADOS_FACTURACION, CONTRATACION_ESTADOS_VIGENTES, DELEGABLE_AUDIENCES, DELEGABLE_AUDIENCE_SCOPES, DELEGABLE_SCOPES, DELEGATED_TOKEN_LIFETIME_SECONDS, DELEGATED_TOKEN_MAX_DEPTH, DELEGATED_TOKEN_TYP, DELIVERY_STATUSES, DIRECTORIO_ROUTES, EMPRESA_ESTADOS, EMPRESA_ROLES, ERROR_CODES, EVENT_CODES, HEADERS, IDENTITY_EVENT_PAYLOAD_SCHEMAS, INTERNAL_AUTORIZACION_ROUTES, INTERNAL_EMPRESA_ROUTES, INTERNAL_GRUPO_ROUTES, INTERNAL_HEADERS, INTERNAL_SERVICE_TOKEN_LIFETIME_SECONDS, INTERNAL_TOKEN_EXCHANGE_ROUTES, INTERNAL_TOKEN_ROUTES, INTERNAL_USER_ROUTES, INTER_EMPRESA_PERMISSIONS, INTER_EMPRESA_PERMISSION_LIST, PRIVACY_STATES, RESERVED_SERVICE_CLIENT_SLUGS, SERVICE_AUDIENCES, SERVICE_AUDIENCE_SCOPES, SERVICE_KID_PREFIX, SERVICE_TOKEN_ERROR_CODES, SERVICE_TOKEN_LIFETIME_SECONDS, SERVICE_TOKEN_TYP, SESSION_ROUTES, SUBJECT_TOKEN_HEADER, SUBJECT_TOKEN_INVALID_CODE, SUBJECT_TOKEN_INVALID_STATUS, TITULAR_ANTERIOR_DESTINOS, TOKEN_BEARING_KEYS, TOKEN_EXCHANGE_ERROR_CODES, TOKEN_EXCHANGE_GRANT_TYPE, TOKEN_ISSUER, USERS_BATCH_MAX_IDS, USER_KID_PREFIX, USER_ROUTES, USER_TOKEN_TYP, WEBHOOK_HEADERS, WEBHOOK_ROUTES, WEBHOOK_TIMESTAMP_WINDOW_SECONDS, addEmpresaMemberRequestSchema, addGrupoEmpresaRequestSchema, autorizacionEventPayloadSchema, autorizacionResponseSchema, autorizacionSchema, companyGroupSchema, companyListResponseSchema, companySchema, contractedCompanySchema, contratacionResponseSchema, contratacionSchema, contratadoResponseSchema, createAutorizacionRequestSchema, createEmpresaRequestSchema, createGrupoRequestSchema, createProductoRequestSchema, createServiceClientRequestSchema, createServiceClientResponseSchema, createSubscriptionRequestSchema, createSucursalRequestSchema, deactivateSucursalRequestSchema, deleteAutorizacionRequestSchema, deliveriesQuerySchema, deliveryListResponseSchema, deliverySchema, directorioEmpresaSchema, directorioQuerySchema, directorioResponseSchema, empresaBranchEventPayloadSchema, empresaDetailResponseSchema, empresaEstadoResponseSchema, empresaEventPayloadSchema, empresaMemberEventPayloadSchema, empresaMemberResponseSchema, empresaMemberRoleChangedPayloadSchema, empresaPerfilSchema, empresaProductChangedPayloadSchema, empresaRecortadaResponseSchema, empresaResponseSchema, empresaRoleAtLeast, errorResponseSchema, getCodeRequestSchema, getCodeResponseSchema, getEmpresaResponseSchema, getServiceClientResponseSchema, grupoEventPayloadSchema, grupoMemberEventPayloadSchema, grupoResponseSchema, grupoSchema, interEmpresaPermissionOwner, interEmpresaPermissionSchema, isContratacionVigente, isDelegableAudience, isDelegableScope, isInterEmpresaPermission, isReservedServiceClientSlug, isScopeOfAudience, isServiceAudience, listAutorizacionesQuerySchema, listAutorizacionesResponseSchema, listEmpresasQuerySchema, listEmpresasResponseSchema, listProductosResponseSchema, listServiceClientDelegationsResponseSchema, listServiceClientGrantsResponseSchema, listServiceClientsResponseSchema, loginRequestSchema, loginResponseSchema, maintenanceCleanupQuerySchema, maintenanceCleanupResponseSchema, messageResponseSchema, messageWithCountResponseSchema, productoPermisosAutorizablesResponseSchema, productoResponseSchema, productoSchema, productoSlugSchema, profileResponseSchema, publicProfileSchema, reassignTitularRequestSchema, reassignTitularResponseSchema, removeEmpresaMemberRequestSchema, removeGrupoEmpresaRequestSchema, renameGrupoRequestSchema, republishPendingQuerySchema, republishPendingResponseSchema, restoreUserResponseSchema, rotateServiceClientSecretResponseSchema, rotateSubscriptionSecretResponseSchema, serviceClientDelegationSchema, serviceClientGrantSchema, serviceClientPublicSchema, serviceClientSlugSchema, serviceTokenErrorSchema, serviceTokenRequestSchema, serviceTokenResponseSchema, sessionListResponseSchema, setActiveEmpresaRequestSchema, setActiveEmpresaResponseSchema, setContratacionRequestSchema, setProductoPermisosAutorizablesRequestSchema, setServiceClientDelegationRequestSchema, setServiceClientDelegationResponseSchema, setServiceClientGrantRequestSchema, setServiceClientGrantResponseSchema, subjectTokenRequestSchema, subjectTokenSchema, subscriptionListResponseSchema, subscriptionResponseSchema, subscriptionSchema, subscriptionWithSecretResponseSchema, sucursalRecortadaSchema, sucursalResponseSchema, sucursalSchema, tokenExchangeErrorSchema, tokenExchangeRequestSchema, tokenExchangeResponseSchema, uncontractedCompanySchema, updateEmpresaMemberRequestSchema, updateEmpresaPerfilSchema, updateEmpresaRequestSchema, updateProductoRequestSchema, updateServiceClientRequestSchema, updateServiceClientResponseSchema, updateSubscriptionRequestSchema, updateSucursalRequestSchema, updateUserRequestSchema, usersBatchRequestSchema, usersBatchResponseSchema, verificarAutorizacionQuerySchema, verificarAutorizacionResponseSchema };
+
+//# sourceMappingURL=index.js.map