@kolibri-day/feedback 0.0.0-stage → 0.1.1

package/dist/esm/kernel/feedback/fake-target.js

@@ -0,0 +1,82 @@
+import { FeedbackTargetError } from "./types.js";
+import { en } from "./messages.js";
+export class FakeFeedbackTarget {
+    name = 'fake';
+    label;
+    /** Nothing leaves the process, so it is trivially inside the trust boundary. */
+    trustBoundary = 'self_hosted';
+    /** Every submit() call, in order — including the ones that then threw. */
+    submissions = [];
+    /** Calls that actually created a new item (i.e. were not resumes). Duplicate-ticket detector. */
+    creates = [];
+    seq = 0;
+    failures = [];
+    webUrl;
+    constructor(options = {}) {
+        this.webUrl = options.webUrl ?? 'https://fake.invalid';
+        this.label = options.label ?? en.targets.fake;
+    }
+    /** Queue a failure for the NEXT submit() call (repeat to script a sequence). */
+    failNext(error) {
+        this.failures.push(error);
+        return this;
+    }
+    /** Convenience: the two classifications, scripted. */
+    failNextTransient(message = 'target unreachable') {
+        return this.failNext(new FeedbackTargetError(message, false));
+    }
+    failNextPermanent(message = 'target rejected the report') {
+        return this.failNext(new FeedbackTargetError(message, true, 422));
+    }
+    /**
+     * Script the partial failure that resumability exists for: the item was created,
+     * the attachment upload then failed. The error carries the id, exactly as a real
+     * target does, so a durable caller can persist it and resume.
+     */
+    failNextAfterCreate(message = 'attachment upload failed') {
+        const id = `fake_${++this.seq}`;
+        this.creates.push(id);
+        return this.failNext(new FeedbackTargetError(message, false, 502, id, `${this.webUrl}/tasks/${id}`));
+    }
+    async submit(report, resume) {
+        const scripted = this.failures.shift();
+        if (scripted) {
+            this.submissions.push({ report, resume, externalId: scripted.externalId ?? '' });
+            throw scripted;
+        }
+        const externalId = resume?.externalId ?? `fake_${++this.seq}`;
+        if (!resume)
+            this.creates.push(externalId);
+        this.submissions.push({ report, resume, externalId });
+        return {
+            externalId,
+            externalUrl: `${this.webUrl}/tasks/${externalId}`,
+            attachmentsUploaded: report.attachments.length,
+        };
+    }
+}
+/**
+ * A target that always fails permanently with a configuration message.
+ *
+ * This is what an unconfigured production deployment gets, and the choice is
+ * deliberate: reports are still PERSISTED and the failure is LOUD (a failed report
+ * naming the missing variables). The alternative — silently discarding reports, or
+ * refusing the button — would mean people file feedback into nothing and conclude the
+ * team ignored them.
+ *
+ * It is also why a missing variable does not throw at process BOOT: that would take
+ * every other job in the same worker down over a feedback misconfiguration.
+ */
+export class UnconfiguredFeedbackTarget {
+    name = 'unconfigured';
+    trustBoundary = 'self_hosted';
+    label;
+    reason;
+    constructor(reason, label = en.targets.unconfigured) {
+        this.reason = reason;
+        this.label = label;
+    }
+    async submit(_report, _resume) {
+        throw new FeedbackTargetError(this.reason, true);
+    }
+}

package/dist/esm/kernel/feedback/files.d.ts

@@ -0,0 +1,6 @@
+/** The image types the capture produces and the server accepts. */
+export declare const SCREENSHOT_MIME_TYPES: readonly ["image/webp", "image/jpeg", "image/png"];
+/** File extension matching a produced MIME. PNG is the fallback — it is what a canvas emits when asked for a type it cannot encode. */
+export declare function extensionFor(mime: string): string;
+/** "screenshot.webp" etc. */
+export declare function screenshotFilename(mime: string): string;

package/dist/esm/kernel/feedback/files.js

@@ -0,0 +1,16 @@
+// Screenshot file naming, shared by the browser (which names the upload) and the
+// delivery side (which names the attachment at the target) so the two cannot drift.
+/** The image types the capture produces and the server accepts. */
+export const SCREENSHOT_MIME_TYPES = ['image/webp', 'image/jpeg', 'image/png'];
+/** File extension matching a produced MIME. PNG is the fallback — it is what a canvas emits when asked for a type it cannot encode. */
+export function extensionFor(mime) {
+    if (mime === 'image/webp')
+        return 'webp';
+    if (mime === 'image/jpeg')
+        return 'jpg';
+    return 'png';
+}
+/** "screenshot.webp" etc. */
+export function screenshotFilename(mime) {
+    return `screenshot.${extensionFor(mime)}`;
+}

package/dist/esm/kernel/feedback/format.d.ts

@@ -0,0 +1,53 @@
+import type { FeedbackReport } from './types.js';
+import { type FeedbackMessages } from './messages.js';
+export interface FormatOptions {
+    /** Language of the labels. Default: German. */
+    messages?: FeedbackMessages;
+    /** Display labels for the app's own kinds; falls back to `messages.kinds`, then the raw kind. */
+    kindLabels?: Readonly<Record<string, string>>;
+}
+export declare function kindLabel(kind: string, options?: FormatOptions): string;
+/** The route part of a reported URL ("/companies/abc?x=1"), or "" if unparseable. */
+export declare function routeOf(url: string | undefined): string;
+/**
+ * The task title: kind, route, and the first line of the message.
+ *
+ * Front-loaded with the things that make a list of tickets scannable — someone
+ * triaging sees "what kind, where, what" without opening anything. The reporter's
+ * name is deliberately NOT here (it is in the body): a title is a summary of the
+ * problem, and a board of "Bug — Max Mustermann" reads as a list of people.
+ */
+export declare function buildTitle(report: FeedbackReport, options?: FormatOptions): string;
+/**
+ * A fence long enough to survive the text it wraps.
+ *
+ * CommonMark's rule: a fenced block ends at a run of backticks at least as long as
+ * the opening one, so an opener longer than anything inside cannot be closed early.
+ * A reporter pasting a fenced code snippet into the feedback box is the case this
+ * exists for — without it their ``` closes ours and the rest of the report renders as
+ * markup.
+ *
+ * Kolibri's renderer is explicitly NOT CommonMark-conformant, so this rule was checked
+ * against it rather than taken from the spec: the fence closes only on "a marker at
+ * least as long as the one that opened it" (packages/shared/src/modules/pages/
+ * markdown.ts), and a report carrying a fenced snippet was run
+ * through that renderer end to end — both context tables intact, the snippet verbatim.
+ */
+export declare function fenceFor(text: string): string;
+/**
+ * The task description, as Markdown.
+ *
+ * Structured in three blocks, in this order and for this reason:
+ *   1. the reporter's own words, first and unmangled — that is the actual report;
+ *   2. SERVER-DERIVED context, which is trustworthy;
+ *   3. CLIENT-REPORTED context, explicitly labelled as such.
+ *
+ * (2) and (3) are separate tables rather than one merged block precisely so nobody
+ * reading the ticket has to remember which fields the browser was free to make up.
+ *
+ * The reporter's text sits in a fenced block rather than as running prose: a bug
+ * report is frequently steps on separate lines, and a fence preserves them exactly
+ * while also keeping a stray `#` or `**` from restyling the ticket. `text` as the
+ * language tag means no highlighter tries to interpret it.
+ */
+export declare function buildDescriptionMarkdown(report: FeedbackReport, options?: FormatOptions): string;

package/dist/esm/kernel/feedback/format.js

@@ -0,0 +1,133 @@
+import { en } from "./messages.js";
+export function kindLabel(kind, options = {}) {
+    const messages = options.messages ?? en;
+    return options.kindLabels?.[kind] ?? messages.kinds[kind] ?? kind;
+}
+/** Collapse to a single line and cut to `max`, so a title can't carry a newline or run long. */
+function oneLine(value, max) {
+    const flat = value.replace(/\s+/g, ' ').trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
+}
+/** The route part of a reported URL ("/companies/abc?x=1"), or "" if unparseable. */
+export function routeOf(url) {
+    if (!url)
+        return '';
+    try {
+        const u = new URL(url);
+        return `${u.pathname}${u.search}`;
+    }
+    catch {
+        // A client-supplied string that isn't a URL. Keep it if it already looks like a
+        // path (the common case for a relative report), else drop it rather than guess.
+        return url.startsWith('/') ? oneLine(url, 120) : '';
+    }
+}
+/**
+ * The task title: kind, route, and the first line of the message.
+ *
+ * Front-loaded with the things that make a list of tickets scannable — someone
+ * triaging sees "what kind, where, what" without opening anything. The reporter's
+ * name is deliberately NOT here (it is in the body): a title is a summary of the
+ * problem, and a board of "Bug — Max Mustermann" reads as a list of people.
+ */
+export function buildTitle(report, options = {}) {
+    const messages = options.messages ?? en;
+    const kind = kindLabel(report.kind, options);
+    const route = routeOf(typeof report.client?.url === 'string' ? report.client.url : undefined);
+    const summary = oneLine(report.message, 80) || messages.report.untitled;
+    return oneLine(route ? `[${kind}] ${route} — ${summary}` : `[${kind}] ${summary}`, 200);
+}
+/**
+ * A fence long enough to survive the text it wraps.
+ *
+ * CommonMark's rule: a fenced block ends at a run of backticks at least as long as
+ * the opening one, so an opener longer than anything inside cannot be closed early.
+ * A reporter pasting a fenced code snippet into the feedback box is the case this
+ * exists for — without it their ``` closes ours and the rest of the report renders as
+ * markup.
+ *
+ * Kolibri's renderer is explicitly NOT CommonMark-conformant, so this rule was checked
+ * against it rather than taken from the spec: the fence closes only on "a marker at
+ * least as long as the one that opened it" (packages/shared/src/modules/pages/
+ * markdown.ts), and a report carrying a fenced snippet was run
+ * through that renderer end to end — both context tables intact, the snippet verbatim.
+ */
+export function fenceFor(text) {
+    const longest = [...text.matchAll(/`+/g)].reduce((max, m) => Math.max(max, m[0].length), 0);
+    return '`'.repeat(Math.max(3, longest + 1));
+}
+/**
+ * One table cell.
+ *
+ * Two transformations, both structural: a newline would end the table row, and an
+ * unescaped `|` would split one cell into two. `\|` is the escape Kolibri's table
+ * parser honours (§B9). Nothing here is a security measure — see the file header.
+ */
+function cell(value) {
+    const v = value === null || value === undefined || value === '' ? '—' : String(value);
+    return v.replace(/\s+/g, ' ').trim().replace(/\|/g, '\\|') || '—';
+}
+function table(rows, messages) {
+    return [
+        `| ${messages.report.field} | ${messages.report.value} |`,
+        '| --- | --- |',
+        ...rows.map(([label, value]) => `| ${cell(label)} | ${cell(value)} |`),
+    ].join('\n');
+}
+/**
+ * The task description, as Markdown.
+ *
+ * Structured in three blocks, in this order and for this reason:
+ *   1. the reporter's own words, first and unmangled — that is the actual report;
+ *   2. SERVER-DERIVED context, which is trustworthy;
+ *   3. CLIENT-REPORTED context, explicitly labelled as such.
+ *
+ * (2) and (3) are separate tables rather than one merged block precisely so nobody
+ * reading the ticket has to remember which fields the browser was free to make up.
+ *
+ * The reporter's text sits in a fenced block rather than as running prose: a bug
+ * report is frequently steps on separate lines, and a fence preserves them exactly
+ * while also keeping a stray `#` or `**` from restyling the ticket. `text` as the
+ * language tag means no highlighter tries to interpret it.
+ */
+export function buildDescriptionMarkdown(report, options = {}) {
+    const messages = options.messages ?? en;
+    const m = messages.report;
+    const r = report.reporter;
+    const c = report.client ?? {};
+    const message = report.message.trim() || m.untitled;
+    const fence = fenceFor(message);
+    const name = r.name || '—';
+    const serverRows = [
+        [m.reportedBy, r.role ? `${name} (${r.role})` : name],
+        [m.userId, r.id],
+        ...(report.serverContext ?? []),
+        [m.reportedAtServer, report.createdAt.toISOString()],
+        [m.reportId, report.id],
+    ];
+    const clientRows = [
+        [m.url, c.url],
+        [m.pageTitle, c.title],
+        [m.viewport, c.viewport],
+        [m.screen, c.screen],
+        [m.devicePixelRatio, c.devicePixelRatio],
+        [m.userAgent, c.userAgent],
+        [m.language, c.language],
+        [m.timezone, c.timezone],
+        [m.online, c.online === undefined ? undefined : c.online ? m.yes : m.no],
+        [m.connection, c.connection],
+        [m.clientTime, c.clientTime],
+    ];
+    const backlink = report.backlink?.url ? `[${report.backlink.label ?? m.openReport}](${report.backlink.url})` : '';
+    return [
+        `**${m.description}**`,
+        `${fence}text\n${message}\n${fence}`,
+        `**${m.serverContext}**`,
+        table(serverRows, messages),
+        `**${m.clientContext}**`,
+        table(clientRows, messages),
+        backlink,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}

package/dist/esm/kernel/feedback/input.d.ts

@@ -0,0 +1,79 @@
+import type { FeedbackClientContext } from './types.js';
+import { type FeedbackMessages } from './messages.js';
+export interface FeedbackLimits {
+    /** Free text cap. Generous — a good bug report is long — but not unbounded. */
+    maxMessageLength: number;
+    /**
+     * Hard ceiling on an accepted screenshot. The browser capture targets ~1 MB and a
+     * typical UI screenshot is far below that, so anything approaching this is either
+     * a pathological page or a hand-crafted request.
+     */
+    maxScreenshotBytes: number;
+    /** Room for the text fields on top of the screenshot, for the whole-body pre-check. */
+    maxBodyOverheadBytes: number;
+    /** Client-context keys are capped in count and size — it is an untrusted free-form blob. */
+    maxContextKeys: number;
+    maxContextKeyLength: number;
+    maxContextValueLength: number;
+    /** The serialized client-context field; anything longer is dropped, not parsed. */
+    maxContextJsonLength: number;
+}
+export declare const DEFAULT_LIMITS: Readonly<FeedbackLimits>;
+export interface FeedbackScreenshotInput {
+    bytes: Uint8Array;
+    contentType: string;
+}
+/** The wire shape — deliberately the COMPLETE set of things a client may say. */
+export interface FeedbackInput {
+    kind: string;
+    message: string;
+    clientContext: unknown;
+    screenshot?: FeedbackScreenshotInput | null;
+}
+export interface ParsedFeedbackInput<K extends string = string> {
+    kind: K;
+    message: string;
+    clientContext: FeedbackClientContext;
+    screenshot: FeedbackScreenshotInput | null;
+}
+/**
+ * A report the server will not accept, with the HTTP status to answer it with and a
+ * message worded for the reporter.
+ */
+export declare class FeedbackInputError extends Error {
+    readonly status: 400 | 413;
+    constructor(message: string, status: 400 | 413);
+}
+interface InputOptions {
+    limits?: Partial<FeedbackLimits>;
+    /** Language of the error messages. Default: German. */
+    messages?: FeedbackMessages;
+}
+/**
+ * Normalize the untrusted client-context blob.
+ *
+ * Permissive about WHICH keys arrive (the browser facts worth capturing will change,
+ * and a strict allowlist would silently drop new ones) but strict about SIZE and
+ * DEPTH: scalars only, bounded key count, bounded string length. An unbounded nested
+ * object here would be a free write-amplification primitive into whatever stores it.
+ */
+export declare function sanitizeClientContext(raw: unknown, limits?: Partial<FeedbackLimits>): FeedbackClientContext;
+export interface ParseOptions<K extends string> extends InputOptions {
+    /** The kinds this app accepts. Anything else is refused rather than defaulted. */
+    kinds: readonly K[];
+}
+/** Validate + normalize the wire shape. Pure: no I/O, no session, no side effects. */
+export declare function parseFeedbackInput<K extends string>(input: FeedbackInput, options: ParseOptions<K>): ParsedFeedbackInput<K>;
+/**
+ * Read the multipart body the browser half sends (fields `kind`, `message`,
+ * `clientContext` as JSON, optional file `screenshot`) into the wire shape.
+ *
+ * Validation of the CONTENT is parseFeedbackInput's job; this only refuses what must
+ * not be buffered at all, and tolerates what is merely decorative:
+ * - the declared Content-Length is checked before anything is read into memory
+ *   (absent or lying headers are still caught by the per-part size check);
+ * - a malformed or oversized client context becomes `{}` — it must never be the
+ *   reason a report is lost.
+ */
+export declare function readFeedbackForm(request: Request, options?: InputOptions): Promise<FeedbackInput>;
+export {};

package/dist/esm/kernel/feedback/input.js

@@ -0,0 +1,150 @@
+import { SCREENSHOT_MIME_TYPES } from "./files.js";
+import { en } from "./messages.js";
+export const DEFAULT_LIMITS = Object.freeze({
+    maxMessageLength: 5_000,
+    maxScreenshotBytes: 3 * 1024 * 1024,
+    maxBodyOverheadBytes: 256 * 1024,
+    maxContextKeys: 40,
+    maxContextKeyLength: 64,
+    maxContextValueLength: 2_000,
+    maxContextJsonLength: 20_000,
+});
+/**
+ * A report the server will not accept, with the HTTP status to answer it with and a
+ * message worded for the reporter.
+ */
+export class FeedbackInputError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = 'FeedbackInputError';
+        this.status = status;
+    }
+}
+function limitsOf(options) {
+    return { ...DEFAULT_LIMITS, ...options.limits };
+}
+/**
+ * Normalize the untrusted client-context blob.
+ *
+ * Permissive about WHICH keys arrive (the browser facts worth capturing will change,
+ * and a strict allowlist would silently drop new ones) but strict about SIZE and
+ * DEPTH: scalars only, bounded key count, bounded string length. An unbounded nested
+ * object here would be a free write-amplification primitive into whatever stores it.
+ */
+export function sanitizeClientContext(raw, limits = {}) {
+    const l = { ...DEFAULT_LIMITS, ...limits };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    let count = 0;
+    for (const [key, value] of Object.entries(raw)) {
+        if (count >= l.maxContextKeys)
+            break;
+        if (key.length > l.maxContextKeyLength)
+            continue;
+        if (typeof value === 'string') {
+            out[key] = value.slice(0, l.maxContextValueLength);
+        }
+        else if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+            out[key] = value;
+        }
+        else {
+            continue; // objects/arrays/functions — not a browser fact worth carrying
+        }
+        count++;
+    }
+    return out;
+}
+/** Validate + normalize the wire shape. Pure: no I/O, no session, no side effects. */
+export function parseFeedbackInput(input, options) {
+    const messages = options.messages ?? en;
+    const limits = limitsOf(options);
+    const message = (input.message ?? '').trim();
+    if (message.length === 0)
+        throw new FeedbackInputError(messages.input.messageRequired, 400);
+    if (message.length > limits.maxMessageLength) {
+        throw new FeedbackInputError(messages.input.messageTooLong(limits.maxMessageLength), 400);
+    }
+    // `includes` on the app's own list, not `in` on an object: "constructor" and
+    // "toString" must not pass as kinds.
+    if (typeof input.kind !== 'string' || !options.kinds.includes(input.kind)) {
+        throw new FeedbackInputError(messages.input.unknownKind, 400);
+    }
+    let screenshot = null;
+    if (input.screenshot) {
+        const { bytes, contentType } = input.screenshot;
+        if (bytes.byteLength === 0) {
+            // An empty part means capture failed client-side. Drop it and keep the report:
+            // the reporter's text is the point, and failing the whole submission over a
+            // screenshot would lose the one part that cannot be re-derived.
+            screenshot = null;
+        }
+        else if (bytes.byteLength > limits.maxScreenshotBytes) {
+            throw new FeedbackInputError(messages.input.screenshotTooLarge, 400);
+        }
+        else if (!SCREENSHOT_MIME_TYPES.includes(contentType)) {
+            throw new FeedbackInputError(messages.input.unsupportedImage, 400);
+        }
+        else {
+            screenshot = { bytes, contentType };
+        }
+    }
+    return {
+        kind: input.kind,
+        message,
+        clientContext: sanitizeClientContext(input.clientContext, limits),
+        screenshot,
+    };
+}
+/**
+ * Read the multipart body the browser half sends (fields `kind`, `message`,
+ * `clientContext` as JSON, optional file `screenshot`) into the wire shape.
+ *
+ * Validation of the CONTENT is parseFeedbackInput's job; this only refuses what must
+ * not be buffered at all, and tolerates what is merely decorative:
+ * - the declared Content-Length is checked before anything is read into memory
+ *   (absent or lying headers are still caught by the per-part size check);
+ * - a malformed or oversized client context becomes `{}` — it must never be the
+ *   reason a report is lost.
+ */
+export async function readFeedbackForm(request, options = {}) {
+    const messages = options.messages ?? en;
+    const limits = limitsOf(options);
+    const declared = Number(request.headers.get('content-length') ?? '0');
+    if (Number.isFinite(declared) && declared > limits.maxScreenshotBytes + limits.maxBodyOverheadBytes) {
+        throw new FeedbackInputError(messages.input.bodyTooLarge, 413);
+    }
+    let form;
+    try {
+        form = await request.formData();
+    }
+    catch {
+        throw new FeedbackInputError(messages.input.invalidRequest, 400);
+    }
+    let clientContext = {};
+    const rawContext = form.get('clientContext');
+    if (typeof rawContext === 'string' && rawContext.length > 0 && rawContext.length < limits.maxContextJsonLength) {
+        try {
+            clientContext = JSON.parse(rawContext);
+        }
+        catch {
+            clientContext = {};
+        }
+    }
+    const file = form.get('screenshot');
+    let screenshot = null;
+    if (file && typeof file !== 'string') {
+        if (file.size > limits.maxScreenshotBytes)
+            throw new FeedbackInputError(messages.input.screenshotTooLarge, 413);
+        screenshot = { bytes: new Uint8Array(await file.arrayBuffer()), contentType: file.type };
+    }
+    const kind = form.get('kind');
+    const message = form.get('message');
+    return {
+        kind: typeof kind === 'string' ? kind : '',
+        message: typeof message === 'string' ? message : '',
+        clientContext,
+        screenshot,
+    };
+}

package/dist/esm/kernel/feedback/messages.d.ts

@@ -0,0 +1,76 @@
+export interface FeedbackMessages {
+    /** BCP 47 tag, informational. */
+    locale: string;
+    /** Labels for the default kinds (BUG/IDEA/OTHER). An app with its own kinds passes `kindLabels`. */
+    kinds: Readonly<Record<string, string>>;
+    /** The Markdown report body (target side). */
+    report: {
+        untitled: string;
+        description: string;
+        serverContext: string;
+        clientContext: string;
+        field: string;
+        value: string;
+        reportedBy: string;
+        userId: string;
+        reportedAtServer: string;
+        reportId: string;
+        url: string;
+        pageTitle: string;
+        viewport: string;
+        screen: string;
+        devicePixelRatio: string;
+        userAgent: string;
+        language: string;
+        timezone: string;
+        online: string;
+        connection: string;
+        clientTime: string;
+        yes: string;
+        no: string;
+        openReport: string;
+    };
+    /** The privacy notice next to the screenshot toggle. */
+    notice: {
+        selfHosted: (targetLabel: string) => string;
+        thirdParty: (targetLabel: string) => string;
+    };
+    /** Display names of the built-in non-tracker targets. */
+    targets: {
+        fake: string;
+        unconfigured: string;
+    };
+    /** Errors from the Kolibri target. They end up in an operator-visible "last error". */
+    kolibri: {
+        unreachable: (path: string, detail: string) => string;
+        createRejected: (status: number, body: string) => string;
+        uploadRejected: (status: number, body: string) => string;
+    };
+    /** Configuration problems found while resolving the target from the environment. */
+    config: {
+        targetUnset: string;
+        fakeInProduction: string;
+        missingVariables: (target: string, names: readonly string[]) => string;
+        notUuid: (variable: string, expected: 'workspace' | 'project', value: string) => string;
+        unknownTarget: (value: string, known: readonly string[]) => string;
+    };
+    /** Validation errors for an incoming report (server side, shown to the reporter). */
+    input: {
+        messageRequired: string;
+        messageTooLong: (max: number) => string;
+        unknownKind: string;
+        screenshotTooLarge: string;
+        unsupportedImage: string;
+        bodyTooLarge: string;
+        invalidRequest: string;
+    };
+}
+export declare const de: FeedbackMessages;
+export declare const en: FeedbackMessages;
+export declare const messages: {
+    readonly en: FeedbackMessages;
+    readonly de: FeedbackMessages;
+};
+export type FeedbackLocale = keyof typeof messages;
+/** The kinds an app gets when it does not define its own. */
+export declare const DEFAULT_FEEDBACK_KINDS: readonly ["BUG", "IDEA", "OTHER"];