fauna-api 1.0.682 → 1.0.692

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/contacts.d.ts

@@ -1,31 +1,25 @@
-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;
+import { Credentials, ApiKey } from "../authentification.js";
+export type AddressKind = 'email' | 'phone' | 'discord';
+export type Address = {
+    kind: AddressKind;
+    /** Lowercase email, E.164 phone (+12395551234), or Discord handle without @. */
+    value: string;
 };
-export type SMS = {
-    phone: string;
-};
-export type Identity = Discord | Slack | Email | SMS;
 export type Contact = {
-    profile: Profile;
+    id: string;
+    displayName: string;
+    addresses: Address[];
+    /** One of its emails belongs to a Fauna account: the verified badge. */
     registered: boolean;
-    platforms: Identity[];
+    /** That Fauna account's picture. */
+    icon?: string;
 };
+/** Every contact, sorted by display name. */
 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;
+/** Creates a contact, or with `id` renames one and replaces its addresses. */
+export declare function save(authorization: Credentials | ApiKey, contact: {
+    id?: string;
+    displayName: string;
+    addresses: Address[];
 }): Promise<Contact>;
+export declare function remove(authorization: Credentials | ApiKey, id: string): Promise<void>;

package/dist/src/cicada/contacts.js

@@ -1,4 +1,5 @@
 import { Cicada } from "./index.js";
+/** Every contact, sorted by display name. */
 export async function list(authorization) {
     const response = await fetch(`${Cicada.getURL()}/cicada/contacts`, {
         method: "POST",
@@ -11,18 +12,29 @@ export async function list(authorization) {
         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`, {
+/** Creates a contact, or with `id` renames one and replaces its addresses. */
+export async function save(authorization, contact) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/contacts/save`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
             "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
         },
-        body: JSON.stringify(params)
+        body: JSON.stringify(contact)
     });
     if (!response.ok)
         throw new Error(await response.text());
     return await response.json();
 }
+export async function remove(authorization, id) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/contacts/delete`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ id })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}

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

@@ -12,6 +12,8 @@ export type Inbox = {
     name: string;
     createdAt: Date;
     group?: InboxGroup;
+    /** An agent is on for this inbox. */
+    agent?: boolean;
 };
 export type InboxAccount = {
     platform: Platform;
@@ -46,3 +48,17 @@ export declare function setAgent(authorization: Credentials | ApiKey, inbox: str
     dailyLimit: number;
 }): Promise<AgentSettings>;
 export declare function clearAgent(authorization: Credentials | ApiKey, inbox: string): Promise<void>;
+/**
+ * Has the inbox's agent phone `to` from one of the inbox's lines (`from`, or its first)
+ * and follow `directions`. Returns once the call is placed; the transcript lands on the
+ * thread with that number. Owners only; counts toward the agent's daily limit.
+ */
+export declare function agentCall(authorization: Credentials, inbox: string, call: {
+    to: string;
+    directions: string;
+    from?: string;
+}): Promise<{
+    calling: string;
+    from: string;
+    callId: string;
+}>;

package/dist/src/cicada/inboxes.js

@@ -25,6 +25,7 @@ function wrapInbox(raw) {
         name: raw.name,
         createdAt: new Date(raw.createdAt),
         ...(group ? { group } : {}),
+        ...(raw.agent ? { agent: true } : {}),
     };
 }
 export async function list(authorization) {
@@ -80,3 +81,12 @@ export async function setAgent(authorization, inbox, settings) {
 export async function clearAgent(authorization, inbox) {
     await post(authorization, '/cicada/inboxes/agent/clear', { inbox });
 }
+/**
+ * Has the inbox's agent phone `to` from one of the inbox's lines (`from`, or its first)
+ * and follow `directions`. Returns once the call is placed; the transcript lands on the
+ * thread with that number. Owners only; counts toward the agent's daily limit.
+ */
+export async function agentCall(authorization, inbox, call) {
+    const response = await post(authorization, '/cicada/inboxes/agent/call', { inbox, ...call });
+    return await response.json();
+}

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;