@evinvest/sites-contract 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,26 @@
-# Temporary Holding Version
+# @evinvest/sites-contract
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Service-Arb sites ↔ panel contract, in TS: what a landing reads from the panel and sends
+to it. Its source is the panel — `crates/panel_core` and `contracts/proto/sa/v1` in
+[EV-Service-Arb/sites_panel](https://github.com/EV-Service-Arb/sites_panel) — and this is its
+only TS form. No runtime dependencies, no Node imports: it is bundled into landing pages and
+the panel's front end.
+
+```text
+src/generated/contract.ts  panel_core's shapes, vocabularies and limits (`nix run .#gen`)
+src/generated/wire.ts      the protos as protojson: the envelope, every type's properties
+src/*.ts                   the one TS implementation of what both sides run, held to
+                           contracts/vectors with panel_core:
+  pricing    checkPricingModel, priceOf
+  booking    checkBookingConfig, checkBookingUrl, bookingRequested, isLeadRef
+  place      checkPlaceLive: a place's live settings, field by field
+  phone      normalizePhone, phoneProblem
+  ingest     siteEvent, ingestBody, uuidV7, isOpaqueId: the only way a site builds an event
+  experiments parseLiveExperiments, declarationProblem
+```
+
+Checks answer `{ path, code }` problems, never words: a site logs them, the panel's editor says
+each code in its own copy.
+
+Release: bump `version`, commit, push the tag `@evinvest/sites-contract-v<version>`; CI
+(`release-npm.yml`) publishes it.

package/dist/booking.d.ts

@@ -0,0 +1,42 @@
+import { type BookingCode, type BookingConfig, type BookingProvider, type DayPart, type PageProvider } from "./generated/contract.js";
+import type { BookingRequestedV1 } from "./generated/wire.js";
+/** One thing wrong with a place's `booking`: where below it (`""`, `default`, `providers.cal_com.url`) and why. */
+export interface BookingProblem {
+    path: string;
+    code: BookingCode;
+}
+export declare const isBookingProvider: (v: unknown) => v is BookingProvider;
+export declare const isPageProvider: (v: unknown) => v is PageProvider;
+/** `lead-<row>-<8 lowercase hex>`, the row 1 or more: the panel's lead id for a site's lead. */
+export declare const isLeadRef: (v: unknown) => v is string;
+/**
+ * Why `url` may not be `provider`'s booking page, or `null` (`contracts/vectors/booking/README.md`,
+ * normative): at most 2048 printable ASCII; the literal `https://`; no `#` and no `\`; an
+ * authority without `@`, `:` or `[`; a dotted DNS name whose last label is not a number; then
+ * the provider's own rule.
+ */
+export declare function checkBookingUrl(provider: PageProvider, url: string): BookingCode | null;
+/**
+ * A place's `booking` checked whole: every problem, and the config when there is none. `manual`
+ * is always available, so never a key of `providers`; the default is `manual` or one of them.
+ */
+export declare function checkBookingConfig(v: unknown): {
+    problems: BookingProblem[];
+    config: BookingConfig | null;
+};
+/** `booking.requested@1`'s properties, their vocabularies as the panel checks them. */
+export type BookingRequested = BookingRequestedV1 & {
+    provider: BookingProvider;
+    preferred_part?: DayPart;
+};
+/**
+ * `booking.requested@1`'s properties, or `null` when the panel would refuse them: a lead ref, a
+ * provider and, with `manual` only, a day and a part of the day. No null, nothing else, no free
+ * text.
+ */
+export declare function bookingRequested(v: unknown): BookingRequested | null;
+/**
+ * Whether a visitor's preferred day may be asked for on `today` (both `YYYY-MM-DD`): two days
+ * back (clocks, an outbox's delay) to a year and a day ahead. The panel checks it on arrival.
+ */
+export declare function preferredDateInWindow(day: string, today: string): boolean;

package/dist/booking.js

@@ -0,0 +1,137 @@
+import { BOOKING_LIMITS as LIMIT, BOOKING_PROVIDERS, DAY_PARTS, PAGE_PROVIDERS, } from "./generated/contract.js";
+import { at, isDate, isObject } from "./text.js";
+export const isBookingProvider = (v) => BOOKING_PROVIDERS.some(p => p === v);
+export const isPageProvider = (v) => PAGE_PROVIDERS.some(p => p === v);
+const LEAD_REF = new RegExp(LIMIT.leadRef);
+const CAL_SEGMENT = new RegExp(LIMIT.calComSegment);
+const LABEL = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+const APPOINTMENTS = "/calendar/appointments/";
+/** `lead-<row>-<8 lowercase hex>`, the row 1 or more: the panel's lead id for a site's lead. */
+export const isLeadRef = (v) => typeof v === "string" && LEAD_REF.test(v);
+/**
+ * Why `url` may not be `provider`'s booking page, or `null` (`contracts/vectors/booking/README.md`,
+ * normative): at most 2048 printable ASCII; the literal `https://`; no `#` and no `\`; an
+ * authority without `@`, `:` or `[`; a dotted DNS name whose last label is not a number; then
+ * the provider's own rule.
+ */
+export function checkBookingUrl(provider, url) {
+    if (url.length === 0 || url.length > LIMIT.maxUrl || !/^[\x21-\x7e]+$/.test(url))
+        return "format";
+    if (!url.startsWith("https://"))
+        return "scheme";
+    if (url.includes("#"))
+        return "fragment";
+    if (url.includes("\\"))
+        return "backslash";
+    const rest = url.slice("https://".length);
+    const split = rest.search(/[/?]/);
+    const host = split < 0 ? rest : rest.slice(0, split);
+    if (host.includes("@"))
+        return "userinfo";
+    if (host.startsWith("["))
+        return "ip";
+    if (host.includes(":"))
+        return "port";
+    const labels = host.split(".");
+    if (host.length > 253 || labels.length < 2 || !labels.every(l => LABEL.test(l)))
+        return "host";
+    const last = (labels.at(-1) ?? "").toLowerCase();
+    // A WHATWG parser reads a host whose last label is a number as an IPv4 address.
+    if (/^\d+$/.test(last) || last.startsWith("0x"))
+        return "ip";
+    const name = host.toLowerCase();
+    const path = (split < 0 ? "" : rest.slice(split)).split("?")[0] ?? "";
+    switch (provider) {
+        case "link":
+            return null;
+        case "google_calendar":
+            return (name === "calendar.app.google" && path.length > 1) || (name === "calendar.google.com" && path.length > APPOINTMENTS.length && path.startsWith(APPOINTMENTS)) ? null : "google";
+        case "cal_com": {
+            if (!LIMIT.calComHosts.some(h => h === name))
+                return "cal_host";
+            const segments = path.replace(/^\//, "").split("/");
+            return path.startsWith("/") && segments.length === 2 && segments.every(s => CAL_SEGMENT.test(s)) ? null : "cal_path";
+        }
+    }
+}
+/**
+ * A place's `booking` checked whole: every problem, and the config when there is none. `manual`
+ * is always available, so never a key of `providers`; the default is `manual` or one of them.
+ */
+export function checkBookingConfig(v) {
+    const problems = [];
+    const fail = (path, code) => problems.push({ path, code });
+    if (!isObject(v))
+        return { problems: [{ path: "", code: "shape" }], config: null };
+    if (Object.keys(v).some(k => k !== "default" && k !== "providers"))
+        fail("", "unknown_key");
+    const def = isBookingProvider(v.default) ? v.default : null;
+    if (!Object.hasOwn(v, "default"))
+        fail("default", "required");
+    else if (def === null)
+        fail("default", "default_unknown");
+    const providers = {};
+    if (!Object.hasOwn(v, "providers"))
+        fail("providers", "required");
+    else if (!isObject(v.providers))
+        fail("providers", "shape");
+    else
+        for (const [name, conf] of Object.entries(v.providers)) {
+            const path = at("providers", name);
+            if (!isBookingProvider(name))
+                fail(path, "provider_unknown");
+            else if (!isObject(conf))
+                fail(path, "provider_shape");
+            else if (Object.keys(conf).some(k => k !== "url"))
+                fail(path, "provider_extra");
+            else if (!isPageProvider(name))
+                fail(path, "manual");
+            else if (!Object.hasOwn(conf, "url"))
+                fail(at(path, "url"), "required");
+            else if (typeof conf.url !== "string")
+                fail(at(path, "url"), "url_type");
+            else {
+                const bad = checkBookingUrl(name, conf.url);
+                if (bad)
+                    fail(at(path, "url"), bad);
+                else
+                    providers[name] = { url: conf.url };
+            }
+        }
+    // A default whose own entry is refused is blamed there, not twice.
+    if (isPageProvider(def) && !Object.hasOwn(providers, def) && !problems.some(p => p.path.startsWith(at("providers", def))))
+        fail("default", "default_unset");
+    return problems.length > 0 || def === null ? { problems, config: null } : { problems, config: { default: def, providers } };
+}
+const isDayPart = (v) => DAY_PARTS.some(p => p === v);
+/**
+ * `booking.requested@1`'s properties, or `null` when the panel would refuse them: a lead ref, a
+ * provider and, with `manual` only, a day and a part of the day. No null, nothing else, no free
+ * text.
+ */
+export function bookingRequested(v) {
+    if (!isObject(v) || Object.entries(v).some(([k, x]) => x === null || !["lead_ref", "provider", "preferred_date", "preferred_part"].includes(k)))
+        return null;
+    const { lead_ref, provider, preferred_date, preferred_part } = v;
+    if (!isLeadRef(lead_ref) || !isBookingProvider(provider))
+        return null;
+    if ((preferred_date !== undefined && !isDate(preferred_date)) || (preferred_part !== undefined && !isDayPart(preferred_part)))
+        return null;
+    if (provider !== "manual" && (preferred_date !== undefined || preferred_part !== undefined))
+        return null;
+    return {
+        lead_ref,
+        provider,
+        ...(preferred_date !== undefined ? { preferred_date } : {}),
+        ...(preferred_part !== undefined ? { preferred_part } : {}),
+    };
+}
+const DAY_MS = 86_400_000;
+/**
+ * Whether a visitor's preferred day may be asked for on `today` (both `YYYY-MM-DD`): two days
+ * back (clocks, an outbox's delay) to a year and a day ahead. The panel checks it on arrival.
+ */
+export function preferredDateInWindow(day, today) {
+    const days = (Date.parse(`${day}T00:00:00Z`) - Date.parse(`${today}T00:00:00Z`)) / DAY_MS;
+    return days >= -2 && days <= 366;
+}

package/dist/experiments.d.ts

@@ -0,0 +1,18 @@
+import { type LiveExperiments } from "./generated/contract.js";
+import type { ExperimentDeclaration } from "./generated/wire.js";
+/**
+ * The panel's answer to `GET …/brands/{brand}/experiments`, or `null` when it is not one: an
+ * override whose field has another type is not the panel's. Fields the panel added since are
+ * passed over. Whether an override fits the experiment in code (weights of the right length, a
+ * holdout in `[0, 1)`) is `applyOverrides`' call: only it knows the code's variants.
+ */
+export declare function parseLiveExperiments(body: unknown): LiveExperiments | null;
+/** Why the panel would refuse an experiment as declared. */
+export type DeclarationProblem = "key" | "variants" | "variant" | "duplicate_variant" | "weights" | "holdout" | "summary";
+/**
+ * Why the panel would refuse this experiment of `experiments.declared@1`, or `null`
+ * (`contracts/vectors/ingest/declarations.json`): a key; 2 to 32 variants, unique, each a slug;
+ * one weight per variant, each ≥ 0, their sum > 0; a holdout in `[0, 1)`; a summary of at most
+ * 200 characters once trimmed.
+ */
+export declare function declarationProblem(d: ExperimentDeclaration): DeclarationProblem | null;

package/dist/experiments.js

@@ -0,0 +1,56 @@
+import { EXPERIMENT_LIMITS } from "./generated/contract.js";
+import { charCount, isObject, trim } from "./text.js";
+/**
+ * The panel's answer to `GET …/brands/{brand}/experiments`, or `null` when it is not one: an
+ * override whose field has another type is not the panel's. Fields the panel added since are
+ * passed over. Whether an override fits the experiment in code (weights of the right length, a
+ * holdout in `[0, 1)`) is `applyOverrides`' call: only it knows the code's variants.
+ */
+export function parseLiveExperiments(body) {
+    if (!isObject(body) || !isObject(body.experiments))
+        return null;
+    const experiments = {};
+    for (const [key, entry] of Object.entries(body.experiments)) {
+        if (!isObject(entry))
+            return null;
+        const { enabled, weights, holdout } = entry;
+        if (enabled !== undefined && typeof enabled !== "boolean")
+            return null;
+        if (weights !== undefined && !(Array.isArray(weights) && weights.every(w => typeof w === "number")))
+            return null;
+        if (holdout !== undefined && typeof holdout !== "number")
+            return null;
+        experiments[key] = {
+            ...(enabled !== undefined ? { enabled } : {}),
+            ...(weights !== undefined ? { weights } : {}),
+            ...(holdout !== undefined ? { holdout } : {}),
+        };
+    }
+    return { experiments };
+}
+const KEY = new RegExp(EXPERIMENT_LIMITS.key);
+const VARIANT = new RegExp(EXPERIMENT_LIMITS.variant);
+/**
+ * Why the panel would refuse this experiment of `experiments.declared@1`, or `null`
+ * (`contracts/vectors/ingest/declarations.json`): a key; 2 to 32 variants, unique, each a slug;
+ * one weight per variant, each ≥ 0, their sum > 0; a holdout in `[0, 1)`; a summary of at most
+ * 200 characters once trimmed.
+ */
+export function declarationProblem(d) {
+    if (!KEY.test(d.key))
+        return "key";
+    if (d.variants.length < 2 || d.variants.length > EXPERIMENT_LIMITS.maxVariants)
+        return "variants";
+    if (!d.variants.every(v => VARIANT.test(v)))
+        return "variant";
+    if (new Set(d.variants).size !== d.variants.length)
+        return "duplicate_variant";
+    const weightsOk = d.weights.length === d.variants.length && d.weights.every(w => Number.isFinite(w) && w >= 0) && d.weights.reduce((a, b) => a + b, 0) > 0;
+    if (!weightsOk)
+        return "weights";
+    if (d.holdout !== undefined && !(Number.isFinite(d.holdout) && d.holdout >= 0 && d.holdout < 1))
+        return "holdout";
+    if (d.summary !== undefined && charCount(trim(d.summary)) > EXPERIMENT_LIMITS.maxSummary)
+        return "summary";
+    return null;
+}

package/dist/generated/contract.d.ts

@@ -0,0 +1,303 @@
+/**
+ * Adds `addCents` to the base.
+ */
+export type AddOption = {
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    addCents: number;
+};
+/**
+ * A storefront's address; its region and country are the site's.
+ */
+export type Address = {
+    street: string;
+    /**
+     * A French postal code: five digits.
+     */
+    postalCode: string;
+    locality: string;
+};
+/**
+ * A place's `booking` setting: the providers it has a page on, and the one it offers by
+ * default — `manual` or one of them. `manual` is always there, so never configured.
+ */
+export type BookingConfig = {
+    default: BookingProvider;
+    providers: {
+        [key in PageProvider]?: BookingPage;
+    };
+};
+/**
+ * A provider's booking page.
+ */
+export type BookingPage = {
+    url: string;
+};
+/**
+ * Where a slot is booked.
+ */
+export type BookingProvider = "manual" | "link" | "google_calendar" | "cal_com";
+/**
+ * A day of the week, as the hours name it.
+ */
+export type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday";
+/**
+ * `discountBp` taken off the subtotal, in basis points: 1 000 is 10 % off.
+ */
+export type DiscountOption = {
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    discountBp: number;
+};
+/**
+ * Degrees, on the globe.
+ */
+export type Geo = {
+    lat: number;
+    lng: number;
+};
+/**
+ * What a landing reads of its brand's experiments: the overrides of the current ones, by key.
+ */
+export type LiveExperiments = {
+    experiments: {
+        [key in string]: LiveOverride;
+    };
+};
+/**
+ * The fields of an override a landing takes, as it is sent them: only those set, each valid
+ * against the experiment's current declaration.
+ */
+export type LiveOverride = {
+    enabled?: boolean;
+    weights?: Array<number>;
+    holdout?: number;
+};
+/**
+ * A messenger the customer writes the brand on.
+ */
+export type Messenger = "whatsapp" | "telegram";
+/**
+ * The subtotal times `multiplyBp`, in basis points: 11 000 is ×1.1.
+ */
+export type MultiplyOption = {
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    multiplyBp: number;
+};
+/**
+ * How one need is priced.
+ */
+export type NeedPricing = {
+    "kind": "estimate";
+    baseCents: number;
+    inputs: Array<string>;
+} | {
+    "kind": "fixed";
+    cents: number;
+};
+/**
+ * A row of opening hours, in the place's local time (Europe/Paris for every place in v1).
+ */
+export type OpeningHours = {
+    /**
+     * One at least, each once, in week order.
+     */
+    days: Array<DayOfWeek>;
+    /**
+     * `HH:MM`.
+     */
+    opens: string;
+    /**
+     * After `opens`: a night across midnight is two rows.
+     */
+    closes: string;
+};
+/**
+ * A provider with a page of its own, which a place configures: every one but `manual`,
+ * which is always available.
+ */
+export type PageProvider = "link" | "google_calendar" | "cal_com";
+/**
+ * A place's live settings: only the fields that are set. Empty: the site serves its baked
+ * config.
+ */
+export type PlaceLive = {
+    phone?: string;
+    whatsapp?: string;
+    /**
+     * The place's Telegram bot: its username, without the `@`.
+     */
+    telegram?: string;
+    /**
+     * The landing's messenger buttons switched off where `false`; a messenger left out is on.
+     */
+    messengers?: {
+        [key in Messenger]?: boolean;
+    };
+    hours?: Array<OpeningHours>;
+    /**
+     * Commune names.
+     */
+    serviceArea?: Array<string>;
+    address?: Address;
+    geo?: Geo;
+    storefrontPhoto?: string;
+    /**
+     * A text per locale; a site keeps it only when every locale it speaks is there.
+     */
+    landmark?: {
+        [key in string]: string;
+    };
+    rating?: Rating;
+    booking?: BookingConfig;
+    /**
+     * Where the place asks for a Google review.
+     */
+    reviewUrl?: string;
+};
+/**
+ * An enum the visitor answers: bedrooms, a surface band, a zone, a frequency. Its kind says
+ * what its options do, and when: every `add` first, then every `multiply`, then every
+ * `discount`.
+ */
+export type PricingInput = {
+    "kind": "add";
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    options: Array<AddOption>;
+} | {
+    "kind": "multiply";
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    options: Array<MultiplyOption>;
+} | {
+    "kind": "discount";
+    id: string;
+    labels: {
+        [key in string]: string;
+    };
+    options: Array<DiscountOption>;
+};
+/**
+ * A checked model, in its wire shape: every value within the limits, which keeps a price
+ * within an `i64` and a double alike. Only [`PricingModel::parse`] makes one.
+ */
+export type PricingModel = {
+    format: 1;
+    currency: "EUR";
+    /**
+     * `YYYY-MM-DD`, a day the calendar has: when the prices hold from. Stored with every lead
+     * priced by it.
+     */
+    validFrom: string;
+    /**
+     * The estimate's total is rounded half up to a multiple of this (1 = to the cent).
+     */
+    roundToCents: number;
+    /**
+     * An estimate never comes out below this, after the rounding.
+     */
+    minimumCents: number;
+    inputs: Array<PricingInput>;
+    /**
+     * By the brand's need slug; a need not here is a quote.
+     */
+    needs: {
+        [key in string]: NeedPricing;
+    };
+};
+/**
+ * Google's rating for the place, with when it was read: the API's terms cap how long a copy
+ * may be shown.
+ */
+export type Rating = {
+    /**
+     * 1 to 5.
+     */
+    value: number;
+    count: number;
+    /**
+     * An RFC 3339 instant, as sent.
+     */
+    fetchedAt: string;
+};
+export declare const PRICING_FORMAT = 1;
+export declare const PRICING_CURRENCY = "EUR";
+export declare const PRICING_LIMITS: {
+    readonly locale: "^[a-z]{2}(-[A-Z]{2})?$";
+    readonly maxDiscountBp: 10000;
+    readonly maxInputs: 32;
+    readonly maxLabel: 120;
+    readonly maxMultiplyBp: 100000;
+    readonly maxNeedInputs: 12;
+    readonly maxNeeds: 64;
+    readonly maxOptions: 32;
+    readonly maxPriceCents: 100000000;
+    readonly slug: "^[a-z0-9_-]{1,40}$";
+};
+export declare const INPUT_KINDS: readonly ["add", "multiply", "discount"];
+export type PricingInputKind = (typeof INPUT_KINDS)[number];
+export declare const PRICING_CODES: readonly ["object", "missing", "unknownField", "format", "currency", "date", "int", "slug", "labels", "locale", "label", "list", "duplicate", "kind", "needKind", "noInput", "dearest", "labelMissing"];
+export type PricingCode = (typeof PRICING_CODES)[number];
+export declare const BOOKING_PROVIDERS: readonly ["manual", "link", "google_calendar", "cal_com"];
+export declare const PAGE_PROVIDERS: readonly ["link", "google_calendar", "cal_com"];
+export declare const BOOKING_LIMITS: {
+    readonly calComHosts: readonly ["cal.evinvest.ltd", "cal.com"];
+    readonly calComSegment: "^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$";
+    readonly leadRef: "^lead-[1-9][0-9]{0,18}-[0-9a-f]{8}$";
+    readonly maxUrl: 2048;
+};
+export declare const BOOKING_CODES: readonly ["shape", "unknown_key", "required", "provider_unknown", "provider_shape", "provider_extra", "manual", "url_type", "default_unknown", "default_unset", "format", "scheme", "fragment", "backslash", "userinfo", "ip", "port", "host", "google", "cal_host", "cal_path"];
+export type BookingCode = (typeof BOOKING_CODES)[number];
+export declare const BOOKING_STATUSES: readonly ["none", "requested", "booked", "canceled", "done", "no_show"];
+export type BookingStatus = (typeof BOOKING_STATUSES)[number];
+export declare const DAY_PARTS: readonly ["morning", "afternoon", "evening"];
+export type DayPart = (typeof DAY_PARTS)[number];
+export declare const DAYS: readonly ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+export declare const MESSENGERS: readonly ["whatsapp", "telegram"];
+export declare const PLACE_FIELDS: readonly ["phone", "whatsapp", "telegram", "messengers", "hours", "serviceArea", "address", "geo", "storefrontPhoto", "landmark", "rating", "booking", "reviewUrl"];
+export type PlaceField = (typeof PLACE_FIELDS)[number];
+export declare const PLACE_LIMITS: {
+    readonly e164: "^\\+[1-9][0-9]{6,14}$";
+    readonly maxArea: 200;
+    readonly maxHours: 14;
+    readonly maxLocales: 8;
+    readonly maxText: 200;
+    readonly maxUrl: 2048;
+    readonly reviewHosts: readonly ["g.page", "search.google.com"];
+    readonly telegramBot: "^[A-Za-z][A-Za-z0-9_]{1,28}[Bb][Oo][Tt]$";
+    readonly time: "^([01][0-9]|2[0-3]):[0-5][0-9]$";
+};
+export declare const PLACE_CODES: readonly ["object", "unknown_field", "required", "type", "blank", "too_long", "control", "e164", "telegram_bot", "messenger_unknown", "boolean", "shape", "empty", "too_many", "day", "duplicate", "time", "closes_before_opens", "postal_code", "coordinate", "https_url", "review_url", "locale", "rating_value", "rating_count", "instant"];
+export type PlaceCode = (typeof PLACE_CODES)[number];
+export declare const EXPERIMENT_LIMITS: {
+    readonly key: "^[a-z0-9_]{1,64}$";
+    readonly maxExperiments: 64;
+    readonly maxSummary: 200;
+    readonly maxVariants: 32;
+    readonly variant: "^[a-z0-9_-]{1,32}$";
+};
+export declare const LEAD_LIMITS: {
+    readonly analyticsId: "^[A-Za-z0-9._:-]{1,128}$";
+    readonly maxEstimateInputs: 12;
+    readonly messageRef: "^[A-Z]{2,4}-[0-9A-HJKMNP-TV-Z]{4,8}$";
+};
+export declare const LEAD_CHANNELS: readonly ["form", "phone_inbound", "callback", "whatsapp", "telegram"];
+export type LeadChannel = (typeof LEAD_CHANNELS)[number];
+export declare const SITE_CHANNELS: readonly ["form", "callback", "whatsapp", "telegram"];
+export type SiteChannel = (typeof SITE_CHANNELS)[number];
+export declare const LEAD_SUSPECTS: readonly ["rate_limited", "too_fast"];
+export type LeadSuspect = (typeof LEAD_SUSPECTS)[number];
+export declare const LEAD_FLOWS: readonly ["quote", "estimate", "fixed"];
+export type LeadFlow = (typeof LEAD_FLOWS)[number];

package/dist/generated/contract.js

@@ -0,0 +1,59 @@
+// AUTO-GENERATED by `nix run .#gen` — do not edit.
+export const PRICING_FORMAT = 1;
+export const PRICING_CURRENCY = "EUR";
+export const PRICING_LIMITS = {
+    "locale": "^[a-z]{2}(-[A-Z]{2})?$",
+    "maxDiscountBp": 10000,
+    "maxInputs": 32,
+    "maxLabel": 120,
+    "maxMultiplyBp": 100000,
+    "maxNeedInputs": 12,
+    "maxNeeds": 64,
+    "maxOptions": 32,
+    "maxPriceCents": 100000000,
+    "slug": "^[a-z0-9_-]{1,40}$",
+};
+export const INPUT_KINDS = ["add", "multiply", "discount"];
+export const PRICING_CODES = ["object", "missing", "unknownField", "format", "currency", "date", "int", "slug", "labels", "locale", "label", "list", "duplicate", "kind", "needKind", "noInput", "dearest", "labelMissing"];
+export const BOOKING_PROVIDERS = ["manual", "link", "google_calendar", "cal_com"];
+export const PAGE_PROVIDERS = ["link", "google_calendar", "cal_com"];
+export const BOOKING_LIMITS = {
+    "calComHosts": ["cal.evinvest.ltd", "cal.com"],
+    "calComSegment": "^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$",
+    "leadRef": "^lead-[1-9][0-9]{0,18}-[0-9a-f]{8}$",
+    "maxUrl": 2048,
+};
+export const BOOKING_CODES = ["shape", "unknown_key", "required", "provider_unknown", "provider_shape", "provider_extra", "manual", "url_type", "default_unknown", "default_unset", "format", "scheme", "fragment", "backslash", "userinfo", "ip", "port", "host", "google", "cal_host", "cal_path"];
+export const BOOKING_STATUSES = ["none", "requested", "booked", "canceled", "done", "no_show"];
+export const DAY_PARTS = ["morning", "afternoon", "evening"];
+export const DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+export const MESSENGERS = ["whatsapp", "telegram"];
+export const PLACE_FIELDS = ["phone", "whatsapp", "telegram", "messengers", "hours", "serviceArea", "address", "geo", "storefrontPhoto", "landmark", "rating", "booking", "reviewUrl"];
+export const PLACE_LIMITS = {
+    "e164": "^\\+[1-9][0-9]{6,14}$",
+    "maxArea": 200,
+    "maxHours": 14,
+    "maxLocales": 8,
+    "maxText": 200,
+    "maxUrl": 2048,
+    "reviewHosts": ["g.page", "search.google.com"],
+    "telegramBot": "^[A-Za-z][A-Za-z0-9_]{1,28}[Bb][Oo][Tt]$",
+    "time": "^([01][0-9]|2[0-3]):[0-5][0-9]$",
+};
+export const PLACE_CODES = ["object", "unknown_field", "required", "type", "blank", "too_long", "control", "e164", "telegram_bot", "messenger_unknown", "boolean", "shape", "empty", "too_many", "day", "duplicate", "time", "closes_before_opens", "postal_code", "coordinate", "https_url", "review_url", "locale", "rating_value", "rating_count", "instant"];
+export const EXPERIMENT_LIMITS = {
+    "key": "^[a-z0-9_]{1,64}$",
+    "maxExperiments": 64,
+    "maxSummary": 200,
+    "maxVariants": 32,
+    "variant": "^[a-z0-9_-]{1,32}$",
+};
+export const LEAD_LIMITS = {
+    "analyticsId": "^[A-Za-z0-9._:-]{1,128}$",
+    "maxEstimateInputs": 12,
+    "messageRef": "^[A-Z]{2,4}-[0-9A-HJKMNP-TV-Z]{4,8}$",
+};
+export const LEAD_CHANNELS = ["form", "phone_inbound", "callback", "whatsapp", "telegram"];
+export const SITE_CHANNELS = ["form", "callback", "whatsapp", "telegram"];
+export const LEAD_SUSPECTS = ["rate_limited", "too_fast"];
+export const LEAD_FLOWS = ["quote", "estimate", "fixed"];