@openlup/platform 0.28.0 → 0.30.0

package/dist/marketing/analytics/purchaseFacts.js

@@ -0,0 +1,69 @@
+const MAX_ITEMS = 200;
+export function projectPaidPurchase(recap, suppressPurchase = () => null) {
+    if (recap.status !== "paid")
+        return suppressPurchase("order_not_paid");
+    if (recap.paymentStatus !== "succeeded")
+        return suppressPurchase("payment_not_succeeded");
+    if (recap.checkoutKind !== "one_time" && recap.checkoutKind !== "subscription_initial"
+        && recap.checkoutKind !== "subscription_renewal")
+        return suppressPurchase("checkout_kind_unsupported");
+    if (!recap.moneyReconciled)
+        return suppressPurchase("money_unreconciled");
+    if (recap.items.length === 0)
+        return suppressPurchase("items_empty");
+    let effectiveNet = 0;
+    const items = [];
+    for (const item of recap.items) {
+        if (!item.sku)
+            return suppressPurchase("sku_missing");
+        if (!Number.isSafeInteger(item.quantity) || item.quantity <= 0)
+            return suppressPurchase("quantity_invalid");
+        if (item.quantity > MAX_ITEMS)
+            return suppressPurchase("item_limit_exceeded");
+        if (!isNonNegativeSafeInteger(item.catalogTotalGross) || !isNonNegativeSafeInteger(item.effectiveNet)
+            || !isNonNegativeSafeInteger(item.vatRateBps) || item.vatRateBps > 10_000)
+            return suppressPurchase("line_money_invalid");
+        const catalogNet = netFromGross(item.catalogTotalGross, item.vatRateBps);
+        const netDiscount = catalogNet - item.effectiveNet;
+        if (netDiscount < 0)
+            return suppressPurchase("net_discount_invalid");
+        const projected = allocateLineItems({ sku: item.sku, variantCode: item.variantCode,
+            quantity: item.quantity, effectiveNet: item.effectiveNet, netDiscount });
+        if (items.length + projected.length > MAX_ITEMS)
+            return suppressPurchase("item_limit_exceeded");
+        items.push(...projected);
+        effectiveNet += item.effectiveNet;
+    }
+    const tax = recap.totals.tax.amountMinor;
+    const total = recap.totals.total.amountMinor;
+    const effectiveShippingNet = total - tax - effectiveNet;
+    if (!isNonNegativeSafeInteger(effectiveShippingNet))
+        return suppressPurchase("shipping_net_invalid");
+    return { transaction_id: recap.orderId, currency: recap.totals.total.currency, value: effectiveNet / 100,
+        shipping: effectiveShippingNet / 100, tax: tax / 100,
+        checkout_mode: recap.checkoutKind === "one_time" ? "one_time" : "subscription", items };
+}
+function allocateLineItems(input) {
+    const priceBase = Math.floor(input.effectiveNet / input.quantity);
+    const priceRemainder = input.effectiveNet % input.quantity;
+    const discountBase = Math.floor(input.netDiscount / input.quantity);
+    const discountRemainder = input.netDiscount % input.quantity;
+    const grouped = new Map();
+    for (let position = 0; position < input.quantity; position += 1) {
+        const priceMinor = priceBase + (position < priceRemainder ? 1 : 0);
+        const discountMinor = discountBase + (position < discountRemainder ? 1 : 0);
+        const key = `${priceMinor}:${discountMinor}`;
+        const current = grouped.get(key);
+        if (current)
+            current.quantity += 1;
+        else
+            grouped.set(key, { priceMinor, discountMinor, quantity: 1 });
+    }
+    return [...grouped.values()].map(group => ({ item_id: input.sku,
+        ...(input.variantCode ? { item_variant: input.variantCode } : {}), price: group.priceMinor / 100,
+        discount: group.discountMinor / 100, quantity: group.quantity }));
+}
+function netFromGross(grossMinor, vatRateBps) {
+    return Math.round(grossMinor * 10_000 / (10_000 + vatRateBps));
+}
+function isNonNegativeSafeInteger(value) { return Number.isSafeInteger(value) && value >= 0; }

package/dist/marketing/analytics/routePolicy.d.ts

@@ -0,0 +1,10 @@
+import type { AnalyticsRoutePolicyInput } from "../contracts/analytics.js";
+export type { AnalyticsRoutePolicyInput } from "../contracts/analytics.js";
+export declare function normalizeAnalyticsPathname(pathname: string): string;
+/** Route manifests and sensitive paths are explicit host policy. */
+export declare function createAnalyticsRoutePolicy(input: AnalyticsRoutePolicyInput): {
+    isSensitiveAnalyticsPath: (pathname: string) => boolean;
+    isOptionalAnalyticsRouteEligible: (pathname: string) => boolean;
+    isDeploymentAnalyticsRouteEligible: (pathname: string, additionalPublicPaths?: ReadonlySet<string>) => boolean;
+    sanitizeDeploymentAnalyticsUrl: (rawUrl: string, currentOrigin: string, additionalPublicPaths?: ReadonlySet<string>) => string | null;
+};

package/dist/marketing/analytics/routePolicy.js

@@ -0,0 +1,59 @@
+const CAMPAIGN_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"];
+const CAMPAIGN_VALUE = /^[A-Za-z0-9_-]{1,100}$/;
+const NO_ADDITIONAL_PATHS = new Set();
+export function normalizeAnalyticsPathname(pathname) {
+    const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1
+        ? withLeadingSlash.replace(/\/+$/, "") : withLeadingSlash;
+    return withoutTrailingSlash.toLowerCase();
+}
+/** Route manifests and sensitive paths are explicit host policy. */
+export function createAnalyticsRoutePolicy(input) {
+    const manifestPaths = new Set(input.publicPaths.map(normalizeAnalyticsPathname));
+    const redirectPaths = new Set(input.redirectSources.filter(source => !source.includes(":"))
+        .map(normalizeAnalyticsPathname));
+    function isSensitiveAnalyticsPath(pathname) {
+        const capabilityPath = pathname.toLowerCase();
+        return input.privatePathPrefixes.some(prefix => pathname === prefix || pathname.startsWith(`${prefix}/`))
+            || input.privateAuthPaths.includes(pathname)
+            || input.capabilityPathPrefixes.some(prefix => capabilityPath === prefix || capabilityPath.startsWith(`${prefix}/`));
+    }
+    function isOptionalAnalyticsRouteEligible(pathname) {
+        return !isSensitiveAnalyticsPath(pathname);
+    }
+    function isDeploymentAnalyticsRouteEligible(pathname, additionalPublicPaths = NO_ADDITIONAL_PATHS) {
+        const path = normalizeAnalyticsPathname(pathname);
+        if (isSensitiveAnalyticsPath(path))
+            return false;
+        return manifestPaths.has(path) || redirectPaths.has(path) || additionalPublicPaths.has(path);
+    }
+    function sanitizeDeploymentAnalyticsUrl(rawUrl, currentOrigin, additionalPublicPaths) {
+        let base;
+        let url;
+        try {
+            base = new URL(currentOrigin);
+            url = new URL(rawUrl, base);
+        }
+        catch {
+            return null;
+        }
+        if ((url.protocol !== "http:" && url.protocol !== "https:") || url.username || url.password
+            || url.origin !== base.origin)
+            return null;
+        const pathname = normalizeAnalyticsPathname(url.pathname);
+        if (!isDeploymentAnalyticsRouteEligible(pathname, additionalPublicPaths))
+            return null;
+        const campaign = new URLSearchParams();
+        for (const key of CAMPAIGN_KEYS) {
+            const values = url.searchParams.getAll(key);
+            if (values.length === 1 && CAMPAIGN_VALUE.test(values[0]))
+                campaign.set(key, values[0]);
+        }
+        url.pathname = pathname;
+        url.search = campaign.toString();
+        url.hash = "";
+        return url.href;
+    }
+    return { isSensitiveAnalyticsPath, isOptionalAnalyticsRouteEligible,
+        isDeploymentAnalyticsRouteEligible, sanitizeDeploymentAnalyticsUrl };
+}

package/dist/marketing/consentEvidence.d.ts

@@ -0,0 +1,8 @@
+import type { MarketingHistoricalConsentCommand, MarketingHistoricalConsentState, MarketingHistoricalConsentResult } from "./contracts/analytics.js";
+export type { MarketingHistoricalConsentCommand, MarketingHistoricalConsentState, MarketingHistoricalConsentResult } from "./contracts/analytics.js";
+/** Transport chronology after authorization; never changes the local consent grant. */
+export declare function selectMarketingHistoricalConsentTime(input: {
+    command: MarketingHistoricalConsentCommand;
+    state: MarketingHistoricalConsentState;
+    now: Date;
+}): MarketingHistoricalConsentResult;

package/dist/marketing/consentEvidence.js

@@ -0,0 +1,32 @@
+import { z } from "./validation.js";
+const historicalTimestamp = z.string().max(80).datetime({ offset: true });
+const HISTORICAL_MIN_AGE_MS = 5 * 60 * 1000;
+/** Transport chronology after authorization; never changes the local consent grant. */
+export function selectMarketingHistoricalConsentTime(input) {
+    const { command, state, now } = input;
+    if (!Number.isFinite(now.getTime()))
+        return { kind: "hold", reason: "consent_time_invalid" };
+    let selected = command.consentedAt;
+    if (state.consent === "SUBSCRIBED") {
+        const native = historicalTimestamp.safeParse(state.nativeConsentAt);
+        if (!native.success || !Number.isFinite(Date.parse(native.data)) || Date.parse(native.data) >= now.getTime()) {
+            return { kind: "hold", reason: "provider_state_unknown" };
+        }
+        const overriding = state.suppressions.some(item => item.reason === "UNSUBSCRIBE"
+            && (item.listId === null || item.listId === command.listId));
+        if (!overriding)
+            selected = native.data;
+        else if (Date.parse(command.consentedAt ?? "") > Date.parse(native.data)) {
+            return { kind: "hold", reason: "provider_state_unknown" };
+        }
+    }
+    const parsed = historicalTimestamp.safeParse(selected);
+    if (!parsed.success || !Number.isFinite(Date.parse(parsed.data)) || Date.parse(parsed.data) >= now.getTime()) {
+        return { kind: "hold", reason: "consent_time_invalid" };
+    }
+    // Parsing truncates fractional milliseconds; round only the age boundary up.
+    const discarded = /\.\d{3}(\d+)(?:Z|[+-]\d{2}:\d{2})$/.exec(parsed.data)?.[1];
+    const matureAt = Date.parse(parsed.data) + (discarded && /[1-9]/.test(discarded) ? 1 : 0) + HISTORICAL_MIN_AGE_MS;
+    return now.getTime() < matureAt ? { kind: "defer", retryAt: new Date(matureAt).toISOString() }
+        : { kind: "ready", providerConsentedAt: parsed.data };
+}

package/dist/marketing/contactLegal.d.ts

@@ -0,0 +1,14 @@
+import type { ContactContent, LegalDocumentContent } from "./contracts/contactLegal.js";
+export declare function contactContent(facts: ContactContent): {
+    supportEmail: string;
+    companyLines: string[];
+};
+export declare function legalDocumentContent(content: LegalDocumentContent): {
+    lastUpdated?: string | undefined;
+    title: string;
+    intro: string;
+    sections: {
+        title: string;
+        body: string;
+    }[];
+};

package/dist/marketing/contactLegal.js

@@ -0,0 +1,19 @@
+export function contactContent(facts) {
+    return {
+        supportEmail: facts.supportEmail,
+        companyLines: [
+            facts.organization.legalName,
+            facts.addressLine,
+            facts.registrationIdentifiers.map(({ label, value }) => `${label} ${value}`).join(" · "),
+            ...(facts.registrationAuthority !== undefined ? [facts.registrationAuthority] : []),
+        ],
+    };
+}
+export function legalDocumentContent(content) {
+    return {
+        title: content.title,
+        intro: content.intro,
+        sections: content.sections.map(({ title, body }) => ({ title, body })),
+        ...(content.lastUpdated !== undefined ? { lastUpdated: content.lastUpdated } : {}),
+    };
+}

package/dist/marketing/contracts/acquisition.d.ts

@@ -0,0 +1,88 @@
+export type AcquisitionOpaqueReference = string;
+export type AcquisitionAddressReference = {
+    source: string;
+    reference: string;
+    revision: string;
+    provenance: string;
+};
+export type AcquisitionCaseState = "submitted" | "approved" | "active" | "rejected" | "withdrawn";
+export type AcquisitionCaseProjection = {
+    contractVersion: "tester_application_v1";
+    caseRef: string;
+    contactRef: string;
+    sourceKind: "tester_application";
+    consent: {
+        consentVersion: string;
+        policyVersion: string;
+        recordedAt: string;
+        locale: "en" | "pl";
+        sourcePath: "/tester-application";
+    };
+    addressReference: AcquisitionAddressReference | null;
+    state: AcquisitionCaseState;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type AcquisitionCaseListRequest = {
+    view: "acquisition_case_v1";
+    cursor?: string | undefined;
+    limit: number;
+};
+export type AcquisitionCaseListResponse = {
+    contractVersion: "tester_application_v1";
+    cases: AcquisitionCaseProjection[];
+    nextCursor: string | null;
+};
+export type AcquisitionCaseActiveCountResponse = {
+    activeTesterCount: number;
+};
+export type AcquisitionIdempotencyKey = string;
+export type AcquisitionSurveySubmit = {
+    view: "acquisition_survey_v1";
+    caseReference: string;
+    surveyType: "producer" | "consumer";
+    responseData: Record<string, unknown>;
+};
+export type AcquisitionSurveyEvidence = {
+    evidenceReference: string;
+    caseReference: string;
+    contactReference: string;
+    surveyType: "producer" | "consumer";
+    responseDigest: string;
+    answerCount: number;
+    recordedAt: string;
+};
+export type AcquisitionSurveySubmitResponse = {
+    contractVersion: "acquisition_survey_v1";
+    evidence: AcquisitionSurveyEvidence;
+    replayed: boolean;
+};
+export type AcquisitionSurveyListQuery = {
+    view: "acquisition_survey_v1";
+    surveyType?: "producer" | "consumer" | undefined;
+    limit: number;
+};
+export type AcquisitionSurveyListResponse = {
+    contractVersion: "acquisition_survey_v1";
+    rows: AcquisitionSurveyEvidence[];
+    totalCount: number;
+};
+export type AcquisitionNewsletterConsentEvent = {
+    contractVersion: "acquisition_newsletter_consent_v1";
+    caseReference: string;
+    contactReference: string;
+    eventReference: string;
+    eventType: "subscribe" | "unsubscribe" | "suppress" | "complaint" | "update";
+    purpose: "marketing_launch_offer" | "marketing_newsletter";
+    explicitOptInEvidence: boolean;
+    occurredAt: string;
+};
+export type AcquisitionNewsletterConsentResponse = {
+    contractVersion: "acquisition_newsletter_consent_v1";
+    eventReference: string;
+    outcome: "applied" | "ignored" | "stale";
+    consentState: "granted" | "suppressed" | null;
+    auditReference: string;
+    replayed: boolean;
+};

package/dist/marketing/contracts/acquisition.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/contracts/acquisitionPorts.d.ts

@@ -0,0 +1,49 @@
+import type { AcquisitionCaseListResponse, AcquisitionCaseProjection, AcquisitionNewsletterConsentEvent, AcquisitionNewsletterConsentResponse, AcquisitionSurveyListQuery, AcquisitionSurveyListResponse, AcquisitionSurveySubmit, AcquisitionSurveySubmitResponse } from "./acquisition.js";
+export type AcquisitionCaseFailureKind = "conflict" | "invalid" | "not_found" | "rate_limited" | "unavailable";
+export type AcquisitionCaseResult<T> = {
+    ok: true;
+    value: T;
+    replayed?: boolean;
+} | {
+    ok: false;
+    error: {
+        kind: AcquisitionCaseFailureKind;
+    };
+};
+export interface AcquisitionCaseListQuery {
+    actorRef: string;
+    scope: "public_tester_application";
+    cursor?: string;
+    limit: number;
+}
+export interface AcquisitionCaseGetQuery {
+    actorRef: string;
+    scope: "public_tester_application";
+    caseRef: string;
+}
+export interface AcquisitionCasePort {
+    list(query: AcquisitionCaseListQuery): Promise<AcquisitionCaseResult<AcquisitionCaseListResponse>>;
+    get(query: AcquisitionCaseGetQuery): Promise<AcquisitionCaseResult<AcquisitionCaseProjection>>;
+    activeCount(scope: "public_tester_application"): Promise<AcquisitionCaseResult<number>>;
+    close(): Promise<void>;
+}
+export type AcquisitionEvidenceFailure = "invalid" | "not_found" | "conflict" | "unavailable";
+export type AcquisitionEvidenceResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        kind: AcquisitionEvidenceFailure;
+    };
+};
+export interface AcquisitionEvidencePort {
+    submitSurvey(input: AcquisitionSurveySubmit & {
+        idempotencyKey: string;
+    }): Promise<AcquisitionEvidenceResult<AcquisitionSurveySubmitResponse>>;
+    listSurveys(input: AcquisitionSurveyListQuery & {
+        actorReference: string;
+    }): Promise<AcquisitionEvidenceResult<AcquisitionSurveyListResponse>>;
+    applyNewsletterConsent(input: AcquisitionNewsletterConsentEvent): Promise<AcquisitionEvidenceResult<AcquisitionNewsletterConsentResponse>>;
+    close(): Promise<void>;
+}

package/dist/marketing/contracts/acquisitionPorts.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/contracts/analytics.d.ts

@@ -0,0 +1,144 @@
+/** The host supplies its own literal step vocabulary. */
+export type AnalyticsStepName<StepName extends string = string> = StepName;
+export interface AnalyticsCheckoutItem {
+    item_id: string;
+    quantity: number;
+}
+export interface AnalyticsPurchaseItem extends AnalyticsCheckoutItem {
+    item_variant?: string;
+    price: number;
+    discount: number;
+}
+export type AnalyticsCheckoutMode = "one_time" | "subscription";
+/** No answer describes an ended wait, without asserting payment failure. */
+export type AnalyticsPaymentWaitOutcome = "confirmed" | "refused" | "no_answer";
+export interface AnalyticsEventMap<StepName extends string = string> {
+    page_view: {
+        page_path: string;
+    };
+    configurator_start: {
+        entry_view: "hero" | "configurator";
+    };
+    configurator_step_view: {
+        step_number: number;
+        step_name: AnalyticsStepName<StepName>;
+    };
+    begin_checkout: {
+        checkout_mode: AnalyticsCheckoutMode;
+        items: AnalyticsCheckoutItem[];
+    };
+    purchase: {
+        transaction_id: string;
+        currency: string;
+        value: number;
+        shipping: number;
+        tax: number;
+        checkout_mode: AnalyticsCheckoutMode;
+        items: AnalyticsPurchaseItem[];
+    };
+    payment_wait_start: {
+        checkoutMode: AnalyticsCheckoutMode;
+    };
+    payment_wait_end: {
+        outcome: AnalyticsPaymentWaitOutcome;
+        checkoutMode: AnalyticsCheckoutMode;
+    };
+    configurator_draft_restored: {
+        draft_context: "public";
+    };
+    configurator_draft_save_failed: {
+        draft_context: "public";
+        reason: "unavailable" | "quota" | "conflict";
+    };
+    configurator_draft_reset: {
+        draft_context: "public";
+    };
+}
+export type AnalyticsEventName = keyof AnalyticsEventMap;
+export interface AnalyticsSinkAttemptMask {
+    deployment: boolean;
+    optional: boolean;
+}
+/** Synchronous local acceptance only; never transport delivery or business acknowledgement. */
+export interface AnalyticsSinkAdmission {
+    deployment: boolean;
+    optional: boolean;
+}
+export interface AnalyticsCookieConsent {
+    necessary: boolean;
+    functional: boolean;
+    analytics: boolean;
+    marketing: boolean;
+}
+export type AnalyticsBrowserWindow = Pick<Window, "localStorage" | "addEventListener" | "removeEventListener"> & {
+    dataLayer?: unknown[];
+};
+export interface AnalyticsDataLayerOptions<StepName extends string = string> {
+    consentStorageKey?: string;
+    consentChangeEvent?: string;
+    /** Host wire names, analytics first then advertising in supplied order. Omission disables consent commands and optional event admission. */
+    consentSignalNames?: {
+        analytics: string;
+        advertising: readonly string[];
+    };
+    eventPrefix?: string;
+    readContainerId?: () => string | null;
+    trackDeploymentEvent?: <K extends AnalyticsEventName>(event: K, properties: AnalyticsEventMap<StepName>[K]) => boolean;
+    getWindow?: () => AnalyticsBrowserWindow | undefined;
+}
+export interface AnalyticsRoutePolicyInput {
+    publicPaths: readonly string[];
+    redirectSources: readonly string[];
+    privatePathPrefixes: readonly string[];
+    privateAuthPaths: readonly string[];
+    capabilityPathPrefixes: readonly string[];
+}
+/** Only paid recap facts read by the projection; money remains the host's truth. */
+export interface PurchaseOrder {
+    orderId: string;
+    status: string;
+    paymentStatus: string | null;
+    checkoutKind: "one_time" | "subscription_initial" | "subscription_renewal" | null;
+    moneyReconciled: boolean;
+    items: Array<{
+        sku: string | null;
+        variantCode: string | null;
+        quantity: number;
+        catalogTotalGross: number;
+        effectiveNet: number;
+        vatRateBps: number;
+    }>;
+    totals: {
+        tax: {
+            amountMinor: number;
+        };
+        total: {
+            amountMinor: number;
+            currency: string;
+        };
+    };
+}
+export type PurchaseSuppressionReason = "order_not_paid" | "payment_not_succeeded" | "checkout_kind_unsupported" | "money_unreconciled" | "items_empty" | "sku_missing" | "quantity_invalid" | "line_money_invalid" | "net_discount_invalid" | "item_limit_exceeded" | "shipping_net_invalid";
+export interface MarketingHistoricalConsentCommand {
+    consentedAt: string | null;
+    listId: string | null;
+}
+/** Native state literals are compatibility inputs supplied by the host adapter. */
+export interface MarketingHistoricalConsentState {
+    consent: "SUBSCRIBED" | "UNSUBSCRIBED" | "NEVER_SUBSCRIBED" | "unknown";
+    nativeConsentAt?: string | null;
+    suppressions: Array<{
+        reason: "UNSUBSCRIBE" | "SPAM_REPORT" | "USER_SUPPRESSED" | "HARD_BOUNCE" | "INVALID_EMAIL" | "unknown";
+        listId: string | null;
+    }>;
+}
+export type MarketingHistoricalConsentResult = {
+    kind: "ready";
+    providerConsentedAt: string;
+} | {
+    kind: "defer";
+    retryAt: string;
+} | {
+    kind: "hold";
+    reason: string;
+};

package/dist/marketing/contracts/analytics.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/contracts/contactLegal.d.ts

@@ -0,0 +1,53 @@
+export interface OrganizationFacts {
+    name: string;
+    legalName: string;
+    url: string;
+    logo: {
+        url: string;
+        contentUrl: string;
+        width: number;
+        height: number;
+    };
+    email: string;
+    vatID: string;
+    taxID: string;
+    areaServed: string;
+    sameAs: string[];
+    contactPoint: {
+        email: string;
+        contactType: string;
+        availableLanguage: string[];
+    };
+    address: {
+        streetAddress: string;
+        addressLocality: string;
+        postalCode: string;
+        addressRegion: string;
+        addressCountry: string;
+    };
+}
+export interface ContactContent {
+    organization: OrganizationFacts;
+    supportEmail: string;
+    addressLine: string;
+    registrationIdentifiers: {
+        label: string;
+        value: string;
+    }[];
+    registrationAuthority?: string;
+}
+export interface LegalDocumentContent {
+    title: string;
+    intro: string;
+    sections: {
+        title: string;
+        body: string;
+    }[];
+    lastUpdated?: string;
+}
+export interface PrivacyProcessorDisclosure {
+    processorName: string;
+    purpose: string;
+    dataCategories: string[];
+    details?: string;
+}

package/dist/marketing/contracts/contactLegal.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/contracts/index.d.ts

@@ -0,0 +1,6 @@
+export type * from "./acquisition.js";
+export type { MarketingResearchJson, ResearchSurveyType, AdminSurveyResponsesRequest, AdminSurveyResponseRow, AdminSurveyResponsesResponse, ResearchSurveySubmitRequest, ResearchSurveySubmitResponse, MarketingResearchSurveyResponsesReadPort, MarketingResearchSurveyRequestHeaders, MarketingResearchSurveySubmitPort, } from "@openlup/core/marketing/research";
+export type * from "./acquisitionPorts.js";
+export type * from "./prelaunch.js";
+export type * from "./analytics.js";
+export type * from "./contactLegal.js";

package/dist/marketing/contracts/index.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/contracts/prelaunch.d.ts

@@ -0,0 +1,39 @@
+export type PrelaunchAcquisitionListRequest = {
+    view: "prelaunch_acquisition_v1";
+    cursor?: string | undefined;
+    limit: number;
+};
+export type PrelaunchAcquisitionDetailRequest = {
+    sourceRef: string;
+};
+export type PrelaunchAcquisitionLead = {
+    sourceRef: string;
+    contactRef: string;
+    sourceKind: "tester_application";
+    consent: {
+        consentVersion: string;
+        policyVersion: string;
+        recordedAt: string;
+        locale: "en" | "pl";
+        sourcePath: "/tester-application";
+    };
+    addressReference: {
+        source: string;
+        reference: string;
+        revision: string;
+        provenance: string;
+    } | null;
+    state: "submitted" | "approved" | "active" | "rejected" | "withdrawn";
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type PrelaunchAcquisitionListResponse = {
+    contractVersion: "prelaunch_acquisition_v1";
+    leads: PrelaunchAcquisitionLead[];
+    nextCursor: string | null;
+};
+export type PrelaunchAcquisitionDetailResponse = {
+    contractVersion: "prelaunch_acquisition_v1";
+    lead: PrelaunchAcquisitionLead;
+};

package/dist/marketing/contracts/prelaunch.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./acquisitionCaseSchemas.js";
+export * from "./acquisitionEvidenceSchemas.js";
+export * from "@openlup/core/marketing/research";
+export * from "./prelaunchAcquisitionSchemas.js";
+export type * from "./contracts/acquisitionPorts.js";
+export * from "./analytics/noop.js";
+export * from "./analytics/dataLayer.js";
+export * from "./analytics/routePolicy.js";
+export * from "./analytics/purchaseFacts.js";
+export * from "./consentEvidence.js";
+export * from "./seo/serializeJsonLd.js";
+export * from "./seo/urls.js";
+export * from "./seo/metadata.js";
+export * from "./seo/jsonLd.js";
+export type * from "./contracts/contactLegal.js";
+export * from "./contactLegal.js";

package/dist/marketing/index.js

@@ -0,0 +1,14 @@
+export * from "./acquisitionCaseSchemas.js";
+export * from "./acquisitionEvidenceSchemas.js";
+export * from "@openlup/core/marketing/research";
+export * from "./prelaunchAcquisitionSchemas.js";
+export * from "./analytics/noop.js";
+export * from "./analytics/dataLayer.js";
+export * from "./analytics/routePolicy.js";
+export * from "./analytics/purchaseFacts.js";
+export * from "./consentEvidence.js";
+export * from "./seo/serializeJsonLd.js";
+export * from "./seo/urls.js";
+export * from "./seo/metadata.js";
+export * from "./seo/jsonLd.js";
+export * from "./contactLegal.js";