@likerts/web 0.0.3

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 0.0.3 — 2026-09-09
+
+- Schema 5 adds ranking, single/multiple matrix and exact-total constant-sum questions with bounded answer schemas.
+- The renderer uses explicit rank movement, stacked mobile-safe matrix controls and an announced constant-sum remainder.
+
+## 0.0.2 — 2026-09-09
+
+- Schema 3 adds conditional visibility, structured Other text, exclusive None choices, stars and dropdown presentations. Existing schema 1/2 answers remain compatible.
+- Schema 4 adds pages, forward routing, page validation, Back/Next navigation, progress and removal of skipped answers.
+- Host-controlled triggers, submission and distribution remain unchanged. No package publication.
+
+## 0.0.1 — 2026-09-08
+
+- Collection-only HTTPS client, cancellable requests, bounded response bodies and five-minute immutable configuration cache.
+- DOM renderer for six question types, NPS/yes-no presets, scale labels and selection bounds, with host CSS/localization hooks.
+- Customer-controlled checkout trigger example and compiled JavaScript/TypeScript declaration artifact.
+
+Local evaluation artifact. Package publication and broader browser/device release checks remain separate.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Likerts contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# Likerts Web SDK
+
+## Install
+
+Install a published version from npm:
+
+```sh
+npm install @likerts/web
+```
+
+You can also use the installable tarballs from the [community release](https://github.com/crosstabs/likerts/releases/tag/community-v0.1.0).
+
+## Install the current source
+
+The free community edition supports schemas 1–5. Clone the repository and run these commands from its root:
+
+```sh
+npm ci --prefix sdks/web
+npm run build --prefix sdks/web
+cd sdks/web
+npm pack
+```
+
+Run `npm install /absolute/path/to/likerts/sdks/web/likerts-web-0.0.3.tgz` in your application. This installs the tarball you just built, containing compiled ESM and TypeScript declarations; it needs no repository-relative imports or build step in the consumer. Use a modern browser with Fetch, AbortController and crypto.randomUUID, and bundle the module with your host application. Frozen archives under `releases/` predate the free edition; build current source rather than installing those historical packages.
+
+`examples/checkout.ts` supplies a customer-owned button trigger that loads/mounts feedback only when clicked and returns cleanup for navigation. Call it after your own eligibility/consent checks. The client should receive only a collection token. Build/test commands below refer to a source checkout, not the installed tarball.
+
+The Web package fetches a public collection configuration and renders it inside a customer-owned element. The customer decides when to mount it, which first-party page contains it, and when to remove it. Never put a management credential in browser code.
+
+```ts
+import {LIKERTS_SDK_CAPABILITY, LikertsClient, mountSurvey} from '@likerts/web';
+
+const client = new LikertsClient('https://feedback.example.com', publicCollectionToken);
+const collection = await client.collection(collectionId);
+const cleanup = mountSurvey(
+  document.querySelector('#feedback')!,
+  collection,
+  client,
+  receipt => console.log(receipt.responseId),
+  {orderStage: 'after_payment'},
+  {
+    messages: {submit: 'Send feedback', submitted: 'Thank you'},
+    classNames: {form: 'my-survey', submit: 'my-button'},
+  },
+);
+```
+
+Publish and collection-management requests declare `LIKERTS_SDK_CAPABILITY` for every Web installation group. A collection client caches configuration for five minutes. Use `collection(id, {refresh: true})` before presentation when fresh configuration is required, and `clearCollectionCache()` when ending the client lifecycle.
+
+## Styling and localization
+
+The renderer emits stable `likerts-*` classes for the form, title, question, label, control, submit button and status. Question wrappers also expose `data-likerts-question` and `data-likerts-type`. Supply extra host classes through `classNames`; the SDK never inserts inline styles. Supply translated UI copy through `messages`. Survey titles, question labels and choices remain customer-authored collection content.
+
+The form associates every label and control, exposes title and status relationships, follows native keyboard order, uses native constraint feedback, announces progress, and moves focus to a submission alert after a server failure. `cleanup` aborts an active request, removes the form and suppresses late completion.
+
+## Browser deployment
+
+The client requires HTTPS except on exact loopback development hosts. Customers may use a same-origin proxy or configure exact HTTPS origins with `collections_security_update` for direct browser calls. The API answers bounded preflight requests and echoes only configured origins; the bearer collection credential, expiry, caps and revocation remain authoritative because an origin is never an authentication boundary.
+
+The renderer works under a strict CSP without `unsafe-inline` or `unsafe-eval`. Load the SDK and customer CSS as external same-origin resources and allow the API origin in `connect-src` when it differs. The client rejects redirects, limits each response body to 256 KiB by default, and permits a smaller limit through the final constructor argument.
+
+Run `npm run build && node --test test/*.test.mjs` for component checks. From the repository root, `scripts/check-web-browser.sh` builds the real backend and uses Chromium to verify accessible labels, keyboard-only completion, strict CSP, host styling/localization and accepted-response accounting through a same-origin proxy.
+
+Schema 3 choice semantics are documented in [CHOICE-FEATURES.md](../../contracts/CHOICE-FEATURES.md): Other answers carry separate selected IDs and text; None is exclusive; stars retain numeric answers and dropdowns retain option IDs.
+
+Schema 5 adds the bounded advanced families in [ADVANCED-QUESTIONS.md](../../contracts/ADVANCED-QUESTIONS.md). Ranking answers are complete option-ID permutations and use explicit Move up/down buttons. Matrix answers map each answered row ID to one column ID or a nonempty list of column IDs and render as stacked fieldsets. Constant-sum answers contain every item ID, accept nonnegative integers and must equal the configured total; the remaining amount is announced while editing.

package/dist/advanced-questions.d.ts

@@ -0,0 +1,25 @@
+export type RankingAnswer = string[];
+export type MatrixAnswer = Record<string, string | string[]>;
+export type ConstantSumAnswer = Record<string, number>;
+export type AdvancedAnswer = RankingAnswer | MatrixAnswer | ConstantSumAnswer;
+export interface AdvancedItem {
+    id: string;
+    label: string;
+}
+export interface AdvancedQuestion {
+    type: string;
+    required?: boolean;
+    options?: AdvancedItem[];
+    rows?: AdvancedItem[];
+    columns?: AdvancedItem[];
+    matrixMode?: 'single' | 'multiple';
+    items?: AdvancedItem[];
+    total?: number;
+}
+export type AdvancedAnswerError = 'required' | 'ranking' | 'matrix' | 'constant_sum';
+export declare const rankingOrder: (question: AdvancedQuestion, answer: unknown) => string[];
+export declare function moveRanking(question: AdvancedQuestion, answer: unknown, id: string, offset: -1 | 1): string[];
+export declare function setMatrixChoice(question: AdvancedQuestion, answer: unknown, rowId: string, columnId: string): MatrixAnswer;
+export declare function setAllocation(answer: unknown, itemId: string, value: number): ConstantSumAnswer;
+export declare function allocationRemaining(question: AdvancedQuestion, answer: unknown): number;
+export declare function advancedAnswerError(question: AdvancedQuestion, answer: unknown): AdvancedAnswerError | undefined;

package/dist/advanced-questions.js

@@ -0,0 +1,31 @@
+export const rankingOrder = (question, answer) => Array.isArray(answer) ? answer.filter((id) => typeof id === 'string') : (question.options ?? []).map(option => option.id);
+export function moveRanking(question, answer, id, offset) { const order = rankingOrder(question, answer); const from = order.indexOf(id); if (from < 0)
+    return order; const to = Math.max(0, Math.min(order.length - 1, from + offset)); const next = [...order]; next.splice(from, 1); next.splice(to, 0, id); return next; }
+export function setMatrixChoice(question, answer, rowId, columnId) { const current = answer && typeof answer === 'object' && !Array.isArray(answer) ? answer : {}; if (question.matrixMode === 'single')
+    return { ...current, [rowId]: columnId }; const selected = Array.isArray(current[rowId]) ? current[rowId] : []; const next = selected.includes(columnId) ? selected.filter(id => id !== columnId) : [...selected, columnId]; const result = { ...current }; if (next.length)
+    result[rowId] = next;
+else
+    delete result[rowId]; return result; }
+export function setAllocation(answer, itemId, value) { const current = answer && typeof answer === 'object' && !Array.isArray(answer) ? answer : {}; return { ...current, [itemId]: value }; }
+export function allocationRemaining(question, answer) { const values = answer && typeof answer === 'object' && !Array.isArray(answer) ? Object.values(answer) : []; return (question.total ?? 0) - values.reduce((sum, value) => sum + (Number.isSafeInteger(value) ? value : 0), 0); }
+export function advancedAnswerError(question, answer) {
+    if (answer === undefined)
+        return question.required ? 'required' : undefined;
+    if (question.type === 'ranking') {
+        const values = Array.isArray(answer) ? answer : [];
+        const ids = (question.options ?? []).map(item => item.id);
+        return values.length === ids.length && new Set(values).size === values.length && values.every(id => ids.includes(id)) ? undefined : 'ranking';
+    }
+    if (!answer || typeof answer !== 'object' || Array.isArray(answer))
+        return question.type === 'matrix' ? 'matrix' : 'constant_sum';
+    const values = answer;
+    if (question.type === 'matrix') {
+        const rows = (question.rows ?? []).map(item => item.id), columns = (question.columns ?? []).map(item => item.id), entries = Object.entries(values);
+        if (!entries.length || question.required && entries.length !== rows.length || entries.some(([row]) => !rows.includes(row)))
+            return 'matrix';
+        const valid = entries.every(([, value]) => question.matrixMode === 'single' ? typeof value === 'string' && columns.includes(value) : Array.isArray(value) && value.length > 0 && new Set(value).size === value.length && value.every(id => typeof id === 'string' && columns.includes(id)));
+        return valid ? undefined : 'matrix';
+    }
+    const items = (question.items ?? []).map(item => item.id), entries = Object.entries(values);
+    return entries.length === items.length && entries.every(([id, value]) => items.includes(id) && Number.isSafeInteger(value) && Number(value) >= 0 && Number(value) <= (question.total ?? 0)) && allocationRemaining(question, values) === 0 ? undefined : 'constant_sum';
+}

package/dist/branching.d.ts

@@ -0,0 +1,26 @@
+import type { Answer, Question, SurveyPage } from './index.js';
+export interface BranchingSchema {
+    questions: Question[];
+    pages?: SurveyPage[];
+}
+export interface SurveyProgress {
+    current: number;
+    total: number;
+    visited: number;
+}
+export declare function pageRoute(schema: BranchingSchema, answers: Record<string, Answer>): number[];
+export declare function routedAnswers(schema: BranchingSchema, answers: Record<string, Answer>): Record<string, Answer>;
+export declare class SurveyFlow {
+    readonly schema: BranchingSchema;
+    private route;
+    private history;
+    private current;
+    private values;
+    constructor(schema: BranchingSchema, initial?: Record<string, Answer>);
+    get page(): SurveyPage;
+    get answers(): Record<string, Answer>;
+    get progress(): SurveyProgress;
+    setAnswer(id: string, value: Answer | undefined): void;
+    next(): boolean;
+    back(): boolean;
+}

package/dist/branching.js

@@ -0,0 +1,58 @@
+import { conditionMatches, visibleAnswers } from './index.js';
+const effectivePages = (schema) => schema.pages ?? [{ id: 'survey', questionIds: schema.questions.map(q => q.id) }];
+export function pageRoute(schema, answers) {
+    const pages = effectivePages(schema), byId = new Map(pages.map((page, index) => [page.id, index]));
+    const visible = visibleAnswers(schema.questions, answers);
+    const available = new Set();
+    const route = [];
+    let current = 0;
+    while (current < pages.length) {
+        route.push(current);
+        pages[current].questionIds.forEach(id => available.add(id));
+        const branch = pages[current].branches?.find(item => conditionMatches(item.when, available.has(item.when.questionId) ? visible[item.when.questionId] : undefined));
+        current = branch ? byId.get(branch.goToPageId) ?? pages.length : current + 1;
+    }
+    return route;
+}
+export function routedAnswers(schema, answers) {
+    let result = visibleAnswers(schema.questions, answers);
+    const pages = effectivePages(schema);
+    for (let pass = 0; pass <= schema.questions.length; pass++) {
+        const reached = new Set(pageRoute(schema, result).flatMap(index => pages[index].questionIds));
+        const filtered = visibleAnswers(schema.questions, Object.fromEntries(Object.entries(result).filter(([id]) => reached.has(id))));
+        if (Object.keys(filtered).length === Object.keys(result).length)
+            return filtered;
+        result = filtered;
+    }
+    throw new Error('Survey route did not stabilize');
+}
+export class SurveyFlow {
+    schema;
+    route;
+    history;
+    current;
+    values;
+    constructor(schema, initial = {}) {
+        this.schema = schema;
+        this.values = routedAnswers(schema, { ...initial });
+        this.route = pageRoute(schema, this.values);
+        this.current = this.route[0] ?? 0;
+        this.history = [this.current];
+    }
+    get page() { return effectivePages(this.schema)[this.current]; }
+    get answers() { return { ...this.values }; }
+    get progress() { return { current: this.current + 1, total: effectivePages(this.schema).length, visited: this.history.length }; }
+    setAnswer(id, value) { const old = this.history; if (value === undefined)
+        delete this.values[id];
+    else
+        this.values[id] = value; this.values = routedAnswers(this.schema, this.values); this.route = pageRoute(this.schema, this.values); if (!this.route.includes(this.current)) {
+        let shared = this.route[0] ?? 0;
+        for (let i = 0; i < Math.min(old.length, this.route.length) && old[i] === this.route[i]; i++)
+            shared = this.route[i];
+        this.current = shared;
+    } this.history = this.route.slice(0, this.route.indexOf(this.current) + 1); }
+    next() { const at = this.route.indexOf(this.current); if (at < 0 || at + 1 >= this.route.length)
+        return false; this.current = this.route[at + 1]; this.history = this.route.slice(0, at + 2); return true; }
+    back() { if (this.history.length < 2)
+        return false; this.history.pop(); this.current = this.history[this.history.length - 1]; return true; }
+}

package/dist/choice-features.d.ts

@@ -0,0 +1,9 @@
+import type { Answer, Question } from './index.js';
+/** Selected option IDs have the same meaning across legacy and structured answers. */
+export declare function selectedChoices(value: unknown): string[];
+export declare function otherTexts(value: unknown): Record<string, string>;
+export declare function choiceAnswer(q: Question, selected: string[], text?: Record<string, string>): Answer;
+export declare function toggleChoice(q: Question, value: unknown, id: string): Answer;
+export declare function setOtherText(q: Question, value: unknown, id: string, text: string): Answer;
+/** Local feedback only; the server validates every accepted answer again. */
+export declare function choiceError(q: Question, value: unknown): 'required' | 'range' | 'other' | 'invalid' | undefined;

package/dist/choice-features.js

@@ -0,0 +1,59 @@
+/** Selected option IDs have the same meaning across legacy and structured answers. */
+export function selectedChoices(value) {
+    if (typeof value === 'string')
+        return value ? [value] : [];
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === 'string');
+    if (value && typeof value === 'object' && 'selected' in value && Array.isArray(value.selected))
+        return value.selected.filter((v) => typeof v === 'string');
+    return [];
+}
+export function otherTexts(value) {
+    if (!value || typeof value !== 'object' || !('otherText' in value) || !value.otherText || typeof value.otherText !== 'object' || Array.isArray(value.otherText))
+        return {};
+    return Object.fromEntries(Object.entries(value.otherText).filter((entry) => typeof entry[1] === 'string'));
+}
+export function choiceAnswer(q, selected, text = {}) {
+    if (q.options?.some(o => o.other !== undefined))
+        return { selected: [...selected], otherText: Object.fromEntries((q.options ?? []).filter(o => o.other !== undefined && selected.includes(o.id)).map(o => [o.id, text[o.id] ?? ''])) };
+    return q.type === 'single_choice' ? selected[0] ?? '' : [...selected];
+}
+export function toggleChoice(q, value, id) {
+    const option = q.options?.find(o => o.id === id);
+    if (!option)
+        throw new TypeError('Unknown choice');
+    const current = selectedChoices(value);
+    const selected = q.type === 'single_choice' ? [id] : current.includes(id) ? current.filter(v => v !== id) : option.exclusive ? [id] : [...current.filter(v => !q.options?.find(o => o.id === v)?.exclusive), id];
+    return choiceAnswer(q, selected, otherTexts(value));
+}
+export function setOtherText(q, value, id, text) {
+    return choiceAnswer(q, selectedChoices(value), { ...otherTexts(value), [id]: text });
+}
+/** Local feedback only; the server validates every accepted answer again. */
+export function choiceError(q, value) {
+    if (value === undefined || value === '')
+        return q.required ? 'required' : undefined;
+    const hasOther = q.options?.some(o => o.other !== undefined);
+    if (hasOther) {
+        if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== 2 || !('selected' in value) || !Array.isArray(value.selected) || !value.selected.every(v => typeof v === 'string') || !('otherText' in value) || !value.otherText || typeof value.otherText !== 'object' || Array.isArray(value.otherText))
+            return 'invalid';
+    }
+    else if (q.type === 'single_choice' ? typeof value !== 'string' : !Array.isArray(value) || !value.every(v => typeof v === 'string'))
+        return 'invalid';
+    const selected = selectedChoices(value);
+    if (new Set(selected).size !== selected.length || selected.some(id => !q.options?.some(o => o.id === id)))
+        return 'invalid';
+    const exclusive = selected.some(id => q.options?.some(o => o.id === id && o.exclusive));
+    if (exclusive && selected.length !== 1)
+        return 'invalid';
+    if (q.type === 'single_choice' ? selected.length !== 1 : selected.length > (q.maxSelections ?? q.options?.length ?? 0) || (!exclusive && selected.length < Math.max(q.required ? 1 : 0, q.minSelections ?? 0)))
+        return 'range';
+    if (hasOther) {
+        const text = otherTexts(value), expected = (q.options ?? []).filter(o => o.other !== undefined && selected.includes(o.id));
+        if (Object.keys(value.otherText).length !== expected.length)
+            return 'other';
+        if (expected.some(o => typeof text[o.id] !== 'string' || !text[o.id].trim() || Array.from(text[o.id]).length > o.other.maxLength))
+            return 'other';
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+export { SurveyFlow, pageRoute, routedAnswers } from './branching.js';
+export type { BranchingSchema, SurveyProgress } from './branching.js';
+export * from './advanced-questions.js';
+export interface StructuredChoiceAnswer {
+    selected: string[];
+    otherText: Record<string, string>;
+}
+export type Answer = string | number | string[] | StructuredChoiceAnswer | Record<string, string | string[]> | Record<string, number>;
+export type QuestionType = 'single_choice' | 'multiple_choice' | 'scale' | 'text' | 'number' | 'date' | 'ranking' | 'matrix' | 'constant_sum';
+export type VisibilityOperator = 'equals' | 'not_equals' | 'includes' | 'not_includes' | 'answered' | 'not_answered';
+export interface VisibilityCondition {
+    questionId: string;
+    operator: VisibilityOperator;
+    value?: string | number;
+}
+export interface PageBranch {
+    when: VisibilityCondition;
+    goToPageId: string;
+}
+export interface SurveyPage {
+    id: string;
+    title?: string;
+    questionIds: string[];
+    branches?: PageBranch[];
+}
+export interface Choice {
+    id: string;
+    label: string;
+    other?: {
+        maxLength: number;
+    };
+    exclusive?: true;
+}
+export interface PromptItem {
+    id: string;
+    label: string;
+}
+export interface Question {
+    id: string;
+    type: QuestionType;
+    label: string;
+    required?: boolean;
+    options?: Choice[];
+    min?: number;
+    max?: number;
+    maxLength?: number;
+    preset?: 'nps' | 'yes_no';
+    labels?: Record<string, string>;
+    minSelections?: number;
+    maxSelections?: number;
+    visibleWhen?: VisibilityCondition;
+    presentation?: 'stars' | 'dropdown';
+    rows?: PromptItem[];
+    columns?: Choice[];
+    matrixMode?: 'single' | 'multiple';
+    items?: PromptItem[];
+    total?: number;
+}
+export interface Collection {
+    id: string;
+    surveyId: string;
+    version: number;
+    placement: string;
+    schema: {
+        schemaVersion: 1 | 2 | 3 | 4 | 5;
+        title: string;
+        questions: Question[];
+        pages?: SurveyPage[];
+    };
+}
+export interface Submission {
+    idempotencyKey: string;
+    answers: Record<string, Answer>;
+    metadata: Record<string, unknown>;
+}
+export interface Receipt {
+    responseId: string;
+    collectionId: string;
+    accepted: true;
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface CollectionRequestOptions extends RequestOptions {
+    refresh?: boolean;
+}
+export interface SurveyMessages {
+    selectPlaceholder: string;
+    back: string;
+    next: string;
+    progress: string;
+    submit: string;
+    submitting: string;
+    submitted: string;
+    submissionError: string;
+    selectionRange: string;
+    otherError: string;
+    moveUp: string;
+    moveDown: string;
+    remaining: string;
+    advancedError: string;
+}
+export interface SurveyClassNames {
+    form: string;
+    title: string;
+    question: string;
+    label: string;
+    control: string;
+    submit: string;
+    status: string;
+}
+export interface MountSurveyOptions {
+    messages?: Partial<SurveyMessages>;
+    classNames?: Partial<SurveyClassNames>;
+}
+export declare const LIKERTS_SDK_CAPABILITY: Readonly<{
+    target: "web";
+    sdkVersion: "0.0.3";
+    schemaVersions: readonly [1, 2, 3, 4, 5];
+}>;
+export declare class LikertsError extends Error {
+    status: number;
+    response: string;
+    constructor(status: number, response: string);
+}
+/** Only a public collection credential belongs here. No administrative credentials. */
+export declare class LikertsClient {
+    private token;
+    private defaultTimeoutMs;
+    private cacheMaxAgeMs;
+    private maxResponseBytes;
+    private baseURL;
+    private transport;
+    private collectionCache;
+    constructor(baseURL: string, token: string, transport?: typeof fetch | undefined, defaultTimeoutMs?: number, cacheMaxAgeMs?: number, maxResponseBytes?: number);
+    private responseText;
+    private request;
+    collection(id: string, options?: CollectionRequestOptions): Promise<Collection>;
+    clearCollectionCache(id?: string): void;
+    /** Retrying requires the same submission object, including its idempotencyKey. */
+    submit(id: string, submission: Submission, options?: RequestOptions): Promise<Receipt>;
+}
+export declare function conditionMatches(condition: VisibilityCondition, answer: Answer | undefined): boolean;
+/** Computes visibility recursively. Hidden source answers are treated as unanswered. */
+export declare function visibleQuestionIds(questions: Question[], answers: Record<string, Answer>): Set<string>;
+/** Removes answers for hidden questions before validation or submission. */
+export declare function visibleAnswers(questions: Question[], answers: Record<string, Answer>): Record<string, Answer>;
+/** Fixed likerts-* classes and data attributes are stable styling hooks; options add host classes without inline styles. */
+export declare function mountSurvey(container: HTMLElement, collection: Collection, client: LikertsClient, onComplete: (receipt: Receipt) => void, metadata?: Record<string, unknown>, options?: MountSurveyOptions): () => void;