@grupolapa/desarrollos-sdk 0.1.0 → 0.3.1

package/dist/embed-protocol-contract.js

@@ -0,0 +1,194 @@
+// Frozen wire contract for UONDR embed protocol 1.0.
+//
+// MIRRORED FILE — the contents below must stay byte-identical in both repos:
+//   uondr-web      src/features/external-configurator/lib/protocol-contract.ts
+//   lapa-monorepo  packages/cotizador-sdk/src/embed-protocol-contract.ts
+//
+// UONDR owns the protocol; Lapa republishes this literal to partner websites
+// through GET /api/public/v1/desarrollos/partner-agent.json. Keep this module
+// import-free so the two copies can be compared byte-for-byte. After editing,
+// run `pnpm verify:protocol-contract` in both repos.
+export const UONDR_EMBED_PROTOCOL_CONTRACT = {
+    version: "1.0",
+    frozenOn: "2026-07-26",
+    owner: "uondr",
+    summary: "Bidirectional postMessage contract between a partner website (host) and the UONDR configurator iframe. The host never calls a UONDR HTTP API; this channel plus the Lapa journey API is the entire integration surface.",
+    sources: {
+        hostCommand: "lapa.partner",
+        configuratorEvent: "uondr.configurator",
+    },
+    commandTypes: [
+        "initialize",
+        "restrict_designs",
+        "restore",
+        "complete",
+        "cancel",
+    ],
+    eventTypes: ["ready", "changed", "completed", "cancelled", "resize", "error"],
+    commandEnvelope: {
+        requiredKeys: ["source", "protocolVersion", "sessionId", "type"],
+        optionalKeys: ["requestId", "payload"],
+        unknownKeysRejected: true,
+    },
+    eventEnvelope: {
+        requiredKeys: [
+            "source",
+            "protocolVersion",
+            "sessionId",
+            "sequence",
+            "type",
+        ],
+        optionalKeys: ["configuration", "payload", "requestId"],
+        unknownKeysRejected: false,
+    },
+    limits: {
+        sessionIdMaxLength: 256,
+        requestIdMaxLength: 128,
+        commandFingerprintMaxLength: 16384,
+        commandHistoryMax: 256,
+        earlyCommandQueueMax: 32,
+    },
+    commands: {
+        initialize: {
+            order: "First command. Sent once, only after the ready event.",
+            payload: {
+                allowedDesignIds: ["<stable-design-id>"],
+                externalMode: true,
+                hidePricing: true,
+            },
+            rules: [
+                "externalMode and hidePricing must both be literal true.",
+                "allowedDesignIds must be a non-empty array of unique, non-empty strings with no leading or trailing whitespace, and a subset of the session scope.",
+                "A second initialize is rejected.",
+            ],
+        },
+        restrict_designs: {
+            order: "After initialize. Narrows the visible design set.",
+            payload: { allowedDesignIds: ["<stable-design-id>"] },
+            rules: [
+                "allowedDesignIds must be a subset of the session scope; the configurator intersects rather than widens.",
+            ],
+        },
+        restore: {
+            order: "After initialize, when Lapa reports an active configuration.",
+            payload: {
+                configuration: {
+                    configurationId: "<stable-configuration-id>",
+                    hash: "<canonical-hash>",
+                    revision: 1,
+                },
+            },
+            rules: [
+                "revision must be a safe integer >= 1 and strictly greater than the last accepted restore revision.",
+                "configurationId and hash must be strings.",
+            ],
+        },
+        complete: {
+            order: "After initialize, when the buyer confirms the configuration.",
+            payload: {},
+            rules: [
+                "The configurator persists an immutable revision and answers with a completed event.",
+            ],
+        },
+        cancel: {
+            order: "After initialize. Terminal.",
+            payload: {},
+            rules: ["The configurator accepts no further commands on this session."],
+        },
+    },
+    events: {
+        ready: {
+            order: "Emitted unprompted at sequence 0 as soon as the session validates. Wait for it before sending initialize.",
+            payload: {
+                allowedDesignIds: ["<stable-design-id>"],
+                capabilities: {
+                    commands: [
+                        "initialize",
+                        "restrict_designs",
+                        "restore",
+                        "complete",
+                        "cancel",
+                    ],
+                    externalMode: true,
+                    hidePricing: true,
+                },
+            },
+        },
+        changed: {
+            order: "Emitted on every buyer selection change after initialize.",
+            payload: {
+                designId: "<stable-design-id>",
+                materialSelectionCount: 0,
+                modifierSelectionCount: 0,
+            },
+            rules: [
+                "Carries no monetary value. Never derive a price or total from this event.",
+            ],
+        },
+        completed: {
+            order: "Emitted once in response to complete.",
+            configuration: {
+                configurationId: "<stable-configuration-id>",
+                hash: "<canonical-hash>",
+                revision: 1,
+            },
+            rules: [
+                "Carries only the stable reference. Submit those three fields to Lapa; Lapa fetches and validates the immutable snapshot server-to-server.",
+                "No snapshot, no internal identifier, and no pricing is exposed to the host.",
+            ],
+        },
+        cancelled: {
+            order: "Emitted in response to cancel. Terminal.",
+            payload: { reason: "<optional-reason-code>" },
+        },
+        resize: {
+            order: "Emitted whenever the configurator content height changes.",
+            payload: { height: 720 },
+            rules: [
+                "Apply to the iframe height. The configurator never resizes itself.",
+            ],
+        },
+        error: {
+            order: "Emitted on a recoverable configurator failure.",
+            payload: {
+                code: "external_configurator_error",
+                message: "<safe-buyer-facing-message>",
+                retryable: true,
+            },
+        },
+    },
+    hostRules: [
+        "Mount the embedUrl returned by Lapa unchanged. Never construct a UONDR URL yourself.",
+        "Derive the target origin with new URL(embedUrl).origin and pass it to every postMessage. Never use '*'.",
+        "Accept an event only when event.origin equals that origin, event.source is the iframe contentWindow, source is 'uondr.configurator', protocolVersion is '1.0', sessionId matches, and sequence is strictly greater than the last accepted sequence.",
+        "The configurator resolves the parent origin from document.referrer and fails closed when it is absent. The host page must send a referrer: do not set Referrer-Policy to no-referrer, same-origin, origin-when-cross-origin, or strict-origin on the page that mounts the iframe.",
+        "Send each command at most once. Duplicate command bodies and duplicate requestIds are dropped.",
+        "Treat completed and cancelled as terminal; request a new session to configure again.",
+    ],
+    configuratorRules: [
+        "Accept a command only when event.origin equals the session parentOrigin and event.source is the parent window.",
+        "Reject every command that arrives before initialize.",
+        "Emit one monotonically increasing sequence per session, starting at 0.",
+        "Hide every monetary amount, currency label, and financing surface in external mode.",
+        "Fail closed on expired, revoked, cross-session, malformed, stale, or replayed input.",
+    ],
+};
+export const UONDR_EMBED_PROTOCOL_CONTRACT_DIGEST = "sha256:f8c00ed49a9364a2f5b35d9073779767b744639e1b7d943ac669e60473080316";
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value && typeof value === "object") {
+        const source = value;
+        return Object.keys(source)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = canonicalize(source[key]);
+            return result;
+        }, {});
+    }
+    return value;
+}
+export function canonicalProtocolContractJson() {
+    return JSON.stringify(canonicalize(UONDR_EMBED_PROTOCOL_CONTRACT));
+}

package/dist/embed-protocol.d.ts

@@ -0,0 +1,55 @@
+export * from "./embed-protocol-contract.js";
+export declare const UONDR_PROTOCOL_VERSION: "1.0";
+export declare const UONDR_EVENT_SOURCE: "uondr.configurator";
+export declare const LAPA_COMMAND_SOURCE: "lapa.partner";
+export type UondrConfigurationReference = {
+    configurationId: string;
+    hash: string;
+    revision: number;
+};
+export type UondrCommandType = "initialize" | "restrict_designs" | "restore" | "complete" | "cancel";
+export type UondrEventType = "ready" | "changed" | "completed" | "cancelled" | "resize" | "error";
+export type UondrHostCommand = {
+    payload?: Record<string, unknown>;
+    protocolVersion: typeof UONDR_PROTOCOL_VERSION;
+    requestId?: string;
+    sessionId: string;
+    source: typeof LAPA_COMMAND_SOURCE;
+    type: UondrCommandType;
+};
+export type UondrConfiguratorEvent = {
+    configuration?: UondrConfigurationReference;
+    payload?: Record<string, unknown>;
+    protocolVersion: typeof UONDR_PROTOCOL_VERSION;
+    requestId?: string;
+    sequence: number;
+    sessionId: string;
+    source: typeof UONDR_EVENT_SOURCE;
+    type: UondrEventType;
+};
+export declare function createUondrCommand(args: {
+    payload?: Record<string, unknown>;
+    requestId?: string;
+    sessionId: string;
+    type: UondrCommandType;
+}): UondrHostCommand;
+export declare function isUondrConfiguratorEvent(value: unknown): value is UondrConfiguratorEvent;
+export declare class UondrEventGuard {
+    #private;
+    readonly origin: string;
+    readonly sessionId: string;
+    readonly sourceWindow: object;
+    constructor(args: {
+        origin: string;
+        sessionId: string;
+        sourceWindow: object;
+    });
+    accept(args: {
+        data: unknown;
+        origin: string;
+        source: object | null;
+    }): UondrConfiguratorEvent | null;
+}
+export declare function postUondrCommand(target: {
+    postMessage(message: unknown, targetOrigin: string): void;
+}, targetOrigin: string, command: UondrHostCommand): void;

package/dist/embed-protocol.js

@@ -0,0 +1,70 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _UondrEventGuard_lastSequence;
+export * from "./embed-protocol-contract.js";
+export const UONDR_PROTOCOL_VERSION = "1.0";
+export const UONDR_EVENT_SOURCE = "uondr.configurator";
+export const LAPA_COMMAND_SOURCE = "lapa.partner";
+export function createUondrCommand(args) {
+    return {
+        protocolVersion: UONDR_PROTOCOL_VERSION,
+        sessionId: args.sessionId,
+        source: LAPA_COMMAND_SOURCE,
+        type: args.type,
+        ...(args.payload ? { payload: args.payload } : {}),
+        ...(args.requestId ? { requestId: args.requestId } : {}),
+    };
+}
+export function isUondrConfiguratorEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const event = value;
+    return (event.source === UONDR_EVENT_SOURCE &&
+        event.protocolVersion === UONDR_PROTOCOL_VERSION &&
+        typeof event.sessionId === "string" &&
+        typeof event.sequence === "number" &&
+        Number.isSafeInteger(event.sequence) &&
+        event.sequence >= 0 &&
+        typeof event.type === "string" &&
+        ["ready", "changed", "completed", "cancelled", "resize", "error"].includes(event.type));
+}
+export class UondrEventGuard {
+    constructor(args) {
+        _UondrEventGuard_lastSequence.set(this, -1);
+        const origin = new URL(args.origin).origin;
+        if (origin === "null") {
+            throw new Error("A concrete UONDR origin is required.");
+        }
+        this.origin = origin;
+        this.sessionId = args.sessionId;
+        this.sourceWindow = args.sourceWindow;
+    }
+    accept(args) {
+        if (args.origin !== this.origin ||
+            args.source !== this.sourceWindow ||
+            !isUondrConfiguratorEvent(args.data) ||
+            args.data.sessionId !== this.sessionId ||
+            args.data.sequence <= __classPrivateFieldGet(this, _UondrEventGuard_lastSequence, "f")) {
+            return null;
+        }
+        __classPrivateFieldSet(this, _UondrEventGuard_lastSequence, args.data.sequence, "f");
+        return args.data;
+    }
+}
+_UondrEventGuard_lastSequence = new WeakMap();
+export function postUondrCommand(target, targetOrigin, command) {
+    const origin = new URL(targetOrigin).origin;
+    if (origin === "null" || targetOrigin === "*") {
+        throw new Error("A concrete UONDR target origin is required.");
+    }
+    target.postMessage(command, origin);
+}

package/dist/http.d.ts

@@ -1,10 +1,13 @@
-import type { DesarrolloInventoryRequest, DesarrolloRequest, DesarrolloSitemapRequest, DesarrollosApiBaseOptions, DesarrollosApiErrorBody, CreatePublicReservationRequest, CreatePublicSessionRequest, GetPublicReservationRequest, PublicDevelopmentsResponse, PublicInventoryResponse, PublicInstancesResponse, PublicPaymentMethodsResponse, PublicReservationStatus, PublicSessionResponse, PublicSitemapResponse, PublicSnapshotResponse } from "./types.js";
+import type { CompleteJourneyConfigurationRequest, CreateJourneyCheckoutRequest, CreateJourneyConfiguratorSessionRequest, CreateJourneyConfiguratorSessionResponse, CreateJourneyQuoteRequest, CreateJourneyRequest, CreateJourneyResponse, DesarrolloInventoryRequest, DesarrolloRequest, DesarrolloSitemapRequest, DesarrollosApiBaseOptions, DesarrollosApiErrorBody, CreatePublicReservationRequest, CreatePublicSessionRequest, GetPublicReservationRequest, GetJourneyRequest, PublicDevelopmentsResponse, PublicInventoryResponse, PublicInstancesResponse, PublicPaymentMethodsResponse, PublicReservationStatus, PublicSessionResponse, PublicSitemapResponse, PublicSnapshotResponse, UpdateJourneyLeadRequest, UpdateJourneySelectionRequest } from "./types.js";
 type Credential = {
     kind: "apiKey";
     value: string;
 } | {
     kind: "session";
     value: string;
+} | {
+    kind: "journey";
+    value: string;
 };
 export declare class DesarrollosApiError extends Error {
     code?: string;
@@ -23,6 +26,30 @@ export declare function createDesarrollosApiRequester(options: DesarrollosApiBas
     getSitemap: (args: DesarrolloSitemapRequest) => Promise<PublicSitemapResponse>;
     getPaymentMethods: (args: DesarrolloRequest) => Promise<PublicPaymentMethodsResponse>;
     createSession: (args: CreatePublicSessionRequest, credential: Credential) => Promise<PublicSessionResponse>;
+    createJourney: (args: CreateJourneyRequest, credential?: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<CreateJourneyResponse>;
+    getJourney: (args: GetJourneyRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
+    updateJourneySelection: (args: UpdateJourneySelectionRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
+    createJourneyConfiguratorSession: (args: CreateJourneyConfiguratorSessionRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<CreateJourneyConfiguratorSessionResponse>;
+    completeJourneyConfiguration: (args: CompleteJourneyConfigurationRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
+    createJourneyQuote: (args: CreateJourneyQuoteRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
+    updateJourneyLead: (args: UpdateJourneyLeadRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
+    createJourneyCheckout: (args: CreateJourneyCheckoutRequest, credential: Extract<Credential, {
+        kind: "journey";
+    }>) => Promise<import("./types").PublicJourneyStatus>;
     createReservation: (args: CreatePublicReservationRequest, credential: Credential) => Promise<PublicReservationStatus>;
     getReservation: (args: GetPublicReservationRequest, credential: Credential) => Promise<PublicReservationStatus>;
 };

package/dist/http.js

@@ -49,6 +49,9 @@ function credentialHeaders(credential) {
     if (!credential) {
         return [];
     }
+    if (credential.kind === "journey") {
+        return [["authorization", `Bearer ${credential.value}`]];
+    }
     return credential.kind === "apiKey"
         ? [["x-lapa-api-key", credential.value]]
         : [["x-lapa-session", credential.value]];
@@ -109,6 +112,43 @@ export function createDesarrollosApiRequester(options) {
             headers: { "Content-Type": "application/json" },
             method: "POST",
         }),
+        createJourney: (args, credential) => requestJson(`/integrations/${encodePathSegment(args.integrationKey)}/journeys`, {
+            credential,
+            method: "POST",
+        }),
+        getJourney: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}`, { credential }),
+        updateJourneySelection: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/selection`, {
+            body: JSON.stringify(args.selection),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "PUT",
+        }),
+        createJourneyConfiguratorSession: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/configurator-sessions`, {
+            credential,
+            method: "POST",
+        }),
+        completeJourneyConfiguration: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/configuration-completions`, {
+            body: JSON.stringify(args.configuration),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
+        createJourneyQuote: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/quotes`, {
+            credential,
+            method: "POST",
+        }),
+        updateJourneyLead: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/lead`, {
+            body: JSON.stringify(args.lead),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "PUT",
+        }),
+        createJourneyCheckout: (args, credential) => requestJson(`/journeys/${encodePathSegment(args.journeyId)}/checkout`, {
+            body: JSON.stringify(args.checkout),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
         createReservation: (args, credential) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/reservations`, {
             body: JSON.stringify({
                 ...args.request,

package/dist/index.d.ts

@@ -1,15 +1,24 @@
 import { DesarrollosApiError } from "./http.js";
-import type { DesarrollosApiBaseOptions, CreatePublicReservationRequest, GetPublicReservationRequest } from "./types.js";
+import type { CompleteJourneyConfigurationRequest, CreateJourneyCheckoutRequest, CreateJourneyConfiguratorSessionRequest, CreateJourneyQuoteRequest, CreateJourneyRequest, DesarrollosApiBaseOptions, CreatePublicReservationRequest, GetJourneyRequest, GetPublicReservationRequest, UpdateJourneyLeadRequest, UpdateJourneySelectionRequest } from "./types.js";
 export { DesarrollosApiError };
 export type * from "./types.js";
+export * from "./embed-protocol.js";
 export declare function createDesarrollosClient(options: DesarrollosApiBaseOptions): {
+    completeJourneyConfiguration: (args: CompleteJourneyConfigurationRequest) => Promise<import("./types").PublicJourneyStatus>;
+    createJourney: (args: CreateJourneyRequest) => Promise<import("./types").CreateJourneyResponse>;
+    createJourneyCheckout: (args: CreateJourneyCheckoutRequest) => Promise<import("./types").PublicJourneyStatus>;
+    createJourneyConfiguratorSession: (args: CreateJourneyConfiguratorSessionRequest) => Promise<import("./types").CreateJourneyConfiguratorSessionResponse>;
+    createJourneyQuote: (args: CreateJourneyQuoteRequest) => Promise<import("./types").PublicJourneyStatus>;
     createReservation: (args: CreatePublicReservationRequest) => Promise<import("./types").PublicReservationStatus>;
     getAgentGuide: () => Promise<Record<string, unknown>>;
     getInventory: (args: import("./types").DesarrolloInventoryRequest) => Promise<import("./types").PublicInventoryResponse>;
+    getJourney: (args: GetJourneyRequest) => Promise<import("./types").PublicJourneyStatus>;
     getOpenApi: () => Promise<Record<string, unknown>>;
     getPaymentMethods: (args: import("./types").DesarrolloRequest) => Promise<import("./types").PublicPaymentMethodsResponse>;
     getReservation: (args: GetPublicReservationRequest) => Promise<import("./types").PublicReservationStatus>;
     getSitemap: (args: import("./types").DesarrolloSitemapRequest) => Promise<import("./types").PublicSitemapResponse>;
     getSnapshot: (args: import("./types").DesarrolloRequest) => Promise<import("./types").PublicSnapshotResponse>;
     listInstances: (args: Pick<import("./types").DesarrolloRequest, "desarrolloKey">) => Promise<import("./types").PublicInstancesResponse>;
+    updateJourneyLead: (args: UpdateJourneyLeadRequest) => Promise<import("./types").PublicJourneyStatus>;
+    updateJourneySelection: (args: UpdateJourneySelectionRequest) => Promise<import("./types").PublicJourneyStatus>;
 };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { DesarrollosApiError, createDesarrollosApiRequester } from "./http.js";
 export { DesarrollosApiError };
+export * from "./embed-protocol.js";
 export function createDesarrollosClient(options) {
     const api = createDesarrollosApiRequester(options);
     function requireSessionToken(sessionToken) {
@@ -8,15 +9,29 @@ export function createDesarrollosClient(options) {
         }
         return { kind: "session", value: sessionToken };
     }
+    function journeyCredential(journeyToken) {
+        if (!journeyToken) {
+            throw new Error("A journey token is required for journey methods.");
+        }
+        return { kind: "journey", value: journeyToken };
+    }
     return {
+        completeJourneyConfiguration: (args) => api.completeJourneyConfiguration(args, journeyCredential(args.journeyToken)),
+        createJourney: (args) => api.createJourney(args, args.journeyToken ? journeyCredential(args.journeyToken) : undefined),
+        createJourneyCheckout: (args) => api.createJourneyCheckout(args, journeyCredential(args.journeyToken)),
+        createJourneyConfiguratorSession: (args) => api.createJourneyConfiguratorSession(args, journeyCredential(args.journeyToken)),
+        createJourneyQuote: (args) => api.createJourneyQuote(args, journeyCredential(args.journeyToken)),
         createReservation: async (args) => api.createReservation(args, requireSessionToken(args.sessionToken)),
         getAgentGuide: api.getAgentGuide,
         getInventory: api.getInventory,
+        getJourney: (args) => api.getJourney(args, journeyCredential(args.journeyToken)),
         getOpenApi: api.getOpenApi,
         getPaymentMethods: api.getPaymentMethods,
         getReservation: async (args) => api.getReservation(args, requireSessionToken(args.sessionToken)),
         getSitemap: api.getSitemap,
         getSnapshot: api.getSnapshot,
         listInstances: api.listInstances,
+        updateJourneyLead: (args) => api.updateJourneyLead(args, journeyCredential(args.journeyToken)),
+        updateJourneySelection: (args) => api.updateJourneySelection(args, journeyCredential(args.journeyToken)),
     };
 }

package/dist/payment-schemes.d.ts

@@ -1,5 +1,9 @@
-import type { CashbackPaymentScheme, FinanceRules, InstallmentPaymentScheme, InventoryUnit, PaymentSchemeDefinition, RangeRule } from "./types.js";
+import type { CashbackPaymentScheme, FinanceRules, InstallmentPaymentScheme, InventoryCategory, InventoryUnit, PaymentSchemeDefinition, RangeRule, SiteCategoryCopy } from "./types.js";
 export declare const MAX_CASHBACK_MONTHS = 30;
+export declare const UONDR_FLEXIBLE_PLAN_BUNDLE_THRESHOLD_MXN = 10000000;
+export type UondrPaymentSchemeOptions = {
+    includeLocalFlexiblePlan?: boolean;
+};
 export declare function getUnitListPriceMXN(unit: InventoryUnit): number;
 export declare function getUnitEstimatedRentalAnnualMXN(unit: InventoryUnit, rentalRate: number, includeIva: boolean): number;
 export declare function getUnitEstimatedRentalMonthlyMXN(unit: InventoryUnit, rentalRate: number, includeIva: boolean): number;
@@ -12,11 +16,18 @@ export declare function getUnitDeliveryLabel(unit: InventoryUnit): string;
 export declare function getUnitDeliveryMonths(unit: InventoryUnit, referenceDate?: Date): number;
 export declare function isCashbackScheme(scheme: PaymentSchemeDefinition): scheme is CashbackPaymentScheme;
 export declare function isInstallmentScheme(scheme: PaymentSchemeDefinition): scheme is InstallmentPaymentScheme;
+export declare function isUondrLocalCategory(category: InventoryCategory, siteCategories?: SiteCategoryCopy[]): boolean;
+export declare function isUondrLocalUnit(unit: InventoryUnit, siteCategories?: SiteCategoryCopy[]): boolean;
+export declare function isUondrFlexiblePaymentScheme(scheme: PaymentSchemeDefinition): scheme is InstallmentPaymentScheme;
+export declare function isUondrBundleFlexiblePlanEligible(units: InventoryUnit[], siteCategories?: SiteCategoryCopy[]): boolean;
 export declare function getPaymentSchemeById(paymentSchemes: PaymentSchemeDefinition[], schemeId: string): PaymentSchemeDefinition | null;
 export declare function getActivePaymentSchemes(paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition[];
 export declare function getAllowedPaymentSchemes(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition[];
+export declare function getUondrAllowedPaymentSchemes(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[], siteCategories?: SiteCategoryCopy[], options?: UondrPaymentSchemeOptions): PaymentSchemeDefinition[];
 export declare function getDefaultSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[]): PaymentSchemeDefinition;
+export declare function getUondrDefaultSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[], siteCategories?: SiteCategoryCopy[], options?: UondrPaymentSchemeOptions): PaymentSchemeDefinition;
 export declare function getResolvedSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[], requestedSchemeId: string | null | undefined): PaymentSchemeDefinition;
+export declare function getUondrResolvedSchemeForUnit(unit: InventoryUnit, paymentSchemes: PaymentSchemeDefinition[], requestedSchemeId: string | null | undefined, siteCategories?: SiteCategoryCopy[], options?: UondrPaymentSchemeOptions): PaymentSchemeDefinition;
 export declare function clampToRange(value: number, range: RangeRule): number;
 export declare function getSchemeDownPaymentRange(scheme: PaymentSchemeDefinition | null): RangeRule | null;
 export declare function getDefaultDownPaymentPctForScheme(scheme: PaymentSchemeDefinition | null, financeRules: FinanceRules): number;

package/dist/payment-schemes.js

@@ -19,6 +19,7 @@ const MONTH_LABELS = [
     "Diciembre",
 ];
 export const MAX_CASHBACK_MONTHS = 30;
+export const UONDR_FLEXIBLE_PLAN_BUNDLE_THRESHOLD_MXN = 10000000;
 export function getUnitListPriceMXN(unit) {
     return roundCurrency(unit.areaM2 * unit.pricePerM2MXN);
 }
@@ -59,6 +60,42 @@ export function isCashbackScheme(scheme) {
 export function isInstallmentScheme(scheme) {
     return scheme.type === "installment";
 }
+function normalizeRuleText(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, " ");
+}
+export function isUondrLocalCategory(category, siteCategories = []) {
+    const normalizedCategory = normalizeRuleText(category);
+    if (normalizedCategory === "local" || normalizedCategory === "locales") {
+        return true;
+    }
+    const categoryCopy = siteCategories.find((item) => item.id === category);
+    const normalizedLabel = categoryCopy
+        ? normalizeRuleText(categoryCopy.label)
+        : "";
+    return normalizedLabel === "local" || normalizedLabel === "locales";
+}
+export function isUondrLocalUnit(unit, siteCategories = []) {
+    return isUondrLocalCategory(unit.category, siteCategories);
+}
+export function isUondrFlexiblePaymentScheme(scheme) {
+    return isInstallmentScheme(scheme);
+}
+export function isUondrBundleFlexiblePlanEligible(units, siteCategories = []) {
+    if (units.length <= 1) {
+        return false;
+    }
+    const hasLocalUnit = units.some((unit) => isUondrLocalUnit(unit, siteCategories));
+    if (!hasLocalUnit) {
+        return false;
+    }
+    const listPriceMXN = units.reduce((total, unit) => total + getUnitListPriceMXN(unit), 0);
+    return listPriceMXN > UONDR_FLEXIBLE_PLAN_BUNDLE_THRESHOLD_MXN;
+}
 export function getPaymentSchemeById(paymentSchemes, schemeId) {
     return paymentSchemes.find((scheme) => scheme.id === schemeId) ?? null;
 }
@@ -70,6 +107,14 @@ export function getAllowedPaymentSchemes(unit, paymentSchemes) {
         .map((schemeId) => getPaymentSchemeById(paymentSchemes, schemeId))
         .filter((scheme) => Boolean(scheme?.active));
 }
+export function getUondrAllowedPaymentSchemes(unit, paymentSchemes, siteCategories = [], options = {}) {
+    const allowedSchemes = getAllowedPaymentSchemes(unit, paymentSchemes);
+    if (!isUondrLocalUnit(unit, siteCategories) ||
+        options.includeLocalFlexiblePlan) {
+        return allowedSchemes;
+    }
+    return allowedSchemes.filter((scheme) => !isUondrFlexiblePaymentScheme(scheme));
+}
 export function getDefaultSchemeForUnit(unit, paymentSchemes) {
     const allowedSchemes = getAllowedPaymentSchemes(unit, paymentSchemes);
     return (allowedSchemes.find((scheme) => scheme.id === unit.defaultSchemeId) ??
@@ -77,11 +122,22 @@ export function getDefaultSchemeForUnit(unit, paymentSchemes) {
         getActivePaymentSchemes(paymentSchemes)[0] ??
         null);
 }
+export function getUondrDefaultSchemeForUnit(unit, paymentSchemes, siteCategories = [], options = {}) {
+    const allowedSchemes = getUondrAllowedPaymentSchemes(unit, paymentSchemes, siteCategories, options);
+    return (allowedSchemes.find((scheme) => scheme.id === unit.defaultSchemeId) ??
+        allowedSchemes[0] ??
+        null);
+}
 export function getResolvedSchemeForUnit(unit, paymentSchemes, requestedSchemeId) {
     const allowedSchemes = getAllowedPaymentSchemes(unit, paymentSchemes);
     return (allowedSchemes.find((scheme) => scheme.id === requestedSchemeId) ??
         getDefaultSchemeForUnit(unit, paymentSchemes));
 }
+export function getUondrResolvedSchemeForUnit(unit, paymentSchemes, requestedSchemeId, siteCategories = [], options = {}) {
+    const allowedSchemes = getUondrAllowedPaymentSchemes(unit, paymentSchemes, siteCategories, options);
+    return (allowedSchemes.find((scheme) => scheme.id === requestedSchemeId) ??
+        getUondrDefaultSchemeForUnit(unit, paymentSchemes, siteCategories, options));
+}
 export function clampToRange(value, range) {
     const clamped = Math.min(range.max, Math.max(range.min, value));
     const steps = Math.round((clamped - range.min) / range.step);

package/dist/query-state.d.ts

@@ -1,5 +1,5 @@
-import type { FinanceRules, InventoryUnit, PaymentSchemeDefinition, QuoteUrlState } from "./types.js";
+import type { FinanceRules, InventoryUnit, PaymentSchemeDefinition, QuoteUrlState, SiteCategoryCopy } from "./types.js";
 export declare function normalizeQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
 export declare function normalizeSocialQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
-export declare function normalizeUondrQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[]): QuoteUrlState;
+export declare function normalizeUondrQuoteUrlState(search: Record<string, unknown>, units: InventoryUnit[], rules: FinanceRules, paymentSchemes: PaymentSchemeDefinition[], siteCategories?: SiteCategoryCopy[]): QuoteUrlState;
 export declare function buildQuoteSearch(state: QuoteUrlState): string;