@tinycloud/sdk-services 3.8.0-beta.9 → 3.8.0

package/dist/feed/index.d.ts

@@ -0,0 +1,238 @@
+import { I as IDatabaseHandle } from '../ISQLService-Aly1CBsW.js';
+import { I as IHooksService, H as HookSubscription } from '../IHooksService-CvTpJbQD.js';
+import { f as Result } from '../types-CSd0RYir.js';
+import { z } from 'zod';
+
+/** Provenance only; these client fields do not grant database authority. */
+interface FeedRestoreOrigin {
+    sourceSpaceId: string;
+    namespace: string;
+    snapshotId: string;
+    sourceKey: string;
+    eventKey?: string;
+}
+interface FeedRestoreDeliveryPolicy {
+    recipient: string;
+    state: "pending" | "held" | "delivered" | "unconfirmed" | "refused" | "unknown";
+    dispatch: "never" | "resolved-pending" | "held";
+    resolvedOwnerMapping: boolean;
+    /** Required: null explicitly means there is no absolute execution cutoff. */
+    dispatchBefore: string | null;
+    source: FeedRestoreOrigin;
+}
+interface FeedRestoreResponse {
+    response: NewFeedResponse | NewFeedMessage;
+    payload?: FeedResponsePayload;
+    origin: FeedRestoreOrigin;
+    deliveries?: FeedRestoreDeliveryPolicy[];
+}
+interface FeedRestoreRecords {
+    cards: FeedCard[];
+    responses: FeedRestoreResponse[];
+}
+/** Cursor covers every verified header, including imported rows denied dispatch. */
+interface FeedResponseDeliveryPage {
+    responses: FeedResponse[];
+    nextSequence: number;
+    hasMore: boolean;
+}
+
+interface FeedCardHistoryPage {
+    cards: FeedCard[];
+    nextIdentity: FeedCardIdentity | null;
+    hasMore: boolean;
+}
+
+type FeedDatabase = Pick<IDatabaseHandle, "query" | "execute" | "batch">;
+type FeedReadDatabase = Pick<IDatabaseHandle, "query">;
+type JSONValue = null | boolean | number | string | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+interface FeedResponsePayload {
+    type: string;
+    version: number;
+    data: JSONValue;
+}
+interface FeedCardIdentity {
+    cardId: string;
+    revision: number;
+    issuanceId: string;
+}
+interface FeedChoice {
+    id: string;
+    label: string;
+}
+interface FeedCard extends FeedCardIdentity {
+    kind: string;
+    needsResponse: boolean;
+    title: string;
+    body: string;
+    choices?: FeedChoice[];
+    urgency: number;
+    createdAt: string;
+    payload?: Record<string, unknown>;
+}
+interface FeedResponseIdentity extends FeedCardIdentity {
+    responseId: string;
+}
+interface NewFeedResponse extends FeedResponseIdentity {
+    kind: "answer" | "followup";
+    choiceId?: string;
+    text?: string;
+    supersedesResponseId?: string;
+    createdAt: string;
+}
+interface NewFeedMessage extends FeedResponseIdentity {
+    kind: "message";
+    text: string;
+    createdAt: string;
+}
+interface FeedResponse extends Omit<NewFeedResponse, "kind"> {
+    kind: NewFeedResponse["kind"] | "message";
+    sequence: number;
+    payloadType?: string;
+    payloadVersion?: number;
+    /** Added only by verified imported delivery policy; undefined retains ordinary live behavior. */
+    dispatchBefore?: string | null;
+}
+interface FeedHandling extends FeedCardIdentity {
+    handlingId: string;
+    responseId: string;
+    phase: "acknowledged" | "succeeded" | "failed";
+    createdAt: string;
+    detail?: Record<string, unknown>;
+}
+interface FeedResponseHandling {
+    acknowledgement: FeedHandling | null;
+    outcome: FeedHandling | null;
+}
+interface FeedCardState extends FeedResponseHandling {
+    card: FeedCard;
+    response: FeedResponse | null;
+}
+interface FeedDatabases {
+    output: FeedDatabase;
+    responses: FeedDatabase;
+}
+interface FeedHandoff {
+    responseId: string;
+    recipient: string;
+    response: FeedResponse;
+    state: "prepared" | "unconfirmed" | "delivered";
+}
+interface FeedDeliveryOptions {
+    handoff: FeedDatabase;
+    recipient: string;
+    response: FeedResponse;
+    deliver: (response: FeedResponse) => Promise<"delivered" | "unconfirmed">;
+}
+type FeedHooks = Pick<IHooksService, "subscribe">;
+interface FeedListenerOptions {
+    responses: FeedReadDatabase;
+    handoff: FeedDatabase;
+    recipient: string;
+    hooks: FeedHooks;
+    subscription: HookSubscription;
+    deliver: FeedDeliveryOptions["deliver"];
+    signal: AbortSignal;
+    renewalSeconds?: number;
+}
+interface FeedSource {
+    sourceId: string;
+    agentDid: string;
+    label: string;
+    output: {
+        spaceId: string;
+        database: string;
+    };
+    responses: {
+        spaceId: string;
+        database: string;
+    };
+}
+type FeedSelector = "information" | "both" | "needs-action";
+interface FeedOwnerView extends FeedCardIdentity {
+    sourceId: string;
+    seenAt?: string;
+    snoozedUntil?: string;
+}
+interface FeedOwnerSettings {
+    defaultSelector: FeedSelector;
+}
+interface FeedApi {
+    feedResourceNames(prefix: string, stableToken: string): Result<{
+        outputResource: string;
+        responseResource: string;
+    }>;
+    initializeFeedDatabases(databases: FeedDatabases): Promise<Result<void>>;
+    publishFeedCard(output: FeedDatabase, card: FeedCard): Promise<Result<FeedCard>>;
+    appendFeedResponse(output: FeedReadDatabase, responses: FeedDatabase, response: NewFeedResponse, payload?: FeedResponsePayload): Promise<Result<FeedResponse>>;
+    appendFeedMessage(output: FeedReadDatabase, responses: FeedDatabase, input: NewFeedMessage, payload?: FeedResponsePayload): Promise<Result<FeedResponse>>;
+    readFeedResponsePayload(responses: FeedReadDatabase, identity: FeedResponseIdentity): Promise<Result<FeedResponsePayload | undefined>>;
+    projectFeedResponseNotification(response: FeedResponse): FeedResponse;
+    listFeedCards(output: FeedReadDatabase): Promise<Result<FeedCard[]>>;
+    listFeedCardHistory(output: FeedReadDatabase, options?: {
+        afterIdentity?: FeedCardIdentity;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<Result<FeedCardHistoryPage>>;
+    listFeedResponses(responses: FeedReadDatabase, options?: {
+        afterSequence?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<Result<FeedResponse[]>>;
+    restoreFeedRecords(ownerPair: FeedDatabases, records: FeedRestoreRecords, options?: {
+        signal?: AbortSignal;
+    }): Promise<Result<void>>;
+    listFeedResponseDeliveries(responses: FeedReadDatabase, options: {
+        recipient: string;
+        afterSequence?: number;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<Result<FeedResponseDeliveryPage>>;
+    recordFeedHandling(output: FeedDatabase, handling: FeedHandling): Promise<Result<FeedHandling>>;
+    readFeedResponseHandling(output: FeedReadDatabase, identity: FeedResponseIdentity): Promise<Result<FeedResponseHandling>>;
+    getFeedCardState(output: FeedReadDatabase, responses: FeedReadDatabase, identity: FeedCardIdentity): Promise<Result<FeedCardState>>;
+    resolveFeedCard(output: FeedReadDatabase, reference: string): Promise<Result<FeedCardIdentity>>;
+    initializeFeedHandoff(handoff: FeedDatabase): Promise<Result<void>>;
+    getFeedHandoff(handoff: FeedReadDatabase, responseId: string, recipient: string): Promise<Result<FeedHandoff | null>>;
+    deliverFeedResponse(options: FeedDeliveryOptions): Promise<Result<FeedHandoff>>;
+    listenFeedResponses(options: FeedListenerOptions): Promise<void>;
+}
+
+declare const initializeFeedDatabases: FeedApi["initializeFeedDatabases"];
+declare const publishFeedCard: FeedApi["publishFeedCard"];
+declare const listFeedCards: FeedApi["listFeedCards"];
+declare const appendFeedResponse: FeedApi["appendFeedResponse"];
+declare const appendFeedMessage: FeedApi["appendFeedMessage"];
+declare const readFeedResponsePayload: FeedApi["readFeedResponsePayload"];
+declare const listFeedResponses: FeedApi["listFeedResponses"];
+declare const recordFeedHandling: FeedApi["recordFeedHandling"];
+declare const readFeedResponseHandling: FeedApi["readFeedResponseHandling"];
+declare const getFeedCardState: FeedApi["getFeedCardState"];
+declare const resolveFeedCard: FeedApi["resolveFeedCard"];
+
+declare const initializeFeedHandoff: FeedApi["initializeFeedHandoff"];
+declare const getFeedHandoff: FeedApi["getFeedHandoff"];
+declare const deliverFeedResponse: FeedApi["deliverFeedResponse"];
+
+declare const listenFeedResponses: FeedApi["listenFeedResponses"];
+
+declare const feedResourceNames: FeedApi["feedResourceNames"];
+
+declare const feedResponsePayloadSchema: z.ZodType<FeedResponsePayload>;
+declare const feedCardSchema: z.ZodType<FeedCard>;
+declare const newFeedResponseSchema: z.ZodType<NewFeedResponse>;
+declare const newFeedMessageSchema: z.ZodType<NewFeedMessage>;
+declare const feedHandlingSchema: z.ZodType<FeedHandling>;
+
+/** A notification is an allowlisted header, never a copy of private payload data. */
+declare const projectFeedResponseNotification: FeedApi["projectFeedResponseNotification"];
+
+declare const restoreFeedRecords: FeedApi["restoreFeedRecords"];
+
+declare const listFeedResponseDeliveries: FeedApi["listFeedResponseDeliveries"];
+
+declare const listFeedCardHistory: FeedApi["listFeedCardHistory"];
+
+export { type FeedApi, type FeedCard, type FeedCardHistoryPage, type FeedCardIdentity, type FeedCardState, type FeedChoice, type FeedDatabase, type FeedDatabases, type FeedDeliveryOptions, type FeedHandling, type FeedHandoff, type FeedHooks, type FeedListenerOptions, type FeedOwnerSettings, type FeedOwnerView, type FeedReadDatabase, type FeedResponse, type FeedResponseDeliveryPage, type FeedResponseHandling, type FeedResponseIdentity, type FeedResponsePayload, type FeedRestoreDeliveryPolicy, type FeedRestoreOrigin, type FeedRestoreRecords, type FeedRestoreResponse, type FeedSelector, type FeedSource, type JSONValue, type NewFeedMessage, type NewFeedResponse, appendFeedMessage, appendFeedResponse, deliverFeedResponse, feedCardSchema, feedHandlingSchema, feedResourceNames, feedResponsePayloadSchema, getFeedCardState, getFeedHandoff, initializeFeedDatabases, initializeFeedHandoff, listFeedCardHistory, listFeedCards, listFeedResponseDeliveries, listFeedResponses, listenFeedResponses, newFeedMessageSchema, newFeedResponseSchema, projectFeedResponseNotification, publishFeedCard, readFeedResponseHandling, readFeedResponsePayload, recordFeedHandling, resolveFeedCard, restoreFeedRecords };