@e-llm-studio/feedback-flow 0.0.0-stage → 0.1.31

package/dist/feedbackApi.d.ts

@@ -0,0 +1,70 @@
+import type { FeedbackMetadata, FeedbackSeverity, FeedbackSubmission } from "./types";
+export interface FeedbackLookup {
+    query_id: string;
+    is_ai_query?: boolean;
+    session_id?: string;
+    request_id?: string;
+    source_request_id?: string;
+    feature_id: string;
+    user_email?: string;
+}
+export interface FeedbackRecord {
+    feedback_form: {
+        feedback_id: string;
+        query_id: string;
+        feature_id: string;
+        user_email: string;
+        rating: number;
+        trace_id?: string;
+        session_id?: string;
+        request_id?: string;
+        metadata: FeedbackMetadata;
+        created_at: string;
+    };
+    positive_feedback: Array<{
+        feedback_id: string;
+        positive_id: string;
+        description: string;
+        time_saved_mins?: number;
+        metadata: Record<string, unknown>;
+        created_at: string;
+    }>;
+    gaps: Array<{
+        feedback_id: string;
+        negative_id: string;
+        description: string;
+        severity?: FeedbackSeverity;
+        metadata: Record<string, unknown>;
+        created_at: string;
+    }>;
+    feedback_attachment: Array<{
+        attachment_id: string;
+        negative_id?: string;
+        positive_id?: string;
+        gcs_url: string;
+        metadata: {
+            file_name: string;
+            mime_type?: string;
+            size?: number;
+            last_modified?: number;
+            public_url?: string;
+        };
+        created_at: string;
+    }>;
+}
+export interface FeedbackApi {
+    /** The same operation creates a new feedback record or updates an existing one. */
+    upsertFeedback(record: FeedbackRecord): Promise<FeedbackRecord>;
+    getFeedback(lookup: FeedbackLookup): Promise<FeedbackRecord | null>;
+    uploadAttachment?: (file: File) => Promise<string | {
+        gcsUrl: string;
+        publicUrl?: string;
+    }>;
+    getAttachmentPreviewUrl?: (gcsUrl: string, forceRefresh?: boolean) => Promise<string>;
+}
+export declare const mockFeedbackApi: FeedbackApi;
+export declare function feedbackLookup(submission: Pick<FeedbackSubmission, "requestId" | "featureId" | "metadata">): FeedbackLookup;
+/** Maps UI answers to the API's form, positive, gaps and attachment groups. */
+export declare function toFeedbackRecord(submission: FeedbackSubmission, previous?: FeedbackRecord | null): FeedbackRecord;
+/** Restores the saved answers for Review; mock attachment URLs are display references, not uploads. */
+export declare function fromFeedbackRecord(record: FeedbackRecord): FeedbackSubmission;

package/dist/feedbackApi.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockFeedbackApi = void 0;
+exports.feedbackLookup = feedbackLookup;
+exports.toFeedbackRecord = toFeedbackRecord;
+exports.fromFeedbackRecord = fromFeedbackRecord;
+const STORAGE_KEY = "@e-llm-studio/feedback-flow/mock-api/v1";
+let memoryRecords = [];
+const clone = (value) => JSON.parse(JSON.stringify(value));
+const newId = () => globalThis.crypto?.randomUUID?.() ?? `mock-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+function readRecords() {
+    try {
+        const stored = globalThis.localStorage?.getItem(STORAGE_KEY);
+        return stored ? JSON.parse(stored) : memoryRecords;
+    }
+    catch {
+        return memoryRecords;
+    }
+}
+function writeRecords(records) {
+    memoryRecords = records;
+    try {
+        globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(records));
+    }
+    catch {
+        // Private browsing / SSR still use the in-memory mock.
+    }
+}
+function matches(record, lookup) {
+    const form = record.feedback_form;
+    return form.query_id === lookup.query_id && form.feature_id === lookup.feature_id && form.user_email === (lookup.user_email ?? "");
+}
+exports.mockFeedbackApi = {
+    async upsertFeedback(record) {
+        const records = readRecords();
+        const index = records.findIndex((item) => item.feedback_form.feedback_id === record.feedback_form.feedback_id || matches(item, record.feedback_form));
+        const next = clone(record);
+        if (index >= 0)
+            records[index] = next;
+        else
+            records.push(next);
+        writeRecords(records);
+        return clone(next);
+    },
+    async getFeedback(lookup) {
+        const match = readRecords().find((record) => matches(record, lookup));
+        return match ? clone(match) : null;
+    },
+};
+function feedbackLookup(submission) {
+    return {
+        query_id: submission.metadata?.queryId ?? submission.requestId,
+        is_ai_query: Boolean(submission.metadata?.sessionId),
+        session_id: submission.metadata?.sessionId,
+        request_id: submission.metadata?.requestId,
+        source_request_id: submission.requestId,
+        feature_id: submission.featureId,
+        user_email: String(submission.metadata?.userEmail ?? submission.metadata?.owner ?? ""),
+    };
+}
+/** Maps UI answers to the API's form, positive, gaps and attachment groups. */
+function toFeedbackRecord(submission, previous) {
+    const now = new Date().toISOString();
+    const feedbackId = previous?.feedback_form.feedback_id ?? newId();
+    const metadata = submission.metadata ?? {};
+    const existingPositive = previous?.positive_feedback[0];
+    const hasPositive = Boolean(submission.mostUseful);
+    const positiveId = existingPositive?.positive_id ?? newId();
+    const positive_feedback = hasPositive
+        ? [
+            {
+                feedback_id: feedbackId,
+                positive_id: positiveId,
+                description: submission.mostUseful ?? "",
+                time_saved_mins: submission.timeSavedMinutes,
+                metadata: {
+                    useful_detail_shown: submission.usefulDetailShown ?? false,
+                },
+                created_at: existingPositive?.created_at ?? now,
+            },
+        ]
+        : [];
+    const gaps = submission.gaps.map((gap, index) => ({
+        feedback_id: feedbackId,
+        negative_id: gap.negativeId ?? (submission.gaps.some((other, otherIndex) => otherIndex !== index &&
+            other.negativeId === previous?.gaps[index]?.negative_id)
+            ? undefined : previous?.gaps[index]?.negative_id) ?? newId(),
+        description: gap.description,
+        severity: gap.severity,
+        metadata: { detail_requested: gap.detailRequested ?? false },
+        created_at: previous?.gaps[index]?.created_at ?? now,
+    }));
+    const feedback_attachment = submission.gaps.flatMap((gap, index) => gap.screenshots.map((screenshot) => {
+        const saved = "attachmentId" in screenshot ? screenshot : null;
+        return {
+            attachment_id: saved?.attachmentId ?? newId(),
+            negative_id: gaps[index].negative_id,
+            gcs_url: saved?.gcsUrl ?? `mock://feedback-attachments/${feedbackId}/${encodeURIComponent(screenshot.name)}`,
+            metadata: {
+                file_name: screenshot.name,
+                mime_type: screenshot.type,
+                size: screenshot.size,
+                last_modified: screenshot.lastModified,
+                ...(saved?.publicUrl ? { public_url: saved.publicUrl } : {}),
+            },
+            created_at: previous?.feedback_attachment.find((item) => item.attachment_id === saved?.attachmentId)?.created_at ?? now,
+        };
+    }));
+    return {
+        feedback_form: {
+            feedback_id: feedbackId,
+            ...feedbackLookup(submission),
+            user_email: feedbackLookup(submission).user_email ?? "",
+            rating: submission.rating,
+            trace_id: metadata.traceId,
+            session_id: metadata.sessionId,
+            request_id: metadata.requestId,
+            metadata: {
+                ...metadata,
+                ...(submission.timeSavedMinutes !== undefined && !hasPositive
+                    ? { draft_time_saved_mins: submission.timeSavedMinutes } : {}),
+                source_request_id: submission.requestId,
+            },
+            created_at: previous?.feedback_form.created_at ?? now,
+        },
+        positive_feedback,
+        gaps,
+        feedback_attachment,
+    };
+}
+/** Restores the saved answers for Review; mock attachment URLs are display references, not uploads. */
+function fromFeedbackRecord(record) {
+    const positive = record.positive_feedback[0];
+    return {
+        requestId: typeof record.feedback_form.metadata.source_request_id === "string"
+            ? record.feedback_form.metadata.source_request_id : record.feedback_form.query_id,
+        featureId: record.feedback_form.feature_id,
+        rating: record.feedback_form.rating,
+        timeSavedMinutes: positive?.time_saved_mins ??
+            (typeof record.feedback_form.metadata.draft_time_saved_mins === "number"
+                ? record.feedback_form.metadata.draft_time_saved_mins : undefined),
+        mostUseful: positive?.description,
+        usefulMoreDetail: typeof positive?.metadata.useful_more_detail === "string" ? positive.metadata.useful_more_detail : undefined,
+        usefulDetailShown: positive?.metadata.useful_detail_shown === true,
+        gaps: record.gaps.map((gap) => ({
+            negativeId: gap.negative_id,
+            description: gap.description,
+            severity: gap.severity,
+            detailRequested: gap.metadata.detail_requested === true,
+            screenshots: record.feedback_attachment
+                .filter((item) => item.negative_id === gap.negative_id)
+                .map((item) => ({
+                attachmentId: item.attachment_id,
+                gcsUrl: item.gcs_url,
+                publicUrl: item.metadata.public_url,
+                name: item.metadata.file_name,
+                type: item.metadata.mime_type,
+                size: item.metadata.size,
+                lastModified: item.metadata.last_modified,
+            })),
+        })),
+        metadata: record.feedback_form.metadata,
+    };
+}

package/dist/feedbackTheme.d.ts

@@ -0,0 +1,4 @@
+import type { CSSProperties } from 'react';
+import { defaultFeedbackTheme, createFeedbackTheme, type FeedbackTheme } from './types';
+export { defaultFeedbackTheme, createFeedbackTheme };
+export declare function feedbackThemeStyle(theme?: FeedbackTheme): CSSProperties;

package/dist/feedbackTheme.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeedbackTheme = exports.defaultFeedbackTheme = void 0;
+exports.feedbackThemeStyle = feedbackThemeStyle;
+const types_1 = require("./types");
+Object.defineProperty(exports, "defaultFeedbackTheme", { enumerable: true, get: function () { return types_1.defaultFeedbackTheme; } });
+Object.defineProperty(exports, "createFeedbackTheme", { enumerable: true, get: function () { return types_1.createFeedbackTheme; } });
+function feedbackThemeStyle(theme) {
+    const merged = (0, types_1.createFeedbackTheme)(theme);
+    return {
+        '--cw-feedback-accent': merged.accent ?? types_1.defaultFeedbackTheme.accent,
+        '--cw-feedback-text': merged.text ?? types_1.defaultFeedbackTheme.text,
+        '--cw-feedback-muted': merged.muted ?? types_1.defaultFeedbackTheme.muted,
+        '--cw-feedback-border': merged.border ?? types_1.defaultFeedbackTheme.border,
+        '--cw-feedback-surface': merged.surface ?? types_1.defaultFeedbackTheme.surface,
+        '--cw-feedback-gap-surface': merged.gapSurface ?? types_1.defaultFeedbackTheme.gapSurface,
+        '--cw-feedback-success': merged.success ?? types_1.defaultFeedbackTheme.success,
+        '--cw-feedback-star-empty': merged.starEmpty ?? types_1.defaultFeedbackTheme.starEmpty,
+        '--cw-feedback-tooltip-bg': merged.tooltipBackground ?? types_1.defaultFeedbackTheme.tooltipBackground,
+        '--cw-feedback-tooltip-text': merged.tooltipText ?? types_1.defaultFeedbackTheme.tooltipText,
+    };
+}

package/dist/feedbackUpload.d.ts

@@ -0,0 +1,50 @@
+export interface FeedbackUploadOptions {
+    /** CW API origin, for example https://cw.example.com. */
+    baseUrl: string;
+    /** Only needed by the legacy signed-URL helpers. */
+    projectId?: string | (() => string | null | undefined);
+    getAuthToken?: () => string | null | undefined;
+    fetcher?: typeof fetch;
+    artifactUserEmail?: string | null;
+    artifactUserName?: string | null;
+}
+export interface SignedUploadFile {
+    filename: string;
+    status: string;
+    signed_url: string;
+    content_type: string;
+    public_url: string;
+}
+export interface DirectFeedbackUploadResponse {
+    message: string;
+    filename: string;
+    content_type: string;
+    size_formatted: string;
+    gs_url: string;
+    public_url: string;
+}
+/** Upload one screenshot to CW's direct multipart endpoint. The caller sends gs_url in feedback. */
+export declare function uploadFeedbackScreenshotDirect(file: File, options: FeedbackUploadOptions): Promise<DirectFeedbackUploadResponse>;
+/** Public URL fallback for integrations without a signed-read endpoint. */
+export declare function feedbackScreenshotPublicUrl(gcsUrl: string): string | null;
+/** Resolve a private GCS screenshot through CW's signed-read endpoint. */
+export declare function getFeedbackScreenshotSignedUrl(gcsUrl: string, options: FeedbackUploadOptions, forceRefresh?: boolean): Promise<string>;
+export declare function createFeedbackScreenshotUrlResolver(options: FeedbackUploadOptions): (gcsUrl: string, forceRefresh?: boolean) => Promise<string>;
+/** Request CW's upload URLs; accepts its direct or responseData-wrapped JSON shape. */
+export declare function generateSignedUrlForUpload(projectId: string, fileNames: string[], options: FeedbackUploadOptions): Promise<SignedUploadFile[]>;
+export interface ManualFeedbackUploadOptions extends FeedbackUploadOptions {
+    files: FileList | File[];
+    isAI?: boolean;
+    ignoreConfirmCall?: boolean;
+    autoIngest?: boolean;
+}
+/** Upload bytes to each signed URL, then confirm the files with CW. */
+export declare function manualUploadFilesToGCS(options: ManualFeedbackUploadOptions): Promise<Array<{
+    filename: string;
+    url: string;
+}>>;
+/** Single-file adapter consumed by the feedback form. */
+export declare function createFeedbackScreenshotUploader(options: FeedbackUploadOptions): (file: File) => Promise<{
+    gcsUrl: string;
+    publicUrl?: string;
+}>;

package/dist/feedbackUpload.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFeedbackScreenshotDirect = uploadFeedbackScreenshotDirect;
+exports.feedbackScreenshotPublicUrl = feedbackScreenshotPublicUrl;
+exports.getFeedbackScreenshotSignedUrl = getFeedbackScreenshotSignedUrl;
+exports.createFeedbackScreenshotUrlResolver = createFeedbackScreenshotUrlResolver;
+exports.generateSignedUrlForUpload = generateSignedUrlForUpload;
+exports.manualUploadFilesToGCS = manualUploadFilesToGCS;
+exports.createFeedbackScreenshotUploader = createFeedbackScreenshotUploader;
+function unwrapResponse(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("Invalid CW upload response");
+    const data = value;
+    if (data.error)
+        throw new Error("CW upload API returned an error");
+    return data.responseData && typeof data.responseData === "object" ? data.responseData : data;
+}
+function authHeaders(options) {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+}
+/** Upload one screenshot to CW's direct multipart endpoint. The caller sends gs_url in feedback. */
+async function uploadFeedbackScreenshotDirect(file, options) {
+    const baseUrl = options.baseUrl.replace(/\/+$/, "");
+    if (!baseUrl)
+        throw new Error("A CW API base URL is required to upload a feedback screenshot");
+    const endpoint = `${baseUrl.endsWith("/backend") ? baseUrl : `${baseUrl}/backend`}/gcs/direct-gcs-upload`;
+    const form = new FormData();
+    form.append("file", file, file.name);
+    const response = await (options.fetcher ?? fetch)(endpoint, {
+        method: "POST",
+        headers: { accept: "*/*", ...authHeaders(options) },
+        body: form,
+    });
+    if (!response.ok)
+        throw new Error(`Feedback screenshot upload failed (${response.status})`);
+    const data = unwrapResponse(await response.json());
+    if (typeof data.gs_url !== "string" || !data.gs_url.startsWith("gs://")) {
+        throw new Error("CW did not return a valid gs_url for the feedback screenshot");
+    }
+    return data;
+}
+/** Public URL fallback for integrations without a signed-read endpoint. */
+function feedbackScreenshotPublicUrl(gcsUrl) {
+    if (/^https:\/\//i.test(gcsUrl))
+        return gcsUrl;
+    if (!gcsUrl.startsWith("gs://"))
+        return null;
+    const path = gcsUrl.slice(5).split("/").map(encodeURIComponent).join("/");
+    return `https://storage.googleapis.com/${path}`;
+}
+const SIGNED_URL_EXPIRY_BUFFER_MS = 60000;
+const SIGNED_URL_FALLBACK_TTL_MS = 5 * 60000;
+const signedReadCache = new Map();
+const signedReadInFlight = new Map();
+function signedReadExpiry(url) {
+    try {
+        const params = new URL(url).searchParams;
+        const date = params.get("X-Goog-Date");
+        const seconds = Number(params.get("X-Goog-Expires"));
+        if (date && /^\d{8}T\d{6}Z$/.test(date) && Number.isFinite(seconds) && seconds > 0) {
+            const start = Date.UTC(Number(date.slice(0, 4)), Number(date.slice(4, 6)) - 1, Number(date.slice(6, 8)), Number(date.slice(9, 11)), Number(date.slice(11, 13)), Number(date.slice(13, 15)));
+            return start + seconds * 1000 - SIGNED_URL_EXPIRY_BUFFER_MS;
+        }
+    }
+    catch {
+        // Unknown signed URL formats get a short in-memory cache only.
+    }
+    return Date.now() + SIGNED_URL_FALLBACK_TTL_MS;
+}
+/** Resolve a private GCS screenshot through CW's signed-read endpoint. */
+async function getFeedbackScreenshotSignedUrl(gcsUrl, options, forceRefresh = false) {
+    const baseUrl = options.baseUrl.replace(/\/+$/, "");
+    if (!baseUrl)
+        throw new Error("A CW API base URL is required to preview a feedback screenshot");
+    const token = options.getAuthToken?.() ?? "";
+    const key = JSON.stringify([baseUrl, token, gcsUrl]);
+    const cached = signedReadCache.get(key);
+    if (!forceRefresh && cached && cached.expiresAt > Date.now())
+        return cached.url;
+    if (cached)
+        signedReadCache.delete(key);
+    const pending = signedReadInFlight.get(key);
+    if (pending)
+        return pending;
+    const request = (async () => {
+        const endpoint = `${baseUrl.endsWith("/backend") ? baseUrl : `${baseUrl}/backend`}/gcs/get-signed-url/`;
+        const response = await (options.fetcher ?? fetch)(endpoint, {
+            method: "POST",
+            headers: { accept: "application/json", "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+            body: JSON.stringify({ gsutil_url: gcsUrl.startsWith("gs://") ? gcsUrl : `gs://${gcsUrl}` }),
+        });
+        if (!response.ok)
+            throw new Error(`Could not get screenshot preview URL (${response.status})`);
+        const data = unwrapResponse(await response.json());
+        if (typeof data.signed_url !== "string" || !data.signed_url) {
+            throw new Error("CW did not return a signed screenshot URL");
+        }
+        const expiresAt = signedReadExpiry(data.signed_url);
+        if (expiresAt > Date.now()) {
+            for (const [entryKey, entry] of signedReadCache) {
+                if (entry.expiresAt <= Date.now())
+                    signedReadCache.delete(entryKey);
+            }
+            if (signedReadCache.size >= 200)
+                signedReadCache.delete(signedReadCache.keys().next().value);
+            signedReadCache.set(key, { url: data.signed_url, expiresAt });
+        }
+        return data.signed_url;
+    })();
+    signedReadInFlight.set(key, request);
+    try {
+        return await request;
+    }
+    finally {
+        if (signedReadInFlight.get(key) === request)
+            signedReadInFlight.delete(key);
+    }
+}
+function createFeedbackScreenshotUrlResolver(options) {
+    return (gcsUrl, forceRefresh) => getFeedbackScreenshotSignedUrl(gcsUrl, options, forceRefresh);
+}
+/** Request CW's upload URLs; accepts its direct or responseData-wrapped JSON shape. */
+async function generateSignedUrlForUpload(projectId, fileNames, options) {
+    const fetcher = options.fetcher ?? fetch;
+    const response = await fetcher(`${options.baseUrl.replace(/\/$/, "")}/gcs/generate-upload-signed-urls`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders(options) },
+        body: JSON.stringify({ project_id: projectId, filenames: fileNames }),
+    });
+    if (!response.ok)
+        throw new Error(`Could not get screenshot signed URL (${response.status})`);
+    const data = unwrapResponse(await response.json());
+    if (!Array.isArray(data.files))
+        throw new Error("CW did not return screenshot upload URLs");
+    return data.files;
+}
+/** Upload bytes to each signed URL, then confirm the files with CW. */
+async function manualUploadFilesToGCS(options) {
+    const projectId = typeof options.projectId === "function" ? options.projectId() : options.projectId;
+    if (!projectId)
+        throw new Error("A project ID is required to upload a feedback screenshot");
+    const files = Array.from(options.files);
+    const namedFiles = files.map((file) => ({
+        file,
+        filename: `feedback-${globalThis.crypto?.randomUUID?.() ?? Date.now()}-${file.name}`,
+    }));
+    const signedFiles = await generateSignedUrlForUpload(projectId, namedFiles.map((item) => item.filename), options);
+    const fetcher = options.fetcher ?? fetch;
+    const uploaded = await Promise.all(signedFiles.map(async (signed) => {
+        if (signed.status === "exists")
+            throw new Error(`Feedback screenshot already exists: ${signed.filename}`);
+        const file = namedFiles.find((item) => item.filename === signed.filename)?.file;
+        if (!file || !signed.signed_url || !signed.public_url)
+            throw new Error("CW did not return an available signed screenshot URL");
+        const upload = await fetcher(signed.signed_url, {
+            method: "PUT",
+            headers: { "Content-Type": signed.content_type || file.type || "application/octet-stream" },
+            body: file,
+        });
+        if (!upload.ok)
+            throw new Error(`Feedback screenshot upload failed (${upload.status})`);
+        return { filename: signed.filename, url: signed.public_url };
+    }));
+    if (options.ignoreConfirmCall)
+        return uploaded;
+    const suffix = options.autoIngest ? "?auto_ingest=true" : "";
+    const confirm = await fetcher(`${options.baseUrl.replace(/\/$/, "")}/gcs/confirm-upload${suffix}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders(options) },
+        body: JSON.stringify({
+            project_id: projectId,
+            files: uploaded,
+            isAI: options.isAI ?? false,
+            artifactUserName: options.artifactUserName ?? null,
+            artifactUserEmail: options.artifactUserEmail ?? null,
+        }),
+    });
+    if (!confirm.ok)
+        throw new Error(`Feedback screenshot confirmation failed (${confirm.status})`);
+    unwrapResponse(await confirm.json());
+    return uploaded;
+}
+/** Single-file adapter consumed by the feedback form. */
+function createFeedbackScreenshotUploader(options) {
+    return async (file) => {
+        const uploaded = await uploadFeedbackScreenshotDirect(file, options);
+        return { gcsUrl: uploaded.gs_url, publicUrl: uploaded.public_url };
+    };
+}

package/dist/httpFeedbackApi.d.ts

@@ -0,0 +1,15 @@
+import type { FeedbackApi } from "./feedbackApi";
+export interface HttpFeedbackApiOptions {
+    baseUrl: string;
+    /** Optional origin for GET when reads and writes are served by different deployments. */
+    readBaseUrl?: string;
+    getAuthToken?: () => string | null | undefined;
+    uploadAttachment?: (file: File) => Promise<string | {
+        gcsUrl: string;
+        publicUrl?: string;
+    }>;
+    getAttachmentPreviewUrl?: (gcsUrl: string, forceRefresh?: boolean) => Promise<string>;
+    fetcher?: typeof fetch;
+}
+/** GET restores saved feedback; POST creates and PUT updates it. */
+export declare function createHttpFeedbackApi(options: HttpFeedbackApiOptions): FeedbackApi;