@kognitivedev/cloud-web-search 0.2.28

package/dist/rich-events.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCloudWebSearchRichEvents = toCloudWebSearchRichEvents;
+const validation_1 = require("./validation");
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asIndex(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function toSource(value) {
+    if (!(0, validation_1.isPlainObject)(value))
+        return null;
+    const url = asString(value.url);
+    const title = asString(value.title);
+    const keyFacts = Array.isArray(value.keyFacts)
+        ? value.keyFacts.filter((fact) => typeof fact === "string")
+        : undefined;
+    return Object.assign({ title,
+        url, snippet: asString(value.snippet), score: asNumber(value.score), confidence: asNumber(value.confidence), faviconUrl: asString(value.faviconUrl), host: asString(value.host), relevantContent: asString(value.relevantContent) }, (keyFacts ? { keyFacts } : {}));
+}
+function sourceFromPayload(payload) {
+    if ((0, validation_1.isPlainObject)(payload.source)) {
+        return toSource(payload.source);
+    }
+    return toSource(payload);
+}
+function sourcesFromPayload(payload) {
+    const values = Array.isArray(payload.results)
+        ? payload.results
+        : Array.isArray(payload.sources)
+            ? payload.sources
+            : [];
+    return values.map((source) => toSource(source)).filter((source) => Boolean(source));
+}
+function payloadOf(record) {
+    return (0, validation_1.isPlainObject)(record.payload) ? record.payload : {};
+}
+function answerFromResult(value) {
+    if (!(0, validation_1.isPlainObject)(value))
+        return null;
+    if ((0, validation_1.isPlainObject)(value.output)) {
+        return (0, validation_1.cloneUnknown)(value.output);
+    }
+    return null;
+}
+function fromRecord(record) {
+    var _a;
+    const payload = payloadOf(record);
+    const base = {
+        jobId: record.jobId,
+        eventId: record.id,
+        raw: (0, validation_1.cloneUnknown)(record),
+    };
+    switch (record.eventType) {
+        case "websearch.research.plan.started":
+            return [Object.assign(Object.assign({ type: "plan.started" }, base), { message: record.message })];
+        case "websearch.research.plan.completed":
+            return [Object.assign(Object.assign({ type: "plan.completed" }, base), { plan: (0, validation_1.isPlainObject)(record.payload) ? (0, validation_1.cloneUnknown)(record.payload) : null })];
+        case "websearch.research.todo.generated":
+            return [Object.assign(Object.assign({ type: "todo.generated" }, base), { todo: (0, validation_1.isPlainObject)(record.payload) ? (0, validation_1.cloneUnknown)(record.payload) : null })];
+        case "websearch.search.started":
+            return [Object.assign(Object.assign({ type: "search.started" }, base), { query: asString(payload.query), input: payload.input })];
+        case "websearch.search.completed":
+            return [Object.assign(Object.assign({ type: "search.completed" }, base), { query: asString(payload.query), provider: asString(payload.provider), results: sourcesFromPayload(payload) })];
+        case "websearch.fetch.started":
+        case "websearch.source.opening":
+            return [Object.assign(Object.assign({ type: "source.opening" }, base), { source: sourceFromPayload(payload), index: asIndex(payload.index) })];
+        case "websearch.extract.completed":
+        case "websearch.source.extracted":
+            return [Object.assign(Object.assign({ type: "source.extracted" }, base), { source: sourceFromPayload(payload), snippet: asString(payload.snippet), confidence: asNumber(payload.confidence), index: asIndex(payload.index) })];
+        case "websearch.fetch.failed":
+        case "websearch.source.failed":
+            return [Object.assign(Object.assign({ type: "source.failed" }, base), { source: sourceFromPayload(payload), errorMessage: (_a = asString(payload.error)) !== null && _a !== void 0 ? _a : asString(payload.errorMessage), index: asIndex(payload.index) })];
+        case "websearch.research.reasoning":
+            return asString(payload.delta)
+                ? [Object.assign(Object.assign({ type: "reasoning.delta" }, base), { delta: asString(payload.delta) })]
+                : [];
+        case "websearch.research.answer.delta":
+            return asString(payload.delta)
+                ? [Object.assign(Object.assign({ type: "answer.delta" }, base), { delta: asString(payload.delta) })]
+                : [];
+        case "websearch.tool.sources.reviewing":
+        case "websearch.tool.synthesis.started":
+            return [Object.assign(Object.assign({ type: "sources.reviewing" }, base), { totalExtractions: asNumber(payload.totalExtractions), message: record.message })];
+        case "websearch.tool.sources.filtered":
+            return [Object.assign(Object.assign({ type: "sources.filtered" }, base), { totalSources: asNumber(payload.totalSources), credibleSources: asNumber(payload.credibleSources), filteredOut: asNumber(payload.filteredOut), message: record.message })];
+        case "websearch.tool.retrieval.completed":
+        case "websearch.tool.synthesis.completed":
+            return [Object.assign(Object.assign({ type: "sources.reviewed" }, base), { sources: sourcesFromPayload(payload), credibleSourceCount: asNumber(payload.credibleSourceCount) })];
+        case "websearch.research.synthesis.started":
+        case "websearch.synthesis.started":
+            return [Object.assign(Object.assign({ type: "synthesis.started" }, base), { totalExtractions: asNumber(payload.totalExtractions) })];
+        case "websearch.research.synthesis.completed":
+            return [Object.assign({ type: "synthesis.completed" }, base)];
+        case "websearch.research.answer.completed":
+            return [Object.assign({ type: "answer.completed" }, base)];
+        default:
+            return [];
+    }
+}
+function toCloudWebSearchRichEvents(event) {
+    if (event.type === "progress" && event.raw) {
+        return fromRecord(event.raw);
+    }
+    if (event.type === "event") {
+        return fromRecord(event.event);
+    }
+    if (event.type === "completed") {
+        return [Object.assign(Object.assign({ type: "answer.completed", jobId: event.jobId, result: event.result, answer: answerFromResult(event.result) }, (event.eventId ? { eventId: event.eventId } : {})), (event.raw ? { raw: event.raw } : {})), Object.assign(Object.assign({ type: "completed", jobId: event.jobId, job: event.job, result: event.result }, (event.eventId ? { eventId: event.eventId } : {})), (event.raw ? { raw: event.raw } : {}))];
+    }
+    if (event.type === "error") {
+        return [Object.assign(Object.assign({ type: "error", jobId: event.jobId, job: event.job, errorMessage: event.errorMessage }, (event.eventId ? { eventId: event.eventId } : {})), (event.raw ? { raw: event.raw } : {}))];
+    }
+    if (event.type === "cancelled") {
+        return [Object.assign(Object.assign({ type: "cancelled", jobId: event.jobId, job: event.job }, (event.eventId ? { eventId: event.eventId } : {})), (event.raw ? { raw: event.raw } : {}))];
+    }
+    return [];
+}

package/dist/sse.d.ts

@@ -0,0 +1,8 @@
+export type ParsedSSEEvent<T = unknown> = {
+    event: string;
+    data: T;
+    dataText: string;
+    id?: string;
+    retry?: number;
+};
+export declare function readSSEStream<T = unknown>(stream: ReadableStream<Uint8Array>): AsyncGenerator<ParsedSSEEvent<T>>;

package/dist/sse.js

@@ -0,0 +1,151 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSSEStream = readSSEStream;
+function parseEventData(dataText) {
+    try {
+        return JSON.parse(dataText);
+    }
+    catch (_a) {
+        return dataText;
+    }
+}
+function finalizeEvent(eventName, dataLines, lastEventId, retry) {
+    if (dataLines.length === 0) {
+        return null;
+    }
+    const dataText = dataLines.join("\n");
+    return Object.assign(Object.assign({ event: eventName || "message", data: parseEventData(dataText), dataText }, (lastEventId === undefined ? {} : { id: lastEventId })), (retry === undefined ? {} : { retry }));
+}
+function findNextLineBreak(buffer) {
+    for (let index = 0; index < buffer.length; index += 1) {
+        const code = buffer.charCodeAt(index);
+        if (code === 0x0a) {
+            return { index, length: 1 };
+        }
+        if (code === 0x0d) {
+            return {
+                index,
+                length: buffer.charCodeAt(index + 1) === 0x0a ? 2 : 1,
+            };
+        }
+    }
+    return null;
+}
+function parseField(line) {
+    const separator = line.indexOf(":");
+    if (separator < 0) {
+        return { field: line, value: "" };
+    }
+    let value = line.slice(separator + 1);
+    if (value.startsWith(" ")) {
+        value = value.slice(1);
+    }
+    return {
+        field: line.slice(0, separator),
+        value,
+    };
+}
+function readSSEStream(stream) {
+    return __asyncGenerator(this, arguments, function* readSSEStream_1() {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let eventName = "message";
+        let dataLines = [];
+        let lastEventId;
+        let pendingEventId;
+        let pendingRetry;
+        const processLine = (line) => {
+            if (line === "") {
+                if (pendingEventId !== undefined) {
+                    lastEventId = pendingEventId;
+                }
+                const event = finalizeEvent(eventName, dataLines, lastEventId, pendingRetry);
+                eventName = "message";
+                dataLines = [];
+                pendingEventId = undefined;
+                pendingRetry = undefined;
+                return event;
+            }
+            if (line.startsWith(":")) {
+                return null;
+            }
+            const { field, value } = parseField(line);
+            switch (field) {
+                case "event":
+                    eventName = value || "message";
+                    break;
+                case "data":
+                    dataLines.push(value);
+                    break;
+                case "id":
+                    if (!value.includes("\0")) {
+                        pendingEventId = value;
+                    }
+                    break;
+                case "retry":
+                    if (/^\d+$/.test(value)) {
+                        pendingRetry = Number.parseInt(value, 10);
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return null;
+        };
+        try {
+            let isDone = false;
+            while (!isDone) {
+                const { done, value } = yield __await(reader.read());
+                isDone = done;
+                buffer += decoder.decode(value !== null && value !== void 0 ? value : new Uint8Array(), { stream: !done });
+                let nextLine = findNextLineBreak(buffer);
+                while (nextLine) {
+                    const line = buffer.slice(0, nextLine.index);
+                    buffer = buffer.slice(nextLine.index + nextLine.length);
+                    const event = processLine(line);
+                    if (event) {
+                        yield yield __await(event);
+                    }
+                    nextLine = findNextLineBreak(buffer);
+                }
+            }
+            buffer += decoder.decode();
+            if (buffer.length > 0) {
+                const event = processLine(buffer);
+                if (event) {
+                    yield yield __await(event);
+                }
+            }
+            if (pendingEventId !== undefined) {
+                lastEventId = pendingEventId;
+            }
+            const trailingEvent = finalizeEvent(eventName, dataLines, lastEventId, pendingRetry);
+            if (trailingEvent) {
+                yield yield __await(trailingEvent);
+            }
+        }
+        finally {
+            try {
+                yield __await(reader.cancel());
+            }
+            catch (_a) {
+                // Best effort cleanup for partially consumed streams.
+            }
+            reader.releaseLock();
+        }
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,310 @@
+import type { HttpTransportConfig, LogLevel } from "@kognitivedev/client-core";
+import type { ParsedSSEEvent } from "./sse";
+export type { LogLevel };
+export interface CloudWebSearchClientConfig extends HttpTransportConfig {
+}
+export type CloudWebSearchJobStatus = "queued" | "in_progress" | "completed" | "error" | "cancelled";
+export type CloudWebSearchMode = "search" | "research";
+export type CloudWebSearchTimeRange = "day" | "week" | "month" | "year";
+export type CloudWebSearchOutputParser<TOutput> = (value: unknown) => TOutput;
+export interface CloudWebSearchDecodeOptions<TOutput = unknown> {
+    parseOutput?: CloudWebSearchOutputParser<TOutput>;
+}
+export interface CloudWebSearchSubscribeOptions<TOutput = unknown> extends CloudWebSearchDecodeOptions<TOutput> {
+    init?: RequestInit;
+}
+export interface CloudWebSearchExecutionParameters {
+    maxResults?: number;
+    maxPages?: number;
+    region?: string;
+    timeRange?: CloudWebSearchTimeRange;
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    outputSchema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface CloudWebSearchSearchJobInput {
+    mode: "search";
+    query: string;
+    parameters?: CloudWebSearchExecutionParameters;
+}
+export interface CloudWebSearchResearchJobInput {
+    mode: "research";
+    instructions: string;
+    responseInstructions?: string;
+    responseSchema?: Record<string, unknown>;
+    parameters?: CloudWebSearchExecutionParameters;
+}
+export type CreateCloudWebSearchJobInput = CloudWebSearchSearchJobInput | CloudWebSearchResearchJobInput;
+export interface ResearchPlanTodo {
+    id: string;
+    title: string;
+    objective: string;
+    searchQuery?: string;
+    rationale?: string;
+}
+export interface ResearchPlan {
+    summary: string;
+    todos: ResearchPlanTodo[];
+}
+export interface CloudWebSearchProgressEntry {
+    stage: string;
+    message: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CloudWebSearchSource {
+    title?: string | null;
+    url?: string | null;
+    host?: string | null;
+    snippet?: string | null;
+    relevantContent?: string | null;
+    keyFacts?: string[];
+    confidence?: number | null;
+    score?: number | null;
+    faviconUrl?: string | null;
+}
+export interface CloudWebSearchResult<TOutput = unknown> {
+    output?: TOutput;
+    text?: string | null;
+    sources: CloudWebSearchSource[];
+    metadata?: Record<string, unknown>;
+}
+export interface CloudWebSearchJobRecord<TOutput = unknown> {
+    id: string;
+    projectId: string;
+    mode: CloudWebSearchMode;
+    searchQuery?: string | null;
+    searchInstructions?: string | null;
+    responseInstructions?: string | null;
+    responseSchema?: Record<string, unknown> | null;
+    researchPlan?: ResearchPlan | null;
+    parameters: Record<string, unknown>;
+    status: CloudWebSearchJobStatus;
+    results?: CloudWebSearchResult<TOutput> | null;
+    progress: CloudWebSearchProgressEntry[];
+    errorMessage?: string | null;
+    cancelRequestedAt?: string | Date | null;
+    cancelledAt?: string | Date | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface CloudWebSearchJobEventRecord {
+    id: string;
+    jobId: string;
+    projectId: string;
+    eventType: string;
+    stage: string | null;
+    status: string | null;
+    message: string | null;
+    payload: unknown;
+    createdAt: string | Date;
+}
+export interface CloudWebSearchJobResultEnvelope<TOutput = unknown> {
+    jobId: string;
+    status: "completed";
+    result: CloudWebSearchResult<TOutput> | null;
+}
+export interface WaitForCompletionOptions<TOutput = unknown> extends CloudWebSearchDecodeOptions<TOutput> {
+    intervalMs?: number;
+    timeoutMs?: number;
+}
+export interface CloudWebSearchJobWaitResult<TOutput = unknown> {
+    job: CloudWebSearchJobRecord<TOutput>;
+    result: CloudWebSearchResult<TOutput> | null;
+}
+export interface CloudWebSearchRichSource extends CloudWebSearchSource {
+    host?: string | null;
+    relevantContent?: string | null;
+    keyFacts?: string[];
+    confidence?: number | null;
+}
+export interface CloudWebSearchProductAnswer {
+    kind?: string;
+    markdown?: string;
+    headline?: string;
+    lede?: string;
+    table?: unknown;
+    takeaways?: string[];
+    cites?: Array<Record<string, unknown>>;
+    sources?: CloudWebSearchRichSource[];
+    [key: string]: unknown;
+}
+export type CloudWebSearchRichEvent<TOutput = unknown> = {
+    type: "plan.started";
+    jobId: string;
+    message?: string | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "plan.completed";
+    jobId: string;
+    plan: ResearchPlan | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "todo.generated";
+    jobId: string;
+    todo: ResearchPlanTodo | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "search.started";
+    jobId: string;
+    query: string | null;
+    input?: unknown;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "search.completed";
+    jobId: string;
+    query: string | null;
+    provider?: string | null;
+    results: CloudWebSearchRichSource[];
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "source.opening";
+    jobId: string;
+    source: CloudWebSearchRichSource | null;
+    index?: number | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "source.extracted";
+    jobId: string;
+    source: CloudWebSearchRichSource | null;
+    snippet?: string | null;
+    confidence?: number | null;
+    index?: number | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "source.failed";
+    jobId: string;
+    source: CloudWebSearchRichSource | null;
+    errorMessage: string | null;
+    index?: number | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "reasoning.delta";
+    jobId: string;
+    delta: string;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "answer.delta";
+    jobId: string;
+    delta: string;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "sources.reviewing";
+    jobId: string;
+    totalExtractions?: number | null;
+    message?: string | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "sources.filtered";
+    jobId: string;
+    totalSources?: number | null;
+    credibleSources?: number | null;
+    filteredOut?: number | null;
+    message?: string | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "sources.reviewed";
+    jobId: string;
+    sources: CloudWebSearchRichSource[];
+    credibleSourceCount?: number | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "synthesis.started";
+    jobId: string;
+    totalExtractions?: number | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "synthesis.completed";
+    jobId: string;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "answer.completed";
+    jobId: string;
+    result?: CloudWebSearchResult<TOutput> | null;
+    answer?: CloudWebSearchProductAnswer | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "completed";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    result: CloudWebSearchResult<TOutput> | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "error";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    errorMessage: string;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "cancelled";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+};
+export type CloudWebSearchStreamEvent<TOutput = unknown> = {
+    type: "snapshot";
+    job: CloudWebSearchJobRecord<TOutput>;
+} | {
+    type: "progress";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    status: CloudWebSearchJobStatus;
+    progress: CloudWebSearchProgressEntry;
+    eventId?: string;
+    replay?: boolean;
+    rawEventType?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "completed";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    result: CloudWebSearchResult<TOutput> | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "error";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    errorMessage: string;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "cancelled";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    eventId?: string;
+    raw?: CloudWebSearchJobEventRecord;
+} | {
+    type: "keepalive";
+    jobId: string;
+    timestamp: string;
+} | {
+    type: "event";
+    jobId: string;
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    event: CloudWebSearchJobEventRecord;
+} | {
+    type: "unknown";
+    job: CloudWebSearchJobRecord<TOutput> | null;
+    frame: ParsedSSEEvent<unknown>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation.d.ts

@@ -0,0 +1,39 @@
+import type { CloudWebSearchDecodeOptions, CloudWebSearchJobEventRecord, CloudWebSearchJobRecord, CloudWebSearchJobResultEnvelope, CloudWebSearchJobStatus, CloudWebSearchProgressEntry, CloudWebSearchResult, CloudWebSearchSource, CreateCloudWebSearchJobInput } from "./types";
+type PlainObject = Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is PlainObject;
+export declare function cloneUnknown<T>(value: T): T;
+export declare function isJobStatus(value: unknown): value is CloudWebSearchJobStatus;
+export declare function decodeCloudWebSearchSource(value: unknown, path: string): CloudWebSearchSource;
+export declare function decodeCloudWebSearchResult<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): CloudWebSearchResult<TOutput>;
+export declare function decodeCloudWebSearchProgressEntry(value: unknown, path: string): CloudWebSearchProgressEntry;
+export declare function decodeCloudWebSearchJobRecord<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): CloudWebSearchJobRecord<TOutput>;
+export declare function decodeCloudWebSearchJobEventRecord(value: unknown, path?: string): CloudWebSearchJobEventRecord;
+export declare function decodeCloudWebSearchJobListEnvelope<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): {
+    jobs: CloudWebSearchJobRecord<TOutput>[];
+};
+export declare function decodeCloudWebSearchJobResultEnvelope<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): CloudWebSearchJobResultEnvelope<TOutput>;
+export declare function decodeJobSnapshotPayload<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): {
+    job: CloudWebSearchJobRecord<TOutput>;
+};
+export declare function decodeDirectProgressPayload(value: unknown, path?: string): {
+    jobId: string;
+    status: CloudWebSearchJobStatus;
+    progress: CloudWebSearchProgressEntry;
+};
+export declare function decodeDirectCompletedPayload<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): {
+    job: CloudWebSearchJobRecord<TOutput>;
+    result: CloudWebSearchResult<TOutput> | null;
+};
+export declare function decodeDirectErrorPayload<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): {
+    job: CloudWebSearchJobRecord<TOutput>;
+    errorMessage: string;
+};
+export declare function decodeDirectCancelledPayload<TOutput = unknown>(value: unknown, options?: CloudWebSearchDecodeOptions<TOutput>, path?: string): {
+    job: CloudWebSearchJobRecord<TOutput>;
+};
+export declare function decodeKeepalivePayload(value: unknown, path?: string): {
+    jobId: string;
+    timestamp: string;
+};
+export declare function validateCreateCloudWebSearchJobInput(value: CreateCloudWebSearchJobInput, path?: string): CreateCloudWebSearchJobInput;
+export {};