fauna-api 0.0.0-stage → 1.0.676

package/dist/src/calendar.js

@@ -0,0 +1,133 @@
+import { Fauna } from "../index.js";
+const Event = {
+    fromJSON(json) {
+        return {
+            ...json,
+            start: new Date(json.start),
+            end: new Date(json.end),
+            created: new Date(json.created),
+            updated: new Date(json.updated),
+            source: json.source ?? null,
+            attendees: json.attendees ?? [],
+        };
+    },
+};
+function draftJSON(draft) {
+    return {
+        ...draft,
+        start: draft.start?.getTime(),
+        end: draft.end?.getTime(),
+    };
+}
+/**
+ * Events between `from` and `to` (at most 400 days apart), one per occurrence,
+ * soonest first. With `group`, that group's calendar; otherwise yours, your
+ * groups' and the events you're invited to.
+ */
+export async function list(authorization, from, to, group) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events?from=${from.getTime()}&to=${to.getTime()}`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return (await response.json()).map(Event.fromJSON);
+}
+/** One event on your calendar, a group's, or one you're invited to. */
+export async function get(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events/${encodeURIComponent(id)}`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Event.fromJSON(await response.json());
+}
+/** Put an event on your calendar, or `group`'s, and email everyone it invites. */
+export async function create(authorization, draft, group) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        },
+        body: JSON.stringify(draftJSON(draft))
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Event.fromJSON(await response.json());
+}
+/**
+ * Change an event on your calendar or a group's. A recurring event changes as a
+ * whole. New invitees get invited; the rest hear about a new time or place.
+ */
+export async function update(authorization, id, update) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(draftJSON(update))
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Event.fromJSON(await response.json());
+}
+/** Remove an event from your calendar or a group's, telling everyone it invited. */
+export async function remove(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+/** Answer an event you're invited to: `yes`, `no` or `maybe`. */
+export async function respond(authorization, id, answer) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/events/${encodeURIComponent(id)}/respond`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ response: answer })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return Event.fromJSON(await response.json());
+}
+/** The secret .ics link for your calendar, or `group`'s, for Google, Apple or Outlook to subscribe to. */
+export async function feed(authorization, group) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/feed`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            ...(group ? { "Group": group.id } : {})
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return (await response.json()).url;
+}
+/** A new .ics link for your calendar, or `group`'s. The old one stops working. */
+export async function resetFeed(credentials, group) {
+    const response = await fetch(`${Fauna.getURL()}/calendar/feed/reset`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`,
+            ...(group ? { "Group": group.id } : {})
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return (await response.json()).url;
+}

package/dist/src/chats.d.ts

@@ -0,0 +1,113 @@
+import { ApiKey, Credentials, Profile } from "./authentification.js";
+import { LastMessage } from "./parrot/chat.js";
+/** Whose chat it is: one of your groups, a friendship, or a partnership of one of your groups. */
+export type OwnerKind = 'group' | 'friend' | 'partnership';
+/** Who a chat belongs to, and how much you trust it. */
+export type Owner = {
+    kind: OwnerKind;
+    /** The group, friendship or partnership id. */
+    id: string;
+    /** The group's name, your friend's name, or the partner group's name. */
+    name: string;
+    /** Your trust in your friend, or your group's trust in the partner group, in [0, 1). Null for your own groups, which always count. */
+    trust: number | null;
+    /** For a partnership: your group in it. */
+    group?: {
+        id: string;
+        name: string;
+    };
+};
+/** A chat you share with others. */
+export type Chat = {
+    id: string;
+    name: string;
+    /** People only: sends never start a model reply. */
+    human: boolean;
+    owner: Owner;
+    /** Messages you haven't read. Signed in with an API key, the key keeps its own place. */
+    unread: number;
+    /** Milliseconds since the epoch. */
+    updated: number;
+    last: LastMessage | null;
+};
+/** A message as plain text: mentions as names, files as `[file: name]`. */
+export type Message = {
+    position: number;
+    role: string;
+    text: string;
+    author?: Profile;
+    /** The name of the API key an agent posted it with. */
+    via?: string;
+    /** Milliseconds since the epoch. */
+    created: number;
+};
+/** What you haven't read, in chats that pass a trust threshold. */
+export type Unread = {
+    total: number;
+    chats: Chat[];
+};
+/** A chat in a catch up, with what you hadn't read, oldest first. */
+export type CaughtUpChat = {
+    id: string;
+    name: string;
+    human: boolean;
+    owner: Owner;
+    updated: number;
+    messages: Message[];
+};
+export type CaughtUp = {
+    chats: CaughtUpChat[];
+    /** More unread is waiting: catch up again for the next batch. */
+    more: boolean;
+    /** Unread left in chats that pass, after this batch. */
+    unread: number;
+};
+/** The chat a search found a message in. */
+export type ChatReference = {
+    id: string;
+    name: string;
+    owner: Owner;
+};
+export type Found = {
+    chat: ChatReference;
+    message: Message;
+};
+/**
+ * Every chat you share with others, newest first: your groups', your friends'
+ * and your groups' partnerships', each with its owner, your trust in it and what
+ * you haven't read.
+ */
+export declare function list(authorization: Credentials | ApiKey): Promise<Chat[]>;
+/**
+ * What you haven't read in chats you trust at least `minTrust` (default 0.1).
+ * Your own groups' chats always count.
+ */
+export declare function unread(authorization: Credentials | ApiKey, options?: {
+    minTrust?: number;
+}): Promise<Unread>;
+/**
+ * Everything you haven't read in chats you trust at least `minTrust` (default
+ * 0.1), oldest first within each chat, at most `max` messages (default 100),
+ * read as it's returned. Call again while `more` is true. A reader that never
+ * opened a chat starts with its newest 20.
+ */
+export declare function catchUp(authorization: Credentials | ApiKey, options?: {
+    minTrust?: number;
+    max?: number;
+}): Promise<CaughtUp>;
+/**
+ * Messages holding every word of `query` across every chat you share with
+ * others, newest first. `cursor` skips that many matches from the newest; `max`
+ * is the page size (default 20).
+ */
+export declare function search(authorization: Credentials | ApiKey, query: string, options?: {
+    cursor?: number;
+    max?: number;
+}): Promise<Found[]>;
+/**
+ * Post `text` in a chat, as you. Everyone in it sees it live, its webhooks fire
+ * and it counts toward memories, like any message. Signed in with an API key,
+ * the message records the key's name (`via`) and never moves trust. In a chat
+ * that isn't people only, it starts a model reply as any message does.
+ */
+export declare function post(authorization: Credentials | ApiKey, chat: string, text: string): Promise<void>;

package/dist/src/chats.js

@@ -0,0 +1,100 @@
+import { Fauna } from "../index.js";
+import { Parrot } from "./parrot/index.js";
+/**
+ * Every chat you share with others, newest first: your groups', your friends'
+ * and your groups' partnerships', each with its owner, your trust in it and what
+ * you haven't read.
+ */
+export async function list(authorization) {
+    const response = await fetch(`${Fauna.getURL()}/chats/shared`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/**
+ * What you haven't read in chats you trust at least `minTrust` (default 0.1).
+ * Your own groups' chats always count.
+ */
+export async function unread(authorization, options = {}) {
+    const query = options.minTrust !== undefined ? `?minTrust=${encodeURIComponent(String(options.minTrust))}` : '';
+    const response = await fetch(`${Fauna.getURL()}/chats/unread${query}`, {
+        method: "GET",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/**
+ * Everything you haven't read in chats you trust at least `minTrust` (default
+ * 0.1), oldest first within each chat, at most `max` messages (default 100),
+ * read as it's returned. Call again while `more` is true. A reader that never
+ * opened a chat starts with its newest 20.
+ */
+export async function catchUp(authorization, options = {}) {
+    const response = await fetch(`${Fauna.getURL()}/chats/catch-up`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ minTrust: options.minTrust, max: options.max })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/**
+ * Messages holding every word of `query` across every chat you share with
+ * others, newest first. `cursor` skips that many matches from the newest; `max`
+ * is the page size (default 20).
+ */
+export async function search(authorization, query, options = {}) {
+    const response = await fetch(`${Fauna.getURL()}/chats/search`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ query, cursor: options.cursor, max: options.max })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+/**
+ * Post `text` in a chat, as you. Everyone in it sees it live, its webhooks fire
+ * and it counts toward memories, like any message. Signed in with an API key,
+ * the message records the key's name (`via`) and never moves trust. In a chat
+ * that isn't people only, it starts a model reply as any message does.
+ */
+export async function post(authorization, chat, text) {
+    const opened = await fetch(`${Parrot.getURL()}/chat/live/open`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ chatId: chat })
+    });
+    if (!opened.ok)
+        throw new Error(await opened.text());
+    const response = await fetch(`${Parrot.getURL()}/chat/live/append`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+            "Server": `parrot:chat:${chat}`
+        },
+        body: JSON.stringify({ role: 'USER', parts: [{ type: 'TEXT', text }] })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}

package/dist/src/cicada/contacts.d.ts

@@ -0,0 +1,31 @@
+import { Platform } from "../integrations.js";
+import { Profile, Credentials, ApiKey } from "../authentification.js";
+export type Discord = {
+    displayName: string;
+    handle: string;
+    userId?: string;
+};
+export type Slack = {
+    displayName: string;
+    email: string;
+    headline: string;
+};
+export type Email = {
+    email: string;
+};
+export type SMS = {
+    phone: string;
+};
+export type Identity = Discord | Slack | Email | SMS;
+export type Contact = {
+    profile: Profile;
+    registered: boolean;
+    platforms: Identity[];
+};
+export declare function list(authorization: Credentials | ApiKey): Promise<Contact[]>;
+export declare function create(authorization: Credentials | ApiKey, params: {
+    email: string;
+    displayName?: string;
+    platform: Platform;
+    identity?: string;
+}): Promise<Contact>;

package/dist/src/cicada/contacts.js

@@ -0,0 +1,28 @@
+import { Cicada } from "./index.js";
+export async function list(authorization) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/contacts`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}
+// Promote an anonymous sender into a contact. Email is mandatory; passing the
+// platform + raw identity (phone / handle / email) binds existing messages to it.
+export async function create(authorization, params) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/contacts/create`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(params)
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.json();
+}

package/dist/src/cicada/conversations.d.ts

@@ -0,0 +1,73 @@
+import { Contact } from "./contacts.js";
+import { Platform } from "../integrations.js";
+import { Credentials, ApiKey } from "../authentification.js";
+import { File as FaunaFile } from "../drive.js";
+export type Conversation = {
+    id: string;
+    inboxId?: string;
+    participants: (Contact | string)[];
+    activeAt: Date;
+    unread: number;
+};
+export type Reminder = {
+    conversation: Conversation;
+    remindAt: Date;
+};
+export type ScheduledSend = {
+    id: string;
+    sendAt: Date;
+    createdAt: Date;
+    message: string;
+    context: {
+        conversation: string;
+        platform?: Platform;
+    } | {
+        recipients: (Contact | string)[];
+        mode: 'broadcast' | 'group';
+        platform: Platform;
+    };
+};
+export type Message = {
+    id: string;
+    author: Contact | string;
+    platform: Platform;
+    createdAt: Date;
+    message: string;
+    raw?: string;
+    attachments: FaunaFile[];
+    /** Sent by the inbox agent. */
+    agent: boolean;
+};
+export declare function listInbox(authorization: Credentials | ApiKey, inboxId?: string): Promise<Conversation[]>;
+export declare function listArchived(authorization: Credentials | ApiKey, inboxId?: string): Promise<Conversation[]>;
+export declare function listReminders(authorization: Credentials | ApiKey, inboxId?: string): Promise<Reminder[]>;
+export declare function get(authorization: Credentials | ApiKey, conversation: string): Promise<Conversation | null>;
+export declare function read(authorization: Credentials | ApiKey, conversation: string): Promise<Message[]>;
+export declare function autocomplete(authorization: Credentials | ApiKey, conversation: string, text: string): Promise<string>;
+export declare function markRead(authorization: Credentials | ApiKey, conversation: string): Promise<void>;
+export declare function remove(authorization: Credentials | ApiKey, conversation: string): Promise<void>;
+export declare function compose(authorization: Credentials | ApiKey, options: {
+    recipients: string[];
+    platform: Platform;
+    text: string;
+    mode: 'broadcast' | 'group';
+    inboxId?: string;
+    accountId?: string;
+}): Promise<string[]>;
+export declare function send(authorization: Credentials | ApiKey, conversation: string, text: string, platform?: Platform): Promise<string>;
+export declare function archive(authorization: Credentials | ApiKey, conversation: string, archived: boolean): Promise<void>;
+export declare function remind(authorization: Credentials | ApiKey, conversation: string, at: Date | null): Promise<void>;
+export declare function schedule(authorization: Credentials | ApiKey, options: {
+    sendAt: Date;
+    text: string;
+    platform?: Platform;
+    conversationId?: string;
+    compose?: {
+        recipients: string[];
+        mode: 'broadcast' | 'group';
+    };
+    inboxId?: string;
+    accountId?: string;
+}): Promise<string>;
+export declare function listScheduled(authorization: Credentials | ApiKey, inboxId?: string): Promise<ScheduledSend[]>;
+export declare function cancelScheduled(authorization: Credentials | ApiKey, scheduled: string): Promise<void>;