@iyulab/lowline-form 0.0.0-stage → 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,32 @@
+import type { Draft, Values } from './draft.js';
+import type { Proposal } from './session.js';
+/** A route of the host refused a call: its status, and what it said. */
+export declare class LowlineError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * The routes a Lowline host maps (`MapLowline` in .NET): `POST {src}/{form}/propose` and `POST {src}/{form}/settle`,
+ * and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
+ * itself — its sign-in — so the calls carry the record only.
+ */
+export declare class LowlineClient {
+    readonly src: string;
+    private readonly fetcher;
+    constructor(src: string, fetcher?: typeof fetch);
+    /** What to show for each open decided field of record `id`, given its values so far. */
+    propose(form: string, id: string, values: Values): Promise<Proposal[]>;
+    /** Saves record `id` holding `saved`, with the draft kept while it was written. */
+    settle(form: string, id: string, saved: Values, draft: Draft): Promise<{
+        id: string;
+        settledAt: string;
+    }>;
+    /** What the host's model makes of `text` for the fields of record values still empty — 404 when the host gave none. */
+    fill(form: string, values: Values, text: string): Promise<Proposal[]>;
+    /**
+     * What the host's model judged for the decided fields of record `id` the records could not answer
+     * (`needs-judgement`) — 404 when the host gave no model.
+     */
+    judge(form: string, id: string, values: Values): Promise<Proposal[]>;
+    private post;
+}

package/dist/client.js

@@ -0,0 +1,52 @@
+/** A route of the host refused a call: its status, and what it said. */
+export class LowlineError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'LowlineError';
+    }
+}
+/**
+ * The routes a Lowline host maps (`MapLowline` in .NET): `POST {src}/{form}/propose` and `POST {src}/{form}/settle`,
+ * and — when the host gave a model — `fill` and `judge`. The host decides the memory space and the choices a person may pick from the request
+ * itself — its sign-in — so the calls carry the record only.
+ */
+export class LowlineClient {
+    constructor(src, fetcher = (...args) => fetch(...args)) {
+        this.src = src;
+        this.fetcher = fetcher;
+    }
+    /** What to show for each open decided field of record `id`, given its values so far. */
+    propose(form, id, values) {
+        return this.post(form, 'propose', { id, values });
+    }
+    /** Saves record `id` holding `saved`, with the draft kept while it was written. */
+    settle(form, id, saved, draft) {
+        return this.post(form, 'settle', { id, saved, draft });
+    }
+    /** What the host's model makes of `text` for the fields of record values still empty — 404 when the host gave none. */
+    fill(form, values, text) {
+        return this.post(form, 'fill', { values, text });
+    }
+    /**
+     * What the host's model judged for the decided fields of record `id` the records could not answer
+     * (`needs-judgement`) — 404 when the host gave no model.
+     */
+    judge(form, id, values) {
+        return this.post(form, 'judge', { id, values });
+    }
+    async post(form, route, body) {
+        const url = `${this.src.replace(/\/+$/, '')}/${encodeURIComponent(form)}/${route}`;
+        const response = await this.fetcher(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            credentials: 'same-origin',
+        });
+        if (!response.ok) {
+            const problem = await response.json().catch(() => undefined);
+            throw new LowlineError(response.status, problem?.detail ?? `${route} answered ${response.status}`);
+        }
+        return (await response.json());
+    }
+}

package/dist/draft.d.ts

@@ -0,0 +1,50 @@
+/** What a field holds: one text, or several for a field that takes several. */
+export type Value = string | string[];
+/** A record's values by field. */
+export type Values = Record<string, Value>;
+/** A suggestion shown for a field: a value, or — `fit: 'prefix'` — a class the value begins with. */
+export interface Suggestion {
+    value: string;
+    origin?: 'decider' | 'other';
+    fit?: 'exact' | 'prefix';
+}
+interface Track {
+    shown?: Suggestion;
+    declined?: boolean;
+    held?: number;
+}
+/**
+ * The account of one record while it is written: the values it was opened with, and for each field the suggestion
+ * last shown, whether it was turned down, and whether its answer was held back to be checked. The host's engine
+ * turns it, with the saved values, into what each decided field teaches — so a value taken from a suggestion is never
+ * counted as one typed. It is only bookkeeping: nothing is counted here.
+ *
+ * Written as the engine reads it: `{ opened, fields: { field: { shown, declined, held } } }`.
+ */
+export declare class Draft {
+    readonly opened: Values;
+    readonly fields: Record<string, Track>;
+    /** A record opened holding `values` — none for a new one. Empty values are left out. */
+    constructor(values?: Values);
+    /** A suggestion came into view for the field. A suggestion turned down earlier stays turned down only if it is this. */
+    show(field: string, suggestion: Suggestion): void;
+    /** The field's answer is held back for a check, drawn with `probability`: what the person settles is checked. */
+    hold(field: string, probability: number): void;
+    /** The person turned down the suggestion in view; false, changing nothing, when none was shown. */
+    decline(field: string): boolean;
+    /** Whether `suggestion` is the one in view for the field and the person turned it down. */
+    declined(field: string, suggestion: Suggestion): boolean;
+    shown(field: string): Suggestion | undefined;
+    held(field: string): number | undefined;
+    toJSON(): {
+        opened: Values;
+        fields: Record<string, Track>;
+    };
+}
+export declare function isEmpty(value: Value | undefined): boolean;
+/**
+ * A form's data as the engine takes it: texts, and lists of texts; a number or a check as its text. Empty fields are
+ * left out.
+ */
+export declare function valuesOf(data: Record<string, unknown>): Values;
+export {};

package/dist/draft.js

@@ -0,0 +1,74 @@
+/**
+ * The account of one record while it is written: the values it was opened with, and for each field the suggestion
+ * last shown, whether it was turned down, and whether its answer was held back to be checked. The host's engine
+ * turns it, with the saved values, into what each decided field teaches — so a value taken from a suggestion is never
+ * counted as one typed. It is only bookkeeping: nothing is counted here.
+ *
+ * Written as the engine reads it: `{ opened, fields: { field: { shown, declined, held } } }`.
+ */
+export class Draft {
+    /** A record opened holding `values` — none for a new one. Empty values are left out. */
+    constructor(values = {}) {
+        this.fields = {};
+        this.opened = Object.fromEntries(Object.entries(values).filter(([, v]) => !isEmpty(v)));
+    }
+    /** A suggestion came into view for the field. A suggestion turned down earlier stays turned down only if it is this. */
+    show(field, suggestion) {
+        const track = (this.fields[field] ??= {});
+        if (!sameSuggestion(track.shown, suggestion))
+            track.declined = false;
+        track.shown = { ...suggestion };
+        delete track.held;
+    }
+    /** The field's answer is held back for a check, drawn with `probability`: what the person settles is checked. */
+    hold(field, probability) {
+        if (!(probability > 0 && probability <= 1))
+            throw new RangeError('a check is drawn with a probability above 0 and at most 1');
+        this.fields[field] = { held: probability };
+    }
+    /** The person turned down the suggestion in view; false, changing nothing, when none was shown. */
+    decline(field) {
+        const track = this.fields[field];
+        if (!track?.shown)
+            return false;
+        track.declined = true;
+        return true;
+    }
+    /** Whether `suggestion` is the one in view for the field and the person turned it down. */
+    declined(field, suggestion) {
+        const track = this.fields[field];
+        return track?.declined === true && sameSuggestion(track.shown, suggestion);
+    }
+    shown(field) {
+        return this.fields[field]?.shown;
+    }
+    held(field) {
+        return this.fields[field]?.held;
+    }
+    toJSON() {
+        return { opened: this.opened, fields: this.fields };
+    }
+}
+function sameSuggestion(a, b) {
+    return a !== undefined && a.value === b.value && (a.origin ?? 'decider') === (b.origin ?? 'decider') && (a.fit ?? 'exact') === (b.fit ?? 'exact');
+}
+export function isEmpty(value) {
+    return value === undefined || (Array.isArray(value) ? value.every((v) => v === '') : value === '');
+}
+/**
+ * A form's data as the engine takes it: texts, and lists of texts; a number or a check as its text. Empty fields are
+ * left out.
+ */
+export function valuesOf(data) {
+    const values = {};
+    for (const [field, raw] of Object.entries(data)) {
+        const value = Array.isArray(raw)
+            ? raw.map(String)
+            : raw === null || raw === undefined
+                ? undefined
+                : String(raw);
+        if (value !== undefined && !isEmpty(value))
+            values[field] = value;
+    }
+    return values;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Draft, valuesOf, type Suggestion, type Value, type Values } from './draft.js';
+export { Session, englishStrings, type Abstain, type Basis, type FieldState, type Proposal, type Round, type Strings } from './session.js';
+export { LowlineClient, LowlineError } from './client.js';
+export { LowlineForm } from './lowline-form.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { Draft, valuesOf } from './draft.js';
+export { Session, englishStrings } from './session.js';
+export { LowlineClient, LowlineError } from './client.js';
+export { LowlineForm } from './lowline-form.js';

package/dist/lowline-form.d.ts

@@ -0,0 +1,71 @@
+import { LitElement } from 'lit';
+import '@formdown/ui';
+import { type Values } from './draft.js';
+import { type Strings } from './session.js';
+/**
+ * A formdown form whose decided fields are suggested from the records people confirmed. It asks the host's routes
+ * (`src` — where `MapLowline` put them) what to show for form `form` while record `record` is written, draws each
+ * suggestion in its field, keeps the account of what the person took or turned down, and sends it with the save.
+ *
+ * ```html
+ * <lowline-form src="/lowline" form="intake" record="r-17"></lowline-form>
+ * ```
+ *
+ * Set `content` to the form's formdown text and, for a record opened again, `data` to its values. `save()` saves it;
+ * `lowline-saved` follows with `{ id, settledAt, values }`.
+ */
+export declare class LowlineForm extends LitElement {
+    /** Where the host's routes are. */
+    src: string;
+    /** The form, by the name the host defined it under. */
+    form: string;
+    /** The record being written; opening a record again under its id keeps it from being evidence for itself. */
+    record: string;
+    /** The form's formdown text. */
+    content: string;
+    /** The record's values when it was opened. */
+    data: Record<string, unknown>;
+    /** How often a field's answer is held back to check it, from 0 to 1. */
+    rate: number;
+    /** The words the form shows, in the host's language. */
+    strings: Strings;
+    private formdown?;
+    private session?;
+    private asking?;
+    private client;
+    private fieldStates;
+    /** Whether the host judges what the records could not answer — until its `judge` route says it has no model. */
+    private canJudge;
+    protected createRenderRoot(): this;
+    protected willUpdate(changed: Map<PropertyKey, unknown>): void;
+    protected updated(changed: Map<PropertyKey, unknown>): void;
+    render(): import("lit-html").TemplateResult<1>;
+    /** The values the form holds now. */
+    values(): Values;
+    /** Saves the record as it stands, with the account of what was shown and done; what is written next starts here. */
+    save(): Promise<{
+        id: string;
+        settledAt: string;
+    }>;
+    /**
+     * Fills the record from `text` — what the person wrote or a picture's description — through the host's model: each
+     * value it gives is offered in its field for the person to take. Nothing is put in on its own.
+     */
+    fill(text: string): Promise<void>;
+    /** Asks again what to show for the decided fields still open. */
+    ask(): Promise<void>;
+    /**
+     * Asks the host to judge the fields of a round the records could not answer — apart from the round, since a model
+     * takes longer — and asks again once it has, so the judgements are shown in their fields.
+     */
+    private judge;
+    private changed;
+    private picked;
+    private declined;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lowline-form': LowlineForm;
+    }
+}

package/dist/lowline-form.js

@@ -0,0 +1,212 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LitElement, html } from 'lit';
+import { customElement, property, query } from 'lit/decorators.js';
+import '@formdown/ui';
+import { LowlineClient, LowlineError } from './client.js';
+import { valuesOf } from './draft.js';
+import { Session, englishStrings } from './session.js';
+/** How long typing pauses before the decided fields are asked about again. */
+const ASK_DELAY_MS = 300;
+/**
+ * A formdown form whose decided fields are suggested from the records people confirmed. It asks the host's routes
+ * (`src` — where `MapLowline` put them) what to show for form `form` while record `record` is written, draws each
+ * suggestion in its field, keeps the account of what the person took or turned down, and sends it with the save.
+ *
+ * ```html
+ * <lowline-form src="/lowline" form="intake" record="r-17"></lowline-form>
+ * ```
+ *
+ * Set `content` to the form's formdown text and, for a record opened again, `data` to its values. `save()` saves it;
+ * `lowline-saved` follows with `{ id, settledAt, values }`.
+ */
+let LowlineForm = class LowlineForm extends LitElement {
+    constructor() {
+        super(...arguments);
+        /** Where the host's routes are. */
+        this.src = '/lowline';
+        /** The form, by the name the host defined it under. */
+        this.form = '';
+        /** The record being written; opening a record again under its id keeps it from being evidence for itself. */
+        this.record = '';
+        /** The form's formdown text. */
+        this.content = '';
+        /** The record's values when it was opened. */
+        this.data = {};
+        /** How often a field's answer is held back to check it, from 0 to 1. */
+        this.rate = 0.05;
+        /** The words the form shows, in the host's language. */
+        this.strings = englishStrings;
+        this.client = new LowlineClient(this.src);
+        this.fieldStates = {};
+        /** Whether the host judges what the records could not answer — until its `judge` route says it has no model. */
+        this.canJudge = true;
+        this.changed = () => {
+            clearTimeout(this.asking);
+            this.asking = setTimeout(() => void this.ask(), ASK_DELAY_MS);
+        };
+        this.picked = (event) => {
+            const { field, value } = event.detail;
+            this.session?.picked(field);
+            const formdown = this.formdown;
+            if (formdown)
+                formdown.updateData({ ...formdown.data, [field]: value });
+        };
+        this.declined = (event) => {
+            const { field } = event.detail;
+            const formdown = this.formdown;
+            if (this.session?.decline(field, this.values()) && formdown)
+                formdown.updateData({ ...formdown.data, [field]: '' });
+            const { [field]: _, ...rest } = this.fieldStates;
+            this.fieldStates = rest;
+            if (formdown)
+                formdown.fieldStates = rest;
+        };
+    }
+    createRenderRoot() {
+        return this;
+    }
+    willUpdate(changed) {
+        if (changed.has('src')) {
+            this.client = new LowlineClient(this.src);
+            this.canJudge = true;
+        }
+        if (changed.has('record') || changed.has('form') || changed.has('data') || changed.has('content')) {
+            // The values it was opened with are taken before anything is suggested or put in.
+            this.session = new Session(this.record, valuesOf(this.data), this.rate, Math.random, this.strings);
+            this.fieldStates = {};
+        }
+    }
+    updated(changed) {
+        if (changed.has('record') || changed.has('form') || changed.has('content'))
+            void this.ask();
+    }
+    render() {
+        return html `<formdown-ui
+      .content=${this.content}
+      .data=${this.data}
+      .fieldStates=${this.fieldStates}
+      @formdown-change=${this.changed}
+      @formdown-suggestion-pick=${this.picked}
+      @formdown-suggestion-decline=${this.declined}
+    ></formdown-ui>`;
+    }
+    /** The values the form holds now. */
+    values() {
+        return valuesOf(this.formdown?.data ?? this.data);
+    }
+    /** Saves the record as it stands, with the account of what was shown and done; what is written next starts here. */
+    async save() {
+        if (!this.session || !this.form || !this.record)
+            throw new Error('lowline-form needs a form and a record to save');
+        const values = this.values();
+        const saved = await this.client.settle(this.form, this.record, values, this.session.draft);
+        this.session.saved(values);
+        this.dispatchEvent(new CustomEvent('lowline-saved', { detail: { ...saved, values }, bubbles: true, composed: true }));
+        return saved;
+    }
+    /**
+     * Fills the record from `text` — what the person wrote or a picture's description — through the host's model: each
+     * value it gives is offered in its field for the person to take. Nothing is put in on its own.
+     */
+    async fill(text) {
+        const session = this.session;
+        if (!session || !this.form)
+            return;
+        const proposals = await this.client.fill(this.form, this.values(), text);
+        if (session !== this.session)
+            return;
+        this.fieldStates = session.applyFill(proposals);
+        if (this.formdown)
+            this.formdown.fieldStates = this.fieldStates;
+    }
+    /** Asks again what to show for the decided fields still open. */
+    async ask() {
+        const session = this.session;
+        if (!session || !this.form || !this.record)
+            return;
+        const values = this.values();
+        let proposals;
+        try {
+            proposals = await this.client.propose(this.form, this.record, values);
+        }
+        catch (error) {
+            // Suggestions are an aid: without them the form is filled in by hand.
+            this.dispatchEvent(new CustomEvent('lowline-unavailable', { detail: { error }, bubbles: true, composed: true }));
+            return;
+        }
+        if (session !== this.session)
+            return;
+        const shown = session.judged(proposals);
+        const round = session.apply(shown, values);
+        this.fieldStates = round.fieldStates;
+        const formdown = this.formdown;
+        if (!formdown)
+            return;
+        if (Object.keys(round.prefill).length > 0)
+            formdown.updateData({ ...formdown.data, ...round.prefill });
+        formdown.fieldStates = this.fieldStates;
+        if (this.canJudge)
+            void this.judge(session, values, shown);
+    }
+    /**
+     * Asks the host to judge the fields of a round the records could not answer — apart from the round, since a model
+     * takes longer — and asks again once it has, so the judgements are shown in their fields.
+     */
+    async judge(session, values, round) {
+        const fields = session.toJudge(round);
+        if (fields.length === 0)
+            return;
+        const asked = round.filter((p) => fields.includes(p.field));
+        let judged;
+        try {
+            judged = await this.client.judge(this.form, this.record, values);
+        }
+        catch (error) {
+            if (error instanceof LowlineError && error.status === 404)
+                this.canJudge = false;
+            session.notJudged(asked);
+            return;
+        }
+        if (session !== this.session)
+            return;
+        session.takeJudged(asked, judged);
+        void this.ask();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        clearTimeout(this.asking);
+    }
+};
+__decorate([
+    property()
+], LowlineForm.prototype, "src", void 0);
+__decorate([
+    property()
+], LowlineForm.prototype, "form", void 0);
+__decorate([
+    property()
+], LowlineForm.prototype, "record", void 0);
+__decorate([
+    property()
+], LowlineForm.prototype, "content", void 0);
+__decorate([
+    property({ attribute: false })
+], LowlineForm.prototype, "data", void 0);
+__decorate([
+    property({ type: Number })
+], LowlineForm.prototype, "rate", void 0);
+__decorate([
+    property({ attribute: false })
+], LowlineForm.prototype, "strings", void 0);
+__decorate([
+    query('formdown-ui')
+], LowlineForm.prototype, "formdown", void 0);
+LowlineForm = __decorate([
+    customElement('lowline-form')
+], LowlineForm);
+export { LowlineForm };

package/dist/session.d.ts

@@ -0,0 +1,111 @@
+import { Draft, type Suggestion, type Values } from './draft.js';
+/** What a suggestion rests on: another field's value it was settled under, or a settled record like this one. */
+export type Basis = {
+    kind: 'value';
+    field: string;
+    value: string;
+} | {
+    kind: 'record';
+    id: string;
+    similarity: number;
+};
+/** Why a decided field is shown no suggestion. */
+export type Abstain = 'off' | 'no-evidence' | 'unsure' | 'not-allowed' | 'needs-judgement' | 'not-a-choice' | 'malformed';
+/** What the host's engine says to show for one decided field. */
+export interface Proposal {
+    field: string;
+    suggestion: Suggestion | null;
+    /** Whether the suggestion may go in as the field's value without the person taking it. */
+    prefill: boolean;
+    layer: 'key' | 'similar' | 'judgement' | null;
+    basis?: Basis[];
+    abstain: Abstain | null;
+    asks?: [string, string][];
+}
+/** What a field shows, as formdown's `fieldStates` takes it. */
+export interface FieldState {
+    suggestions?: string[];
+    note?: string;
+    decline?: string;
+    label?: string;
+}
+/** The words the form shows, in the host's language. */
+export interface Strings {
+    /** The button that turns the suggestion down. */
+    decline: string;
+    /** The note of a suggestion settled before under another field's value: `{field}` and `{value}` are filled in. */
+    fromValue: string;
+    /** The note of a suggestion taken from a similar record. */
+    fromSimilar: string;
+    /** The note of a suggestion from a judgement made outside the records. */
+    fromJudgement: string;
+    /** The note of a value filled in from what the person wrote. */
+    fromWriting: string;
+}
+export declare const englishStrings: Strings;
+/** What the form does with one round of proposals: what each field shows, and the values to put in unasked. */
+export interface Round {
+    fieldStates: Record<string, FieldState>;
+    prefill: Values;
+}
+/**
+ * One record being written: its draft, and what its fields show. A field's answer may be held back once, at random,
+ * to check it — `rate` is how often (one in twenty by default), drawn once per field of the record, before its answer
+ * is looked at, and only for a value the decider suggests.
+ */
+export declare class Session {
+    readonly id: string;
+    readonly rate: number;
+    private readonly random;
+    private readonly strings;
+    draft: Draft;
+    private drawn;
+    /** Fields whose value the form put in unasked, from the suggestion still shown. */
+    private filled;
+    /** What filling from the person's writing offers, by field, until the person picks it or turns it down. */
+    private written;
+    /** The judgement asked for each field, by what it reads; `null` while the host is still judging. */
+    private judgements;
+    constructor(id: string, opened: Values, rate?: number, random?: () => number, strings?: Strings);
+    /**
+     * Takes a round of proposals for the form's `values` now. A field offered a value from the person's writing keeps it
+     * in view until the person picks it or turns it down.
+     */
+    apply(proposals: Proposal[], values: Values): Round;
+    /**
+     * The round's proposals with each field that asks for a judgement answered by the one already judged on the same
+     * values, if there is one — so a judgement stays in view while the person writes on, and is not asked for again.
+     */
+    judged(proposals: Proposal[]): Proposal[];
+    /**
+     * The fields of the round that ask for a judgement not asked for yet on what they read; marked as being asked. A field
+     * with nothing to read yet is left until there is something.
+     */
+    toJudge(proposals: Proposal[]): string[];
+    /**
+     * Takes what the host judged for the fields `asked` — each a proposal as the round would give it; a field it gave
+     * nothing for stays as it was, and is not asked about again on the same values. A field asked for again since, on
+     * other values, keeps waiting for that one.
+     */
+    takeJudged(asked: Proposal[], judged: Proposal[]): void;
+    /** The host could not judge the fields `asked`: they may be asked about again. */
+    notJudged(asked: Proposal[]): void;
+    /**
+     * Takes what filling from the person's writing offers: each value shown as a suggestion from elsewhere, never put in
+     * on its own, in place of what the records suggest for the field. Answers what every field shows now.
+     */
+    applyFill(proposals: Proposal[]): Record<string, FieldState>;
+    /** The person picked a field's offered value: what was offered from their writing has done its part. */
+    picked(field: string): void;
+    /**
+     * The person turned down the field's suggestion. Answers whether the form must empty the field: it holds the value
+     * the form put in unasked — saved as it is, the turned-down value would count as taken.
+     */
+    decline(field: string, values: Values): boolean;
+    /** The record was saved holding `values`: what is written next starts from them. */
+    saved(values: Values): void;
+    /** Whether the field's answer is held back now — drawn the first time a checkable value is proposed for it. */
+    private draw;
+    /** Where the suggestion comes from, in words. A field's value is shown as the record holds it now. */
+    private note;
+}