fauna-api 1.0.686 → 1.0.693

package/dist/src/authentification.d.ts

@@ -29,6 +29,19 @@ export type Profile = {
 export declare const Profile: {
     fromJSON(json: unknown): Profile | undefined;
 };
+/** One place you're signed in. `id` names the session; it is not its token. */
+export type Session = {
+    id: string;
+    /** The session this call came from. */
+    current: boolean;
+    /** The browser or client that signed in, as its User-Agent named it. */
+    agent: string;
+    created: Date;
+    expires: Date;
+};
+export declare const Session: {
+    fromJSON(json: any): Session;
+};
 export declare function authorize(email: string, password: string): Promise<Token>;
 export declare function authorizeToken(token: Token): Promise<Credentials>;
 export declare function authorizeApiKey(apiKey: string): Promise<ApiKey>;
@@ -37,6 +50,27 @@ export declare function create(email: string, password: string, phone: string, d
 export declare function edit(credentials: Credentials, update: Partial<Pick<Credentials, 'displayName' | 'icon' | 'email' | 'phone'>>): Promise<boolean>;
 export declare function verify(channel: 'EMAIL' | 'PHONE', target: string, code: string): Promise<boolean>;
 export declare function sendVerification(credentials: Credentials, channel: 'EMAIL' | 'PHONE'): Promise<boolean>;
+/** Emails a link and code for choosing a new password, when an account has that email. Answers the same either way. */
+export declare function forgotPassword(email: string): Promise<boolean>;
+/** A new password, with the code from a reset email. The email counts as verified, and every session ends. */
+export declare function resetPassword(email: string, code: string, password: string): Promise<boolean>;
+/** A new password, given the current one. Every other session ends; this one stays. */
+export declare function changePassword(credentials: Credentials, current: string, password: string): Promise<boolean>;
+/** Your live sessions, newest first. */
+export declare function sessions(credentials: Credentials, query: {
+    cursor: number;
+    max: number;
+}): Promise<Session[]>;
+/** Ends one of your sessions. */
+export declare function revokeSession(credentials: Credentials, session: Session): Promise<boolean>;
+/** Ends the session `credentials` signed in with. */
+export declare function signOut(credentials: Credentials): Promise<boolean>;
+/** Ends every one of your sessions, this one too. */
+export declare function signOutEverywhere(credentials: Credentials): Promise<boolean>;
+/** A single use code that passes this session to another page or app for a minute, so the token never rides in a URL. */
+export declare function handoff(credentials: Credentials): Promise<string>;
+/** Uses up a handoff code for the session token it passes. */
+export declare function redeemHandoff(code: string): Promise<Token>;
 export declare function allocateBalance(credentials: Credentials, target: ApiKey | Group, delta: number): Promise<true>;
 export declare function generateApiKey(credentials: Credentials): Promise<ApiKey>;
 export declare function removeApiKey(credentials: Credentials, apiKey: ApiKey): Promise<boolean>;

package/dist/src/authentification.js

@@ -13,6 +13,17 @@ export const Profile = {
         };
     },
 };
+export const Session = {
+    fromJSON(json) {
+        return {
+            id: String(json.id),
+            current: json.current === true,
+            agent: typeof json.agent === "string" ? json.agent : "",
+            created: new Date(json.created),
+            expires: new Date(json.expires),
+        };
+    },
+};
 // Authorization
 export async function authorize(email, password) {
     const response = await fetch(`${Fauna.getURL()}/authentification/authorize`, {
@@ -108,6 +119,130 @@ export async function sendVerification(credentials, channel) {
     }
     return response.ok;
 }
+// Passwords and sessions
+/** Emails a link and code for choosing a new password, when an account has that email. Answers the same either way. */
+export async function forgotPassword(email) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/password/forgot`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ email })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** A new password, with the code from a reset email. The email counts as verified, and every session ends. */
+export async function resetPassword(email, code, password) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/password/reset`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ email, code, password })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** A new password, given the current one. Every other session ends; this one stays. */
+export async function changePassword(credentials, current, password) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/password`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Token ${credentials.token}`
+        },
+        body: JSON.stringify({ current, password })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** Your live sessions, newest first. */
+export async function sessions(credentials, query) {
+    const params = new URLSearchParams({ cursor: String(query.cursor), max: String(query.max) });
+    const response = await fetch(`${Fauna.getURL()}/authentification/sessions?${params}`, {
+        method: "GET",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return (await response.json()).map((row) => Session.fromJSON(row));
+}
+/** Ends one of your sessions. */
+export async function revokeSession(credentials, session) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/sessions/${encodeURIComponent(session.id)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** Ends the session `credentials` signed in with. */
+export async function signOut(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/sign-out`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** Ends every one of your sessions, this one too. */
+export async function signOutEverywhere(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/sessions`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.ok;
+}
+/** A single use code that passes this session to another page or app for a minute, so the token never rides in a URL. */
+export async function handoff(credentials) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/handoff`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Token ${credentials.token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return String((await response.json()).code);
+}
+/** Uses up a handoff code for the session token it passes. */
+export async function redeemHandoff(code) {
+    const response = await fetch(`${Fauna.getURL()}/authentification/handoff/redeem`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return await response.text();
+}
 export async function allocateBalance(credentials, target, delta) {
     const deltaMicros = Math.round(delta * 1000000);
     if (!Number.isSafeInteger(deltaMicros))

package/dist/src/calendar.d.ts

@@ -77,7 +77,10 @@ export declare function update(authorization: Credentials | ApiKey, id: string,
 export declare function remove(authorization: Credentials | ApiKey, id: string): Promise<void>;
 /** Answer an event you're invited to: `yes`, `no` or `maybe`. */
 export declare function respond(authorization: Credentials | ApiKey, id: string, answer: Answer): Promise<Event>;
-/** The secret .ics link for your calendar, or `group`'s, for Google, Apple or Outlook to subscribe to. */
+/** Your own secret .ics link for your calendar, or `group`'s, for Google, Apple or
+ *  Outlook to subscribe to. Each person has their own link, and a group's stops
+ *  working when you leave the group. */
 export declare function feed(authorization: Credentials | ApiKey, group?: Group): Promise<string>;
-/** A new .ics link for your calendar, or `group`'s. The old one stops working. */
+/** A new .ics link of your own for your calendar, or `group`'s. Your old one stops
+ *  working; nobody else's changes. */
 export declare function resetFeed(credentials: Credentials, group?: Group): Promise<string>;

package/dist/src/calendar.js

@@ -105,7 +105,9 @@ export async function respond(authorization, id, answer) {
         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. */
+/** Your own secret .ics link for your calendar, or `group`'s, for Google, Apple or
+ *  Outlook to subscribe to. Each person has their own link, and a group's stops
+ *  working when you leave the group. */
 export async function feed(authorization, group) {
     const response = await fetch(`${Fauna.getURL()}/calendar/feed`, {
         method: "GET",
@@ -118,7 +120,8 @@ export async function feed(authorization, group) {
         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. */
+/** A new .ics link of your own for your calendar, or `group`'s. Your old one stops
+ *  working; nobody else's changes. */
 export async function resetFeed(credentials, group) {
     const response = await fetch(`${Fauna.getURL()}/calendar/feed/reset`, {
         method: "POST",

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

@@ -1,7 +1,7 @@
 import { Cicada } from "./index.js";
 import { Platform } from "../integrations.js";
 import { Credentials, ApiKey } from "../authentification.js";
-import type { Text } from "../parrot/generative.js";
+import type { Text, Voice } from "../parrot/generative.js";
 export type InboxGroup = {
     id: string;
     name: string;
@@ -30,8 +30,12 @@ export declare function assign(authorization: Credentials | ApiKey, inboxId: str
 }): Promise<void>;
 export declare function listAccounts(authorization: Credentials | ApiKey, inboxId: string): Promise<InboxAccount[]>;
 /** `dailyLimit` and `spentToday` are dollars per UTC day; at the limit the agent pauses until midnight UTC. */
+/** `reasoning` is one of the text model's catalog tiers, empty for its default; `voiceModel`
+ *  is the realtime voice the agent talks with on calls, empty for the catalog's first. */
 export type AgentSettings = {
     model: Text;
+    reasoning: string;
+    voiceModel: Voice | '';
     instructions: string;
     dailyLimit: number;
     spentToday: number;
@@ -44,6 +48,8 @@ export declare function getAgent(authorization: Credentials | ApiKey, inbox: str
 /** Turns the agent on (it answers messages sent from now on) or updates it. */
 export declare function setAgent(authorization: Credentials | ApiKey, inbox: string, settings: {
     model: Text;
+    reasoning?: string;
+    voiceModel?: Voice;
     instructions: string;
     dailyLimit: number;
 }): Promise<AgentSettings>;

package/dist/src/cicada/inboxes.js

@@ -61,6 +61,8 @@ export const AgentSettings = {
     fromJSON(json) {
         return {
             model: json.model,
+            reasoning: String(json.reasoning ?? ''),
+            voiceModel: String(json.voiceModel ?? ''),
             instructions: String(json.instructions ?? ''),
             dailyLimit: Number(json.dailyLimit ?? 0),
             spentToday: Number(json.spentToday ?? 0),

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

@@ -1,3 +1,4 @@
+import { Cicada } from "./index.js";
 import { Credentials, ApiKey } from "../authentification.js";
 import WebSocket from "isomorphic-ws";
 export type CallEnd = {
@@ -46,3 +47,47 @@ export declare function listen(authorization: Credentials | ApiKey, inbox: strin
 }>;
 /** Calls `to` from one of the inbox's phone lines: `from`, or its first line. */
 export declare function call(authorization: Credentials | ApiKey, inbox: string, to: string, from?: string): Promise<PhoneCall>;
+/** Where in a recording something was said, in milliseconds from its start. */
+export type CallSpan = {
+    startMs: number;
+    endMs: number;
+};
+/** One side speaking in a recorded call, each word timed. `You` is the inbox's side on a
+ *  call a person took or placed; `Agent` is the inbox's agent. */
+export type CallSegment = CallSpan & {
+    speaker: 'Them' | 'You' | 'Agent';
+    text: string;
+    words: CallSpan[];
+};
+/** A call on one of the inbox's lines, with its recording's timed transcript. */
+export type CallRecord = {
+    id: string;
+    direction: 'IN' | 'OUT';
+    /** The other party, E.164. */
+    peer: string;
+    /** The inbox's line, E.164. */
+    line: string;
+    status: string;
+    startedAt: Date;
+    /** Seconds it was connected. */
+    duration: number;
+    /** The inbox's agent took or placed it. */
+    agent: boolean;
+    /** A message left on the line, or a call that reached their voicemail. */
+    voicemail: boolean;
+    /** Its audio can be fetched with recording(). */
+    recorded: boolean;
+    segments: CallSegment[];
+};
+export declare const CallRecord: {
+    fromJSON(json: any): CallRecord;
+};
+/** The inbox's calls, newest first. `voicemails` keeps only voicemails; `query` matches what was said, the number, or the contact's name. */
+export declare function history(authorization: Credentials | ApiKey, inbox: string, opts?: {
+    voicemails?: boolean;
+    query?: string;
+    cursor?: number;
+    max?: number;
+}): Promise<CallRecord[]>;
+/** A recorded call's audio, MP3. */
+export declare function recording(authorization: Credentials | ApiKey, call: string): Promise<Blob>;

package/dist/src/cicada/phone.js

@@ -304,3 +304,49 @@ export async function listen(authorization, inbox, onIncoming) {
 export async function call(authorization, inbox, to, from) {
     return openCall(authorization, { event: 'dial', inbox, to, ...(from ? { from } : {}) });
 }
+export const CallRecord = {
+    fromJSON(json) {
+        return {
+            id: String(json.id),
+            direction: json.direction === 'in' ? 'IN' : 'OUT',
+            peer: String(json.peer ?? ''),
+            line: String(json.line ?? ''),
+            status: String(json.status ?? ''),
+            startedAt: new Date(json.startedAt),
+            duration: Number(json.duration ?? 0),
+            agent: Boolean(json.agent),
+            voicemail: Boolean(json.voicemail),
+            recorded: Boolean(json.recorded),
+            segments: Array.isArray(json.segments) ? json.segments : [],
+        };
+    },
+};
+/** The inbox's calls, newest first. `voicemails` keeps only voicemails; `query` matches what was said, the number, or the contact's name. */
+export async function history(authorization, inbox, opts = {}) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/phone/history`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+        },
+        body: JSON.stringify({ inbox, ...opts }),
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return (Array.isArray(json) ? json : []).map(CallRecord.fromJSON);
+}
+/** A recorded call's audio, MP3. */
+export async function recording(authorization, call) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/phone/recording`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
+        },
+        body: JSON.stringify({ call }),
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.blob();
+}

package/dist/src/extensions/web/session.d.ts

@@ -103,6 +103,4 @@ export declare function invite(authorization: Credentials | ApiKey, email: strin
     accessCode: string;
 } | {
     reference: string;
-}): Promise<{
-    status: "added" | "invited";
-}>;
+}): Promise<void>;

package/dist/src/extensions/web/session.js

@@ -318,7 +318,6 @@ export async function invite(authorization, email, joinUrl, scope) {
     });
     if (!response.ok)
         throw new Error(await response.text());
-    return await response.json();
 }
 // ── Bootstrap helpers ────────────────────────────────────────────────────────
 async function publishPageBootstrap(web, authorization, root, onProgress, targetOverride) {

package/dist/src/groups.d.ts

@@ -1,60 +1,207 @@
+import { Fauna } from "../index.js";
 import { ApiKey, Credentials, Profile } from "./authentification.js";
 import { ChatSummary } from "./parrot/chat.js";
+/** A group named inside another record. */
+export type GroupRef = {
+    id: string;
+    name: string;
+    icon?: string;
+};
+export declare const GroupRef: {
+    fromJSON(json: any): GroupRef;
+};
+/** One way someone is in a group. `through` is the group's own id when they are
+ *  directly in it, else the nested group they come in through. */
+export type GroupMember = {
+    email: string;
+    displayName?: string;
+    icon?: string;
+    through: string;
+};
+export declare const GroupMember: {
+    fromJSON(json: any): GroupMember;
+};
+/** A group as someone in it sees it. A group holds people and other groups:
+ *  everyone in a nested group is in this one too, never the other way. */
 export type Group = {
     id: string;
     name: string;
     icon?: string;
     balance: number;
-    members: Profile[];
     createdAt: Date;
+    /** Emails of its admins, who are always directly in it: they change the group, who is in it and how people and groups join. */
+    admins: string[];
+    /** Emails of the people directly in it, admins included. */
+    people: string[];
+    /** The groups nested directly inside it. */
+    groups: GroupRef[];
+    /** Everyone in it, once per way in: the people directly in it first, then everyone who comes in through each nested group. */
+    members: GroupMember[];
+    /** How you are in it: its own id when you are directly in it, else the nested group you come in through. */
+    through: string;
 };
-/** A group as someone outside it sees it: no balance, no member list. */
+export declare const Group: {
+    fromJSON(json: any): Group;
+};
+/** A join link, as the group's admins see it. People join with it, and admins of
+ *  other groups put their group inside this one with it. */
+export type JoinLink = {
+    code: string;
+    /** How many people or groups joined with it. */
+    uses: number;
+    /** How many it lets in before it is used up; absent when any number can join until it expires. */
+    maxUses?: number;
+    expires: Date;
+};
+export declare const JoinLink: {
+    fromJSON(json: any): JoinLink;
+};
+/** A group as anyone signed in may see it: no balance, no member list.
+ *  `memberCount` counts everyone in it, directly or through a nested group. */
 export type GroupSummary = {
     id: string;
     name: string;
     icon?: string;
     memberCount: number;
 };
-/** A person found by `query`, with the groups they belong to. */
+export declare const GroupSummary: {
+    fromJSON(json: any): GroupSummary;
+};
+/** A group a person found by `query` is in, and how: `through` is the group's own
+ *  id when they are directly in it, else the nested group they come in through. */
+export type MatchedGroup = {
+    id: string;
+    name: string;
+    icon?: string;
+    memberCount: number;
+    through: string;
+};
+export declare const MatchedGroup: {
+    fromJSON(json: any): MatchedGroup;
+};
+/** A person found by `query`, with every group they are in. */
 export type GroupMatch = {
     profile: Profile;
-    groups: GroupSummary[];
+    groups: MatchedGroup[];
+};
+export declare const GroupMatch: {
+    fromJSON(json: any): GroupMatch;
+};
+/** Which side sent a nesting: `parent` invited the child, whose admins accept;
+ *  `child` asked to go inside the parent, whose admins approve. */
+export type NestSide = 'parent' | 'child';
+/** A group invited inside another, or asking to go inside one, waiting for the other side's admins. */
+export type GroupNest = {
+    token: string;
+    parent: GroupRef;
+    child: GroupRef;
+    from: NestSide;
+    /** Email of the admin who sent it. */
+    by?: string;
+    expires: Date;
+};
+export declare const GroupNest: {
+    fromJSON(json: any): GroupNest;
 };
+/** What `inviteGroup` and `requestGroup` did: nested at once when you administer
+ *  both groups, else waiting on the other side with `token`. */
+export type NestOffer = {
+    nested: true;
+} | {
+    nested: false;
+    token: string;
+};
+export declare const NestOffer: {
+    fromJSON(json: any): NestOffer;
+};
+/** Start a group. You are its first admin. Needs a subscription. */
 export declare function create(credentials: Credentials, name: string): Promise<Group>;
+/** Every group you are in, directly or through a nested group, oldest first.
+ *  Each says how you are in it (`through`). */
 export declare function list(authorization: Credentials | ApiKey): Promise<Group[]>;
-/** People matching a partial email or name, best first, each with their groups.
- *  Only people in at least one group come back. */
+/** People matching a partial email or name, best first, each with every group
+ *  they are in and how. Only people in at least one group come back. */
 export declare function query(authorization: Credentials | ApiKey, profile: Partial<Profile>): Promise<GroupMatch[]>;
 /** Name, icon and member count of groups by id, including groups you are not in.
  *  Unknown ids are left out. */
 export declare function summaries(authorization: Credentials | ApiKey, ids: string[]): Promise<GroupSummary[]>;
+/** A group you are in, directly or through a nested group. */
 export declare function get(authorization: Credentials | ApiKey, id: string): Promise<Group>;
+/** Change the group's name or icon. Admins only. */
 export declare function edit(credentials: Credentials, id: string, update: Partial<Group>): Promise<Group>;
-/** Add a user to a group by email. Resolves `{ status: 'added' }` if they were
- *  added directly (they have a Fauna account), or `{ status: 'invited', token }`
- *  if a pending invite was stored instead (no Fauna account for that email yet).
- *  Fauna emails the invite unless `notify` is false, so an app can send its own
- *  email carrying the token. */
+/** Delete a group with its chats, files, calendar, rooms, webhooks and
+ *  partnerships. It leaves every group it was in; the groups inside it stay.
+ *  Its direct admins may, and so may anyone holding `fauna/groups:delete:global`. */
+export declare function remove(credentials: Credentials, id: string): Promise<void>;
+/** Invite an email to a group. Admins only. Nobody joins until they accept the
+ *  invite with its token (`acceptInvite`), whether or not the email already has
+ *  a Fauna account, and the answer is the same either way. Fauna emails the
+ *  invite unless `notify` is false, so an app can send its own email carrying
+ *  the token. Resolves to the token. */
 export declare function invite(credentials: Credentials, id: string, email: string, options?: {
     notify?: boolean;
-}): Promise<{
-    status: 'added';
-} | {
-    status: 'invited';
-    token: string;
-}>;
-/** Join the group an email invite points at, using the token from the invite. */
+}): Promise<string>;
+/** Join the group an email invite points at, using the token from the invite.
+ *  `alreadyMember` says you were directly in it already. */
 export declare function acceptInvite(credentials: Credentials, token: string): Promise<{
     group: Group;
     alreadyMember: boolean;
 }>;
-export declare function generateLink(credentials: Credentials, id: string): Promise<string>;
-export declare function join(credentials: Credentials, code: string): Promise<{
+/** A join code good for seven days. Admins only. People join with it, and admins
+ *  of other groups put their group inside this one with it. `maxUses` caps how
+ *  many it lets in; without it, any number can join until it expires. */
+export declare function generateLink(credentials: Credentials, id: string, options?: {
+    maxUses?: number;
+}): Promise<string>;
+/** The group's join links that still work, newest first. Admins only. */
+export declare function links(credentials: Credentials, id: string): Promise<JoinLink[]>;
+/** A join link stops working. Admins only. */
+export declare function revokeLink(credentials: Credentials, id: string, code: string): Promise<void>;
+/** Join a group with a join code. With `group`, a group you administer goes
+ *  inside it instead, and you are in it through that group. `alreadyMember` says
+ *  you (or `group`) were in it already. */
+export declare function join(credentials: Credentials, code: string, group?: string): Promise<{
     group: Group;
     alreadyMember: boolean;
 }>;
+/** Leave a group you are directly in. The last admin can't while anyone else is
+ *  in it, directly or through a nested group: make someone else an admin, or
+ *  delete the group. When nobody else is in it, leaving deletes it. */
 export declare function leave(credentials: Credentials, id: string): Promise<void>;
+/** Remove a person who is directly in the group. Admins only. */
 export declare function kick(credentials: Credentials, id: string, email: string): Promise<void>;
+/** Make a person who is directly in the group an admin. Admins only. Someone in
+ *  it only through a nested group is invited directly first. */
+export declare function promote(credentials: Credentials, id: string, email: string): Promise<Group>;
+/** Make an admin a member again. Admins only; a group keeps at least one admin. */
+export declare function demote(credentials: Credentials, id: string, email: string): Promise<Group>;
+/** Invite group `child` inside group `id`; the child's admins accept with the
+ *  token (`acceptNest`). Admins of `id` only. Nests at once when you administer
+ *  both. Unless `notify` is false, the child's admins hear about it in their
+ *  Fauna inbox. Nesting is at most 5 groups deep and never makes a loop. */
+export declare function inviteGroup(credentials: Credentials, id: string, child: string, options?: {
+    notify?: boolean;
+}): Promise<NestOffer>;
+/** Ask to put group `id` inside group `parent`; the parent's admins approve with
+ *  the token (`acceptNest`). Admins of `id` only. Nests at once when you
+ *  administer both. Unless `notify` is false, the parent's admins hear about it
+ *  in their Fauna inbox. */
+export declare function requestGroup(credentials: Credentials, id: string, parent: string, options?: {
+    notify?: boolean;
+}): Promise<NestOffer>;
+/** The invites and requests waiting on or from a group, newest first. Admins only. */
+export declare function nests(credentials: Credentials, id: string, query: {
+    cursor: number;
+    max: number;
+}): Promise<GroupNest[]>;
+/** Accept an invite into a group, or approve a request to join one, by its
+ *  token. An admin of the side it waits on only. Resolves to the parent group. */
+export declare function acceptNest(credentials: Credentials, token: string): Promise<Group>;
+/** Drop a waiting invite or request by its token. An admin of either group. */
+export declare function revokeNest(credentials: Credentials, token: string): Promise<void>;
+/** Take group `child` out of group `id`. An admin of either group. Everyone who
+ *  was in `id` only through it loses it. */
+export declare function unnest(credentials: Credentials, id: string, child: string): Promise<void>;
 /** Two groups with people only chats between them. `group` is the one of yours it was listed for. */
 export type Partnership = {
     id: string;