@grupolapa/desarrollos-sdk 0.1.0

package/dist/entrada.d.ts

@@ -0,0 +1,111 @@
+import type { InventoryUnit } from "./types.js";
+export declare const ENTRADA_BOOKING_AMOUNT_MXN = 10000;
+export declare const APARTMENT_TOTAL_MONTHS = 36;
+export declare const ENTRADA_ACTION_SCHEMES: readonly [{
+    readonly id: "contado";
+    readonly description: "Liquidas tu acción en una sola exhibición y accedes a tasa preferencial desde el mes 1.";
+    readonly engancheRatio: 1;
+    readonly label: "Contado";
+    readonly monthlyCount: 0;
+    readonly monthlyRatio: 0;
+    readonly tag: "Máximo rendimiento";
+    readonly tasaObra: 0.08;
+    readonly tasaObraLabel: "8%";
+}, {
+    readonly id: "medio";
+    readonly description: "Enganche de $120K y 5 mensualidades de $40K. Rendimiento del 6% anual una vez liquidado el capital.";
+    readonly engancheRatio: number;
+    readonly label: "Financiado 5 meses";
+    readonly monthlyCount: 5;
+    readonly monthlyRatio: number;
+    readonly tag: "Balance";
+    readonly tasaObra: 0.06;
+    readonly tasaObraLabel: "6%";
+}, {
+    readonly id: "amplio";
+    readonly description: "Enganche de $60K y 13 mensualidades de $20K. Rendimiento del 4% anual una vez liquidado el capital.";
+    readonly engancheRatio: number;
+    readonly label: "Financiado 13 meses";
+    readonly monthlyCount: 13;
+    readonly monthlyRatio: number;
+    readonly tag: "Más accesible";
+    readonly tasaObra: 0.04;
+    readonly tasaObraLabel: "4%";
+}];
+type EntradaActionScheme = (typeof ENTRADA_ACTION_SCHEMES)[number];
+export type EntradaActionSchemeId = EntradaActionScheme["id"];
+export declare function getApartmentPartValueMXN(unit: InventoryUnit): number;
+export declare function buildApartmentPlan(unit: InventoryUnit, requestedParts: number, rentalRate?: number): {
+    deliveryValueMXN: number;
+    engancheMXN: number;
+    fullLotValueMXN: number;
+    monthlyPaymentMXN: number;
+    numParts: number;
+    rentaMensualMXN: number;
+    saldoFinalMXN: number;
+    totalMonths: number;
+    totalToPayMXN: number;
+    yourValueMXN: number;
+};
+export declare function getCorporatePricePerActionMXN(unit: InventoryUnit, totalShares: number): number;
+export declare function getCorporateM2PerAction(unit: InventoryUnit, totalShares: number): number;
+export declare function buildCorporatePlan(args: {
+    inflationRate: number;
+    numActions: number;
+    requestedSchemeId: EntradaActionSchemeId | string | null | undefined;
+    rentalRate: number;
+    totalShares: number;
+    unit: InventoryUnit;
+}): {
+    capitalMXN: number;
+    engancheMXN: number;
+    m2: number;
+    monthlyCount: 0 | 5 | 13;
+    monthlyPaymentMXN: number;
+    numActions: number;
+    operationMonthlyReturnMXN: number;
+    operationAnnualReturnNetMXN: number;
+    operationMonthlyReturnNetMXN: number;
+    operationReturnHorizonNetMXN: number;
+    obraReturnMonthlyMXN: number;
+    obraReturnMonthlyNetMXN: number;
+    obraReturnNetMXN: number;
+    patrimonioTotalMXN: number;
+    plusvaliaGainMXN: number;
+    pricePerActionMXN: number;
+    projectedAssetValueMXN: number;
+    scheme: {
+        readonly id: "contado";
+        readonly description: "Liquidas tu acción en una sola exhibición y accedes a tasa preferencial desde el mes 1.";
+        readonly engancheRatio: 1;
+        readonly label: "Contado";
+        readonly monthlyCount: 0;
+        readonly monthlyRatio: 0;
+        readonly tag: "Máximo rendimiento";
+        readonly tasaObra: 0.08;
+        readonly tasaObraLabel: "8%";
+    } | {
+        readonly id: "medio";
+        readonly description: "Enganche de $120K y 5 mensualidades de $40K. Rendimiento del 6% anual una vez liquidado el capital.";
+        readonly engancheRatio: number;
+        readonly label: "Financiado 5 meses";
+        readonly monthlyCount: 5;
+        readonly monthlyRatio: number;
+        readonly tag: "Balance";
+        readonly tasaObra: 0.06;
+        readonly tasaObraLabel: "6%";
+    } | {
+        readonly id: "amplio";
+        readonly description: "Enganche de $60K y 13 mensualidades de $20K. Rendimiento del 4% anual una vez liquidado el capital.";
+        readonly engancheRatio: number;
+        readonly label: "Financiado 13 meses";
+        readonly monthlyCount: 13;
+        readonly monthlyRatio: number;
+        readonly tag: "Más accesible";
+        readonly tasaObra: 0.04;
+        readonly tasaObraLabel: "4%";
+    };
+    totalMonths: 0 | 5 | 13;
+    totalPaidMXN: number;
+};
+export {};

package/dist/entrada.js

@@ -0,0 +1,139 @@
+import { getUnitListPriceMXN } from "./payment-schemes.js";
+import { getEscalatedAmountOverHorizonMXN } from "./corporate-rent.js";
+const APARTMENT_TOTAL_PARTS = 6;
+const APARTMENT_COPROP_PRICE_MULTIPLIER = 1.05;
+const APARTMENT_ENGANCHE_RATIO = 60000 / 325000;
+const APARTMENT_SALDO_FINAL_RATIO = 60000 / 325000;
+const APARTMENT_MENSUALIDAD_RATIO = 6000 / 325000;
+const APARTMENT_TOTAL_RENT_RATIO = 18000 / 1950000;
+const APARTMENT_DELIVERY_VALUE_RATIO = 2900000 / 1950000;
+const CORPORATE_PLUSVALIA_ANUAL = 0.1;
+const CORPORATE_ISR_RETENCION = 0.1;
+const CORPORATE_HORIZONTE_YEARS = 7;
+const CORPORATE_OBRA_MESES = 39;
+export const ENTRADA_BOOKING_AMOUNT_MXN = 10000;
+export const APARTMENT_TOTAL_MONTHS = 36;
+export const ENTRADA_ACTION_SCHEMES = [
+    {
+        id: "contado",
+        description: "Liquidas tu acción en una sola exhibición y accedes a tasa preferencial desde el mes 1.",
+        engancheRatio: 1,
+        label: "Contado",
+        monthlyCount: 0,
+        monthlyRatio: 0,
+        tag: "Máximo rendimiento",
+        tasaObra: 0.08,
+        tasaObraLabel: "8%",
+    },
+    {
+        id: "medio",
+        description: "Enganche de $120K y 5 mensualidades de $40K. Rendimiento del 6% anual una vez liquidado el capital.",
+        engancheRatio: 120000 / 320000,
+        label: "Financiado 5 meses",
+        monthlyCount: 5,
+        monthlyRatio: 40000 / 320000,
+        tag: "Balance",
+        tasaObra: 0.06,
+        tasaObraLabel: "6%",
+    },
+    {
+        id: "amplio",
+        description: "Enganche de $60K y 13 mensualidades de $20K. Rendimiento del 4% anual una vez liquidado el capital.",
+        engancheRatio: 60000 / 320000,
+        label: "Financiado 13 meses",
+        monthlyCount: 13,
+        monthlyRatio: 20000 / 320000,
+        tag: "Más accesible",
+        tasaObra: 0.04,
+        tasaObraLabel: "4%",
+    },
+];
+function roundCurrency(value) {
+    return Math.round(value);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function getActionScheme(schemeId) {
+    return (ENTRADA_ACTION_SCHEMES.find((scheme) => scheme.id === schemeId) ??
+        ENTRADA_ACTION_SCHEMES[0]);
+}
+export function getApartmentPartValueMXN(unit) {
+    return getUnitListPriceMXN(unit) / APARTMENT_TOTAL_PARTS;
+}
+export function buildApartmentPlan(unit, requestedParts, rentalRate) {
+    const numParts = clamp(requestedParts, 1, APARTMENT_TOTAL_PARTS);
+    const fullLotValueMXN = getUnitListPriceMXN(unit) * APARTMENT_COPROP_PRICE_MULTIPLIER;
+    const partValueMXN = fullLotValueMXN / APARTMENT_TOTAL_PARTS;
+    const totalRentMonthlyMXN = typeof rentalRate === "number"
+        ? (fullLotValueMXN * Math.max(rentalRate, 0)) / 12
+        : fullLotValueMXN * APARTMENT_TOTAL_RENT_RATIO;
+    const deliveryValueMXN = fullLotValueMXN * APARTMENT_DELIVERY_VALUE_RATIO;
+    const yourValueMXN = partValueMXN * numParts;
+    const engancheMXN = roundCurrency(yourValueMXN * APARTMENT_ENGANCHE_RATIO);
+    const monthlyPaymentMXN = roundCurrency(yourValueMXN * APARTMENT_MENSUALIDAD_RATIO);
+    const saldoFinalMXN = roundCurrency(yourValueMXN * APARTMENT_SALDO_FINAL_RATIO);
+    return {
+        deliveryValueMXN: roundCurrency((deliveryValueMXN / APARTMENT_TOTAL_PARTS) * numParts),
+        engancheMXN,
+        fullLotValueMXN: roundCurrency(fullLotValueMXN),
+        monthlyPaymentMXN,
+        numParts,
+        rentaMensualMXN: roundCurrency((totalRentMonthlyMXN / APARTMENT_TOTAL_PARTS) * numParts),
+        saldoFinalMXN,
+        totalMonths: APARTMENT_TOTAL_MONTHS,
+        totalToPayMXN: engancheMXN + monthlyPaymentMXN * APARTMENT_TOTAL_MONTHS + saldoFinalMXN,
+        yourValueMXN: roundCurrency(yourValueMXN),
+    };
+}
+export function getCorporatePricePerActionMXN(unit, totalShares) {
+    return getUnitListPriceMXN(unit) / Math.max(totalShares, 1);
+}
+export function getCorporateM2PerAction(unit, totalShares) {
+    return unit.areaM2 / Math.max(totalShares, 1);
+}
+export function buildCorporatePlan(args) {
+    const scheme = getActionScheme(args.requestedSchemeId);
+    const numActions = clamp(args.numActions, 1, 5);
+    const pricePerActionMXN = getCorporatePricePerActionMXN(args.unit, args.totalShares);
+    const m2PerAction = getCorporateM2PerAction(args.unit, args.totalShares);
+    const capitalMXN = pricePerActionMXN * numActions;
+    const engancheMXN = roundCurrency(capitalMXN * scheme.engancheRatio);
+    const monthlyPaymentMXN = roundCurrency(capitalMXN * scheme.monthlyRatio);
+    const monthsLiquidated = CORPORATE_OBRA_MESES - scheme.monthlyCount;
+    const obraMonthlyReturnMXN = (capitalMXN * scheme.tasaObra) / 12;
+    const obraMonthlyReturnNetMXN = obraMonthlyReturnMXN * (1 - CORPORATE_ISR_RETENCION);
+    const obraReturnNetMXN = obraMonthlyReturnNetMXN * monthsLiquidated;
+    const obraYearsFloat = CORPORATE_OBRA_MESES / 12;
+    const operationYears = CORPORATE_HORIZONTE_YEARS - obraYearsFloat;
+    const operationMonthlyReturnMXN = (capitalMXN * Math.max(args.rentalRate, 0)) / 12;
+    const operationMonthlyReturnNetMXN = operationMonthlyReturnMXN * (1 - CORPORATE_ISR_RETENCION);
+    const operationAnnualReturnNetMXN = operationMonthlyReturnNetMXN * 12;
+    const operationReturnHorizonNetMXN = getEscalatedAmountOverHorizonMXN(operationAnnualReturnNetMXN, args.inflationRate, operationYears);
+    const projectedAssetValueMXN = capitalMXN *
+        Math.pow(1 + CORPORATE_PLUSVALIA_ANUAL, CORPORATE_HORIZONTE_YEARS);
+    const plusvaliaGainMXN = projectedAssetValueMXN - capitalMXN;
+    const patrimonioTotalMXN = projectedAssetValueMXN + obraReturnNetMXN + operationReturnHorizonNetMXN;
+    return {
+        capitalMXN: roundCurrency(capitalMXN),
+        engancheMXN,
+        m2: m2PerAction * numActions,
+        monthlyCount: scheme.monthlyCount,
+        monthlyPaymentMXN,
+        numActions,
+        operationMonthlyReturnMXN: roundCurrency(operationMonthlyReturnMXN),
+        operationAnnualReturnNetMXN: roundCurrency(operationAnnualReturnNetMXN),
+        operationMonthlyReturnNetMXN: roundCurrency(operationMonthlyReturnNetMXN),
+        operationReturnHorizonNetMXN: roundCurrency(operationReturnHorizonNetMXN),
+        obraReturnMonthlyMXN: roundCurrency(obraMonthlyReturnMXN),
+        obraReturnMonthlyNetMXN: roundCurrency(obraMonthlyReturnNetMXN),
+        obraReturnNetMXN: roundCurrency(obraReturnNetMXN),
+        patrimonioTotalMXN: roundCurrency(patrimonioTotalMXN),
+        plusvaliaGainMXN: roundCurrency(plusvaliaGainMXN),
+        pricePerActionMXN: roundCurrency(pricePerActionMXN),
+        projectedAssetValueMXN: roundCurrency(projectedAssetValueMXN),
+        scheme,
+        totalMonths: scheme.monthlyCount,
+        totalPaidMXN: roundCurrency(capitalMXN),
+    };
+}

package/dist/format.d.ts

@@ -0,0 +1,7 @@
+export declare function formatCurrency(value: number): string;
+export declare function formatCurrencyPrecise(value: number): string;
+export declare function formatCompactCurrency(value: number): string;
+export declare function formatPricePerM2(value: number): string;
+export declare function formatArea(value: number): string;
+export declare function formatPercent(value: number): string;
+export declare function formatYears(value: number): string;

package/dist/format.js

@@ -0,0 +1,37 @@
+const currencyFormatter = new Intl.NumberFormat("es-MX", {
+    style: "currency",
+    currency: "MXN",
+    maximumFractionDigits: 0,
+});
+const preciseCurrencyFormatter = new Intl.NumberFormat("es-MX", {
+    style: "currency",
+    currency: "MXN",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+export function formatCurrency(value) {
+    return currencyFormatter.format(value);
+}
+export function formatCurrencyPrecise(value) {
+    return preciseCurrencyFormatter.format(value);
+}
+export function formatCompactCurrency(value) {
+    const absolute = Math.abs(value);
+    if (absolute >= 1000000) {
+        const sign = value < 0 ? "-" : "";
+        return `${sign}$${(absolute / 1000000).toFixed(2)}M`;
+    }
+    return formatCurrency(value);
+}
+export function formatPricePerM2(value) {
+    return `${formatCurrencyPrecise(value)}/m²`;
+}
+export function formatArea(value) {
+    return `${value.toFixed(2)} m²`;
+}
+export function formatPercent(value) {
+    return `${value}%`;
+}
+export function formatYears(value) {
+    return `${value} año${value === 1 ? "" : "s"}`;
+}

package/dist/http.d.ts

@@ -0,0 +1,29 @@
+import type { DesarrolloInventoryRequest, DesarrolloRequest, DesarrolloSitemapRequest, DesarrollosApiBaseOptions, DesarrollosApiErrorBody, CreatePublicReservationRequest, CreatePublicSessionRequest, GetPublicReservationRequest, PublicDevelopmentsResponse, PublicInventoryResponse, PublicInstancesResponse, PublicPaymentMethodsResponse, PublicReservationStatus, PublicSessionResponse, PublicSitemapResponse, PublicSnapshotResponse } from "./types.js";
+type Credential = {
+    kind: "apiKey";
+    value: string;
+} | {
+    kind: "session";
+    value: string;
+};
+export declare class DesarrollosApiError extends Error {
+    code?: string;
+    fieldErrors?: Record<string, string>;
+    response: Response;
+    status: number;
+    constructor(response: Response, body: DesarrollosApiErrorBody);
+}
+export declare function createDesarrollosApiRequester(options: DesarrollosApiBaseOptions): {
+    getAgentGuide: () => Promise<Record<string, unknown>>;
+    getOpenApi: () => Promise<Record<string, unknown>>;
+    listDevelopments: (credential: Credential) => Promise<PublicDevelopmentsResponse>;
+    listInstances: (args: Pick<DesarrolloRequest, "desarrolloKey">) => Promise<PublicInstancesResponse>;
+    getSnapshot: (args: DesarrolloRequest) => Promise<PublicSnapshotResponse>;
+    getInventory: (args: DesarrolloInventoryRequest) => Promise<PublicInventoryResponse>;
+    getSitemap: (args: DesarrolloSitemapRequest) => Promise<PublicSitemapResponse>;
+    getPaymentMethods: (args: DesarrolloRequest) => Promise<PublicPaymentMethodsResponse>;
+    createSession: (args: CreatePublicSessionRequest, credential: Credential) => Promise<PublicSessionResponse>;
+    createReservation: (args: CreatePublicReservationRequest, credential: Credential) => Promise<PublicReservationStatus>;
+    getReservation: (args: GetPublicReservationRequest, credential: Credential) => Promise<PublicReservationStatus>;
+};
+export {};

package/dist/http.js

@@ -0,0 +1,123 @@
+export class DesarrollosApiError extends Error {
+    constructor(response, body) {
+        super(body.message);
+        this.name = "DesarrollosApiError";
+        this.code = body.code;
+        this.fieldErrors = body.fieldErrors;
+        this.response = response;
+        this.status = response.status;
+    }
+}
+function trimSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function normalizeBaseUrl(baseUrl) {
+    const trimmed = trimSlashes(baseUrl.trim());
+    if (!trimmed) {
+        throw new Error("Desarrollos SDK baseUrl is required.");
+    }
+    return trimmed;
+}
+function getFetch(customFetch) {
+    const fetchImpl = customFetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error("Desarrollos SDK requires a fetch implementation in this runtime.");
+    }
+    return fetchImpl;
+}
+function appendInstanceSlug(params, instanceSlug) {
+    if (instanceSlug) {
+        params.set("instanceSlug", instanceSlug);
+    }
+}
+function buildQuery(args) {
+    const params = new URLSearchParams();
+    appendInstanceSlug(params, args.instanceSlug);
+    if (args.unitIds && args.unitIds.length > 0) {
+        params.set("unitIds", args.unitIds.join(","));
+    }
+    if (args.includeShapes === false) {
+        params.set("includeShapes", "false");
+    }
+    const query = params.toString();
+    return query ? `?${query}` : "";
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(value);
+}
+function credentialHeaders(credential) {
+    if (!credential) {
+        return [];
+    }
+    return credential.kind === "apiKey"
+        ? [["x-lapa-api-key", credential.value]]
+        : [["x-lapa-session", credential.value]];
+}
+function buildHeaders(headers, credential) {
+    const requestHeaders = new Headers(headers);
+    requestHeaders.set("Accept", requestHeaders.get("Accept") ?? "application/json");
+    for (const [name, value] of credentialHeaders(credential)) {
+        requestHeaders.set(name, value);
+    }
+    return requestHeaders;
+}
+async function readJsonResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    const isJson = contentType.includes("application/json");
+    const body = isJson ? await response.json() : null;
+    if (!response.ok) {
+        throw new DesarrollosApiError(response, {
+            message: body && typeof body.message === "string"
+                ? body.message
+                : `Desarrollos API request failed with status ${response.status}.`,
+            code: body && typeof body.code === "string" ? body.code : undefined,
+            fieldErrors: body &&
+                typeof body.fieldErrors === "object" &&
+                body.fieldErrors !== null
+                ? body.fieldErrors
+                : undefined,
+        });
+    }
+    return body;
+}
+export function createDesarrollosApiRequester(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const fetchImpl = getFetch(options.fetch);
+    async function requestJson(path, init = {}) {
+        const { credential, headers, ...requestInit } = init;
+        const response = await fetchImpl(`${baseUrl}${path}`, {
+            ...requestInit,
+            headers: buildHeaders(headers, credential),
+        });
+        return await readJsonResponse(response);
+    }
+    return {
+        getAgentGuide: () => requestJson("/agent.json"),
+        getOpenApi: () => requestJson("/openapi.json"),
+        listDevelopments: (credential) => requestJson("/", { credential }),
+        listInstances: (args) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/instances`),
+        getSnapshot: (args) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/snapshot${buildQuery(args)}`),
+        getInventory: (args) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/inventory${buildQuery(args)}`),
+        getSitemap: (args) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/sitemap${buildQuery(args)}`),
+        getPaymentMethods: (args) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/payment-methods${buildQuery(args)}`),
+        createSession: (args, credential) => requestJson("/sessions", {
+            body: JSON.stringify({
+                desarrolloKey: args.desarrolloKey,
+                origin: args.origin,
+            }),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
+        createReservation: (args, credential) => requestJson(`/${encodePathSegment(args.desarrolloKey)}/reservations`, {
+            body: JSON.stringify({
+                ...args.request,
+                instanceSlug: args.request.instanceSlug ?? args.instanceSlug,
+            }),
+            credential,
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+        }),
+        getReservation: (args, credential) => requestJson(`/reservations/${encodePathSegment(args.externalReference)}`, { credential }),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { DesarrollosApiError } from "./http.js";
+import type { DesarrollosApiBaseOptions, CreatePublicReservationRequest, GetPublicReservationRequest } from "./types.js";
+export { DesarrollosApiError };
+export type * from "./types.js";
+export declare function createDesarrollosClient(options: DesarrollosApiBaseOptions): {
+    createReservation: (args: CreatePublicReservationRequest) => Promise<import("./types").PublicReservationStatus>;
+    getAgentGuide: () => Promise<Record<string, unknown>>;
+    getInventory: (args: import("./types").DesarrolloInventoryRequest) => Promise<import("./types").PublicInventoryResponse>;
+    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>;
+};

package/dist/index.js

@@ -0,0 +1,22 @@
+import { DesarrollosApiError, createDesarrollosApiRequester } from "./http.js";
+export { DesarrollosApiError };
+export function createDesarrollosClient(options) {
+    const api = createDesarrollosApiRequester(options);
+    function requireSessionToken(sessionToken) {
+        if (!sessionToken) {
+            throw new Error("A desarrollos session token is required for browser write methods.");
+        }
+        return { kind: "session", value: sessionToken };
+    }
+    return {
+        createReservation: async (args) => api.createReservation(args, requireSessionToken(args.sessionToken)),
+        getAgentGuide: api.getAgentGuide,
+        getInventory: api.getInventory,
+        getOpenApi: api.getOpenApi,
+        getPaymentMethods: api.getPaymentMethods,
+        getReservation: async (args) => api.getReservation(args, requireSessionToken(args.sessionToken)),
+        getSitemap: api.getSitemap,
+        getSnapshot: api.getSnapshot,
+        listInstances: api.listInstances,
+    };
+}

package/dist/installment-allocation.d.ts

@@ -0,0 +1,30 @@
+export declare const INSTALLMENT_DOWN_PAYMENT_RANGE: {
+    readonly min: 20;
+    readonly max: 100;
+    readonly step: 5;
+};
+export declare const INSTALLMENT_MONTHLY_BASE_RANGE: {
+    readonly min: 20;
+    readonly max: 40;
+    readonly step: 5;
+};
+export declare const INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT = 40;
+export declare const INSTALLMENT_DEFAULT_MONTHLY_PCT = 20;
+export declare const INSTALLMENT_DISCOUNT_THRESHOLD_PCT = 30;
+export declare const INSTALLMENT_DISCOUNT_INCREMENT_PCT = 10;
+export declare const INSTALLMENT_DISCOUNT_STEP_PCT = 1.25;
+export declare function getInstallmentDiscountPct(downPaymentPct: number): number;
+export declare function clampInstallmentDownPaymentPct(value: number): number;
+export declare function getInstallmentMonthlyRange(downPaymentPct: number): {
+    min: number;
+    max: number;
+    step: 5;
+};
+export declare function clampInstallmentMonthlyPct(monthlyPct: number, downPaymentPct: number): number;
+export interface InstallmentAllocation {
+    downPaymentPct: number;
+    monthlyPct: number;
+    deferredPct: number;
+    deliveryPct: number;
+}
+export declare function getInstallmentAllocation(downPaymentPct: number, monthlyPct: number): InstallmentAllocation;

package/dist/installment-allocation.js

@@ -0,0 +1,69 @@
+export const INSTALLMENT_DOWN_PAYMENT_RANGE = {
+    min: 20,
+    max: 100,
+    step: 5,
+};
+export const INSTALLMENT_MONTHLY_BASE_RANGE = {
+    min: 20,
+    max: 40,
+    step: 5,
+};
+export const INSTALLMENT_DEFAULT_DOWN_PAYMENT_PCT = 40;
+export const INSTALLMENT_DEFAULT_MONTHLY_PCT = 20;
+export const INSTALLMENT_DISCOUNT_THRESHOLD_PCT = 30;
+export const INSTALLMENT_DISCOUNT_INCREMENT_PCT = 10;
+export const INSTALLMENT_DISCOUNT_STEP_PCT = 1.25;
+export function getInstallmentDiscountPct(downPaymentPct) {
+    if (downPaymentPct < INSTALLMENT_DISCOUNT_THRESHOLD_PCT) {
+        return 0;
+    }
+    const steps = Math.floor((downPaymentPct - INSTALLMENT_DISCOUNT_THRESHOLD_PCT) /
+        INSTALLMENT_DISCOUNT_INCREMENT_PCT);
+    return (steps + 1) * INSTALLMENT_DISCOUNT_STEP_PCT;
+}
+const INSTALLMENT_BASE_DOWN_PAYMENT_PCT = INSTALLMENT_DOWN_PAYMENT_RANGE.min;
+const INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT = INSTALLMENT_MONTHLY_BASE_RANGE.max;
+function clampToRangeBounds(value, min, max, step) {
+    const clamped = Math.min(max, Math.max(min, value));
+    return min + Math.round((clamped - min) / step) * step;
+}
+export function clampInstallmentDownPaymentPct(value) {
+    return clampToRangeBounds(value, INSTALLMENT_DOWN_PAYMENT_RANGE.min, INSTALLMENT_DOWN_PAYMENT_RANGE.max, INSTALLMENT_DOWN_PAYMENT_RANGE.step);
+}
+export function getInstallmentMonthlyRange(downPaymentPct) {
+    const downPct = clampInstallmentDownPaymentPct(downPaymentPct);
+    const totalRemaining = 100 - downPct;
+    const max = Math.min(INSTALLMENT_MONTHLY_BASE_RANGE.max, totalRemaining);
+    const min = Math.min(INSTALLMENT_MONTHLY_BASE_RANGE.min, max);
+    return { min, max, step: INSTALLMENT_MONTHLY_BASE_RANGE.step };
+}
+export function clampInstallmentMonthlyPct(monthlyPct, downPaymentPct) {
+    const range = getInstallmentMonthlyRange(downPaymentPct);
+    return clampToRangeBounds(monthlyPct, range.min, range.max, range.step);
+}
+export function getInstallmentAllocation(downPaymentPct, monthlyPct) {
+    const downPct = clampInstallmentDownPaymentPct(downPaymentPct);
+    const baseMonthly = clampInstallmentMonthlyPct(monthlyPct, downPct);
+    const baseDeferred = INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT - baseMonthly;
+    const baseDelivery = 100 -
+        INSTALLMENT_BASE_DOWN_PAYMENT_PCT -
+        INSTALLMENT_BASE_MONTHLY_PLUS_DEFERRED_PCT;
+    let extra = Math.max(0, downPct - INSTALLMENT_BASE_DOWN_PAYMENT_PCT);
+    let delivery = baseDelivery;
+    let deferred = baseDeferred;
+    let monthly = baseMonthly;
+    const fromDeferred = Math.min(deferred, extra);
+    deferred -= fromDeferred;
+    extra -= fromDeferred;
+    const fromDelivery = Math.min(delivery, extra);
+    delivery -= fromDelivery;
+    extra -= fromDelivery;
+    const fromMonthly = Math.min(monthly, extra);
+    monthly -= fromMonthly;
+    return {
+        downPaymentPct: downPct,
+        monthlyPct: monthly,
+        deferredPct: deferred,
+        deliveryPct: delivery,
+    };
+}

package/dist/inventory-availability.d.ts

@@ -0,0 +1,10 @@
+import type { AppContent, InventoryAvailability, InventoryAvailabilityByUnitId, InventoryStatus, InventoryStatusLabels, InventoryUnit } from "./types.js";
+type PaidShareSalesByProductTypeId = Record<string, number>;
+export declare function buildInventoryAvailabilityByUnitId(content: AppContent, paidShareSalesByProductTypeId?: PaidShareSalesByProductTypeId): InventoryAvailabilityByUnitId;
+export declare function getInventoryAvailability(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): InventoryAvailability | null;
+export declare function getResolvedInventoryStatus(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): InventoryStatus | null;
+export declare function canCheckoutInventoryUnit(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): boolean;
+export declare function canCheckoutInventoryQuantity(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId, quantity: number): boolean;
+export declare function getResolvedInventoryStatusLabel(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId, statusLabels: InventoryStatusLabels): string;
+export declare function getResolvedShareSummary(unit: InventoryUnit | null | undefined, availabilityByUnitId: InventoryAvailabilityByUnitId): import("./types").InventoryShareAvailability | null;
+export {};