palbase 0.16.1 → 0.17.1

package/types/internal/src/modules/messaging.d.ts

@@ -0,0 +1,2322 @@
+import { type Reply, type Transport } from '../transport.js';
+/**
+ * One time the project's server read or removed people's messages.
+ */
+export type AccessEntry = {
+    /**
+     * read_messages, read_report, delete_message, delete_conversation or send_message.
+     */
+    action: string;
+    /**
+     * The key that made the call.
+     */
+    actor: string;
+    /**
+     * When.
+     */
+    at: string;
+    /**
+     * The conversation.
+     */
+    conversation_id: string | null;
+    /**
+     * How many messages.
+     */
+    count: number;
+    /**
+     * The entry.
+     */
+    id: number;
+    /**
+     * The request.
+     */
+    request_id: string | null;
+    /**
+     * The person.
+     */
+    user_id: string | null;
+};
+export type AccessLogPage = {
+    /**
+     * The entries, the newest first.
+     */
+    data: AccessEntry[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * Adds people to a group.
+ */
+export type AddMembersRequest = {
+    /**
+     * The people (1 to 100).
+     */
+    user_ids: string[];
+};
+/**
+ * Makes a conversation for people.
+ */
+export type AdminConversationRequest = {
+    /**
+     * A group's description.
+     */
+    description?: string;
+    /**
+     * direct (member_ids: the two) or group.
+     */
+    kind: "direct" | "group";
+    /**
+     * Its people.
+     */
+    member_ids: string[];
+    /**
+     * A group's owner (none: the server keeps it).
+     */
+    owner_id?: string;
+    /**
+     * Where the app reads a group's picture.
+     */
+    photo?: string;
+    settings?: GroupSettings;
+    /**
+     * A group's title.
+     */
+    title?: string;
+};
+/**
+ * A message the project's server says, as the app.
+ */
+export type AdminMessageRequest = {
+    /**
+     * The server's own id of it: sent again with it, it is the same message.
+     */
+    client_message_id: string;
+    /**
+     * Whom its words name.
+     */
+    mentions?: Mention[];
+    /**
+     * What it says.
+     */
+    text: string;
+};
+/**
+ * The project's server's word on a person's name and picture.
+ */
+export type AdminProfileRequest = {
+    /**
+     * Where the app reads the picture.
+     */
+    image?: string | null;
+    /**
+     * A name (1 to 100 characters).
+     */
+    name?: string | null;
+};
+/**
+ * A file a message carries.
+ */
+export type Attachment = {
+    /**
+     * Its type, as the app gave it.
+     */
+    content_type: string;
+    /**
+     * A voice message's or video's length.
+     */
+    duration_ms: number | null;
+    /**
+     * The key that opens the file (the app encrypted it); null on a message seen a limited number of times — POST …/view gives it.
+     */
+    file_key: string | null;
+    /**
+     * A picture's or video's height.
+     */
+    height: number | null;
+    /**
+     * The file (its upload's id).
+     */
+    id: string;
+    /**
+     * Its name, as the app gave it.
+     */
+    name: string | null;
+    /**
+     * Its size in bytes (encrypted).
+     */
+    size: number;
+    /**
+     * A small preview, as the app made it (encrypted with the file's key); null on a message seen once.
+     */
+    thumbnail: string | null;
+    /**
+     * A voice message's waveform, as the app made it.
+     */
+    waveform?: number[];
+    /**
+     * A picture's or video's width.
+     */
+    width: number | null;
+};
+/**
+ * A file a message carries.
+ */
+export type AttachmentRequest = {
+    /**
+     * Its type.
+     */
+    content_type: string;
+    /**
+     * A voice message's or video's length.
+     */
+    duration_ms?: number;
+    /**
+     * The key that opens it (the app encrypted it with it).
+     */
+    file_key: string;
+    /**
+     * A picture's or video's height.
+     */
+    height?: number;
+    /**
+     * Its name.
+     */
+    name?: string;
+    /**
+     * A small preview the app made, encrypted with the file's key (at most 24 KiB).
+     */
+    thumbnail?: string;
+    /**
+     * An upload of the conversation's (POST …/uploads), uploaded.
+     */
+    upload_id: string;
+    /**
+     * A voice message's waveform.
+     */
+    waveform?: number[];
+    /**
+     * A picture's or video's width.
+     */
+    width?: number;
+};
+/**
+ * A person the reader blocks.
+ */
+export type Block = {
+    /**
+     * Since when.
+     */
+    created_at: string;
+    /**
+     * The person blocked.
+     */
+    user_id: string;
+};
+export type BlockPage = {
+    /**
+     * The people blocked.
+     */
+    data: Block[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * A conversation as a member reads it.
+ */
+export type Conversation = {
+    /**
+     * When it was made.
+     */
+    created_at: string;
+    /**
+     * Who made it; null: the project's server.
+     */
+    created_by: string | null;
+    /**
+     * Deleted for everyone.
+     */
+    deleted: boolean;
+    /**
+     * A group's description.
+     */
+    description: string | null;
+    /**
+     * How what it says is kept: server — sealed with its own key, which the platform holds (not end-to-end).
+     */
+    encryption: "server";
+    /**
+     * More of its messages changed than a sync carries: what the reader keeps of it is read again, a page at a time.
+     */
+    gap?: boolean;
+    /**
+     * The conversation.
+     */
+    id: string;
+    /**
+     * direct (two people) or group.
+     */
+    kind: "direct" | "group";
+    last_message?: Message;
+    /**
+     * When its timeline last moved.
+     */
+    last_message_at: string | null;
+    /**
+     * Its last message's place.
+     */
+    last_seq: number;
+    /**
+     * The reader's own place in it.
+     */
+    me: MemberState | null;
+    /**
+     * How many people are in it.
+     */
+    member_count: number;
+    /**
+     * Its people, when it is small (32 or fewer).
+     */
+    members?: Member[];
+    /**
+     * A direct conversation's other person.
+     */
+    peer_id: string | null;
+    /**
+     * Where the app reads a group's picture.
+     */
+    photo: string | null;
+    settings: ConversationSettings;
+    /**
+     * A group's title.
+     */
+    title: string | null;
+    /**
+     * How many times it changed.
+     */
+    version: number;
+};
+/**
+ * A conversation made, and whom it did not take.
+ */
+export type ConversationCreated = {
+    conversation: Conversation;
+    /**
+     * Whom it did not take.
+     */
+    not_added: NotAdded[];
+};
+/**
+ * messaging.conversation.created
+ */
+export type ConversationCreatedEvent = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * Who made it; null: the project's server.
+     */
+    created_by: string | null;
+    /**
+     * direct or group.
+     */
+    kind: string;
+    /**
+     * Its people.
+     */
+    member_ids: string[];
+};
+/**
+ * messaging.conversation.deleted
+ */
+export type ConversationDeletedEvent = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * Who deleted it; null: the project's server.
+     */
+    deleted_by: string | null;
+};
+export type ConversationPage = {
+    /**
+     * The conversations.
+     */
+    data: Conversation[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * How a conversation runs.
+ */
+export type ConversationSettings = {
+    /**
+     * Who adds people to it: all or admins.
+     */
+    add_policy: "all" | "admins";
+    /**
+     * Who changes its title, description, picture and timer: all or admins.
+     */
+    edit_policy: "all" | "admins";
+    /**
+     * Whether someone added reads what was said before them.
+     */
+    history_for_new_members: boolean;
+    /**
+     * Who writes in the group: all or admins.
+     */
+    send_policy: "all" | "admins";
+    /**
+     * How long a new message lives (seconds); null: for good.
+     */
+    timer_seconds: number | null;
+    /**
+     * Vanish mode (a direct conversation's): a message read goes once its reader leaves the conversation.
+     */
+    vanish: boolean;
+};
+/**
+ * Opens the direct conversation with a person.
+ */
+export type DirectRequest = {
+    /**
+     * The other person.
+     */
+    user_id: string;
+};
+/**
+ * A message's new words.
+ */
+export type EditRequest = {
+    /**
+     * Whom its words name.
+     */
+    mentions?: Mention[];
+    /**
+     * What the message says now.
+     */
+    text: string;
+};
+/**
+ * The error envelope.
+ */
+export type ErrorResponse = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Correlation ID for log/audit lookup
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying; present on a refusal that ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code (mirrors the response status)
+     */
+    status: number;
+};
+/**
+ * Where a file is read.
+ */
+export type FileURL = {
+    /**
+     * Until when.
+     */
+    expires_at: string;
+    /**
+     * Where the file (encrypted) is read.
+     */
+    url: string;
+};
+/**
+ * Makes a group.
+ */
+export type GroupRequest = {
+    /**
+     * Its description (at most 1,000 characters).
+     */
+    description?: string;
+    /**
+     * Its people besides the reader (at most 999).
+     */
+    member_ids?: string[];
+    /**
+     * Where the app reads its picture.
+     */
+    photo?: string;
+    settings?: GroupSettings;
+    /**
+     * Its title.
+     */
+    title: string;
+};
+/**
+ * How a group runs, as it is made.
+ */
+export type GroupSettings = {
+    /**
+     * Who adds people: all or admins (default).
+     */
+    add_policy?: "all" | "admins";
+    /**
+     * Who changes its details and timer: all or admins.
+     */
+    edit_policy?: "all" | "admins";
+    /**
+     * Whether someone added reads what was said before them (default true).
+     */
+    history_for_new_members?: boolean;
+    /**
+     * Who writes: all or admins.
+     */
+    send_policy?: "all" | "admins";
+    /**
+     * How long a message lives (seconds).
+     */
+    timer_seconds?: number;
+};
+/**
+ * A message the reader removed for themselves.
+ */
+export type HiddenMessage = {
+    /**
+     * Its conversation.
+     */
+    conversation_id: string;
+    /**
+     * The message.
+     */
+    message_id: string;
+};
+/**
+ * The hook asked whom one may reach.
+ */
+export type HookSettings = {
+    /**
+     * When it does not answer: allow everyone, or deny (the client retries).
+     */
+    on_error: "allow" | "deny";
+    /**
+     * How long it is waited for.
+     */
+    timeout_ms: number;
+    /**
+     * The project's endpoint.
+     */
+    url: string;
+};
+/**
+ * Sets the hook.
+ */
+export type HookSettingsRequest = {
+    /**
+     * allow or deny (default).
+     */
+    on_error?: "allow" | "deny";
+    /**
+     * 100 to 5,000 (default 2,000).
+     */
+    timeout_ms?: number;
+    /**
+     * An https URL on the public internet.
+     */
+    url: string;
+};
+/**
+ * A person in a conversation, as the others see them.
+ */
+export type Member = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * How far their apps took the conversation (a delivery receipt; a read moves read_seq alone).
+     */
+    delivered_seq: number;
+    /**
+     * When they joined.
+     */
+    joined_at: string;
+    /**
+     * When they left or were removed.
+     */
+    left_at: string | null;
+    /**
+     * How far they read; null in a direct conversation where either person turned their read receipts off (the reader's own always says it).
+     */
+    read_seq: number | null;
+    /**
+     * owner, admin or member.
+     */
+    role: "owner" | "admin" | "member";
+    /**
+     * active, left or removed.
+     */
+    state: "active" | "left" | "removed";
+    /**
+     * The person.
+     */
+    user_id: string;
+    /**
+     * How many times it changed.
+     */
+    version: number;
+};
+export type MemberPage = {
+    /**
+     * The people.
+     */
+    data: Member[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * The reader's own place in a conversation.
+ */
+export type MemberState = {
+    /**
+     * What they cleared for themselves: up to this one.
+     */
+    cleared_seq: number;
+    /**
+     * How far their apps took the conversation.
+     */
+    delivered_seq: number;
+    /**
+     * They see the messages after this one.
+     */
+    joined_seq: number;
+    /**
+     * They see the messages up to this one, once they left or were removed.
+     */
+    left_seq: number | null;
+    /**
+     * Muted until then; null: not muted.
+     */
+    muted_until: string | null;
+    /**
+     * What notifies them: every message, those naming them, none.
+     */
+    notify_level: "all" | "mentions" | "none";
+    /**
+     * How far they read.
+     */
+    read_seq: number;
+    /**
+     * owner, admin or member (a direct conversation's two are members).
+     */
+    role: "owner" | "admin" | "member";
+    /**
+     * active; left; removed (they keep what was said while they were in it).
+     */
+    state: "active" | "left" | "removed";
+    /**
+     * Messages of the conversation's own timeline they have not read (not theirs, not the platform's), counted to 1,000.
+     */
+    unread_count: number;
+    /**
+     * How many times it changed.
+     */
+    version: number;
+};
+/**
+ * Whom a group took, and whom not.
+ */
+export type MembersAdded = {
+    /**
+     * Whom the group took.
+     */
+    added: string[];
+    /**
+     * Whom it did not take.
+     */
+    not_added: NotAdded[];
+};
+/**
+ * The members a change changed.
+ */
+export type MembersChanged = {
+    /**
+     * The members whose role changed.
+     */
+    members: Member[];
+};
+/**
+ * A person a message's words name.
+ */
+export type Mention = {
+    /**
+     * How long, in UTF-16 code units.
+     */
+    length: number;
+    /**
+     * Where in the text, in UTF-16 code units.
+     */
+    offset: number;
+    /**
+     * The person named.
+     */
+    user_id: string;
+};
+/**
+ * A message as a member reads it.
+ */
+export type Message = {
+    /**
+     * A thread answer the conversation's timeline shows too.
+     */
+    also_in_conversation: boolean;
+    /**
+     * Its files.
+     */
+    attachments: Attachment[];
+    /**
+     * The writer's app's own id of it.
+     */
+    client_message_id: string | null;
+    /**
+     * Its conversation.
+     */
+    conversation_id: string;
+    /**
+     * When it was sent.
+     */
+    created_at: string;
+    /**
+     * Removed: what it said is gone.
+     */
+    deleted: boolean;
+    /**
+     * When its writer last changed it.
+     */
+    edited_at: string | null;
+    /**
+     * It goes this many seconds after everyone it was for read it.
+     */
+    expires_after_read: number | null;
+    /**
+     * When it goes.
+     */
+    expires_at: string | null;
+    /**
+     * The message.
+     */
+    id: string;
+    /**
+     * text, media (files) or system.
+     */
+    kind: "text" | "media" | "system";
+    /**
+     * When its thread was last answered.
+     */
+    last_reply_at: string | null;
+    /**
+     * Whom its words name.
+     */
+    mentions: Mention[];
+    /**
+     * Its reactions, each emoji's.
+     */
+    reactions: Reaction[];
+    /**
+     * Why it was removed: sender, admin, server, expired, viewed, vanished, retention, user_deleted.
+     */
+    removed_reason: string | null;
+    /**
+     * How many answers its thread holds.
+     */
+    reply_count: number;
+    /**
+     * The message it answers inline.
+     */
+    reply_to_id: string | null;
+    /**
+     * Its writer; null: the platform's or the project's server's.
+     */
+    sender_id: string | null;
+    /**
+     * Its place in its conversation.
+     */
+    seq: number;
+    /**
+     * What a system message tells.
+     */
+    system: SystemEvent | null;
+    /**
+     * What it says.
+     */
+    text: string | null;
+    /**
+     * The message whose thread it answers.
+     */
+    thread_id: string | null;
+    /**
+     * Sent in vanish mode: it goes once read and left.
+     */
+    vanish: boolean;
+    /**
+     * How many times it changed (a reaction, an answer in its thread, an edit).
+     */
+    version: number;
+    /**
+     * When it is seen a limited number of times.
+     */
+    view_once: ViewOnce | null;
+};
+export type MessagePage = {
+    /**
+     * The messages.
+     */
+    data: Message[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * The reader's own profile and settings.
+ */
+export type MyProfile = {
+    /**
+     * How long the messages of conversations they open from now on live; null: for good.
+     */
+    default_timer_seconds: number | null;
+    /**
+     * Where the app reads their picture.
+     */
+    image: string | null;
+    /**
+     * When they were last here.
+     */
+    last_seen_at: string | null;
+    /**
+     * Their name.
+     */
+    name: string | null;
+    /**
+     * Whether their reads show in a direct conversation; off, nor do the other's to them. A group's always show.
+     */
+    read_receipts: boolean;
+    /**
+     * Whether others see when they were last here (they see others' only then).
+     */
+    show_last_seen: boolean;
+    /**
+     * The reader.
+     */
+    user_id: string;
+};
+/**
+ * A person a group did not take, and why.
+ */
+export type NotAdded = {
+    /**
+     * not_allowed (the project's hook did not let them be reached, or they block whoever added them) or group_full.
+     */
+    reason: "not_allowed" | "group_full";
+    /**
+     * The person.
+     */
+    user_id: string;
+};
+/**
+ * How a conversation notifies the reader; what it names changes.
+ */
+export type NotificationsRequest = {
+    /**
+     * Muted until then; null: unmuted.
+     */
+    muted_until?: string | null;
+    /**
+     * What notifies the reader.
+     */
+    notify_level?: "all" | "mentions" | "none";
+};
+/**
+ * A person as the conversations show them.
+ */
+export type Profile = {
+    /**
+     * Where the app reads their picture.
+     */
+    image: string | null;
+    /**
+     * When they were last here (the same).
+     */
+    last_seen_at: string | null;
+    /**
+     * Their name.
+     */
+    name: string | null;
+    /**
+     * Here now (when they let others see it, and the reader does).
+     */
+    online: boolean;
+    /**
+     * The person.
+     */
+    user_id: string;
+};
+/**
+ * People's profiles.
+ */
+export type ProfileList = {
+    /**
+     * The profiles there are.
+     */
+    data: Profile[];
+};
+/**
+ * How a reaction is added.
+ */
+export type ReactRequest = {
+    /**
+     * The reader's other reactions to the message go: one a person (WhatsApp's).
+     */
+    replace?: boolean;
+};
+/**
+ * One emoji's reactions to a message (a person gives several, one of each emoji).
+ */
+export type Reaction = {
+    /**
+     * How many gave it.
+     */
+    count: number;
+    /**
+     * The reaction.
+     */
+    emoji: string;
+    /**
+     * Whether the reader gave it.
+     */
+    me: boolean;
+    /**
+     * Who gave it (the first 32).
+     */
+    user_ids: string[];
+};
+/**
+ * Who of a conversation read a message, and whose apps took it.
+ */
+export type Readers = {
+    /**
+     * Whose apps took it.
+     */
+    delivered: string[];
+    /**
+     * Who read it.
+     */
+    read: string[];
+};
+/**
+ * How far the reader read a conversation or thread, and how far their app took it.
+ */
+export type Receipt = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * How far their app took it.
+     */
+    delivered_seq?: number;
+    /**
+     * How far the reader read.
+     */
+    read_seq?: number;
+    /**
+     * A thread of it the reader follows.
+     */
+    thread_id?: string;
+};
+/**
+ * The reader's receipts.
+ */
+export type ReceiptsRequest = {
+    /**
+     * 1 to 100 receipts.
+     */
+    receipts: Receipt[];
+};
+/**
+ * A conversation the reader no longer has.
+ */
+export type RemovedConversation = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * Why: deleted.
+     */
+    reason: string;
+};
+/**
+ * A report as the project's server reads it.
+ */
+export type Report = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * When it was made.
+     */
+    created_at: string;
+    /**
+     * The report.
+     */
+    id: string;
+    /**
+     * The messages it names.
+     */
+    message_ids: string[];
+    /**
+     * What the messages said (read one report to get them).
+     */
+    messages?: ReportedMessage[];
+    /**
+     * The reporter's words (read one report to get them).
+     */
+    note?: string;
+    /**
+     * Why.
+     */
+    reason: string;
+    /**
+     * Whom.
+     */
+    reported_user_id: string | null;
+    /**
+     * Who reported (null once they were deleted).
+     */
+    reporter_id: string | null;
+    /**
+     * What came of it.
+     */
+    resolution: string | null;
+    /**
+     * When it was resolved.
+     */
+    resolved_at: string | null;
+    /**
+     * open or resolved.
+     */
+    status: "open" | "resolved";
+};
+/**
+ * A report made.
+ */
+export type ReportCreated = {
+    /**
+     * When.
+     */
+    created_at: string;
+    /**
+     * The report.
+     */
+    id: string;
+    /**
+     * open.
+     */
+    status: string;
+};
+/**
+ * messaging.report.created
+ */
+export type ReportCreatedEvent = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * How many messages it names.
+     */
+    message_count: number;
+    /**
+     * Why.
+     */
+    reason: string;
+    /**
+     * The report: read it with the secret key (GET /messaging/admin/reports/{report_id}).
+     */
+    report_id: string;
+    /**
+     * Whom.
+     */
+    reported_user_id: string | null;
+    /**
+     * Who reported.
+     */
+    reporter_id: string;
+};
+export type ReportPage = {
+    /**
+     * The reports.
+     */
+    data: Report[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * Reports a conversation, a person in it, or messages of it.
+ */
+export type ReportRequest = {
+    /**
+     * The conversation.
+     */
+    conversation_id: string;
+    /**
+     * Messages the reader sees in it (at most 50).
+     */
+    message_ids?: string[];
+    /**
+     * The reader's own words (at most 1,000 characters).
+     */
+    note?: string;
+    /**
+     * Why.
+     */
+    reason: "spam" | "harassment" | "hate" | "violence" | "sexual" | "self_harm" | "illegal" | "other";
+    /**
+     * The person reported.
+     */
+    user_id?: string;
+};
+/**
+ * A reported message as it was when reported.
+ */
+export type ReportedMessage = {
+    /**
+     * Its files, with their keys.
+     */
+    attachments: Attachment[];
+    /**
+     * When it was sent.
+     */
+    created_at: string;
+    /**
+     * The message.
+     */
+    id: string;
+    /**
+     * text, media or system.
+     */
+    kind: string;
+    /**
+     * Its writer.
+     */
+    sender_id: string | null;
+    /**
+     * Its place.
+     */
+    seq: number;
+    /**
+     * What it said when reported.
+     */
+    text: string | null;
+};
+/**
+ * Resolves a report.
+ */
+export type ResolveRequest = {
+    /**
+     * What came of it (1 to 64 characters).
+     */
+    resolution: string;
+};
+/**
+ * A message its writer scheduled; request is what it will say, while it is still to be sent.
+ */
+export type ScheduledMessage = {
+    /**
+     * The app's own id of it.
+     */
+    client_message_id: string;
+    /**
+     * Its conversation.
+     */
+    conversation_id: string;
+    /**
+     * When it was scheduled.
+     */
+    created_at: string;
+    /**
+     * Why it was not sent (failed): not_a_member, conversation_deleted, blocked, admins_only…
+     */
+    failure: string | null;
+    /**
+     * The scheduled message.
+     */
+    id: string;
+    /**
+     * The message it became (sent).
+     */
+    message_id: string | null;
+    request?: SendRequest;
+    /**
+     * When it goes.
+     */
+    send_at: string;
+    /**
+     * scheduled, sent, cancelled or failed.
+     */
+    state: "scheduled" | "sent" | "cancelled" | "failed";
+    /**
+     * When it last changed.
+     */
+    updated_at: string;
+    /**
+     * How many times it changed.
+     */
+    version: number;
+};
+export type ScheduledPage = {
+    /**
+     * The scheduled messages.
+     */
+    data: ScheduledMessage[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * A message to send.
+ */
+export type SendRequest = {
+    /**
+     * A thread answer the conversation's timeline shows too.
+     */
+    also_in_conversation?: boolean;
+    /**
+     * Its files (at most 10).
+     */
+    attachments?: AttachmentRequest[];
+    /**
+     * The app's own id of the message: sent again with it, it is the same message.
+     */
+    client_message_id: string;
+    /**
+     * When its time starts: send (default) or read — once everyone it is for read it.
+     */
+    expires_from?: "send" | "read";
+    /**
+     * It goes this many seconds after it is sent (or read: expires_from).
+     */
+    expires_in?: number;
+    /**
+     * Whom its words name (at most 50).
+     */
+    mentions?: Mention[];
+    /**
+     * A message it answers inline.
+     */
+    reply_to_id?: string;
+    /**
+     * Send it then (words only): it is scheduled.
+     */
+    send_at?: string;
+    /**
+     * What it says (1 to 4,096 characters).
+     */
+    text?: string;
+    /**
+     * A message whose thread it answers (one level).
+     */
+    thread_id?: string;
+    view_once?: ViewOnceRequest;
+};
+/**
+ * How the project runs its conversations.
+ */
+export type Settings = {
+    /**
+     * A deleted user's messages: keep (their writer anonymous) or delete.
+     */
+    deleted_user_messages: "keep" | "delete";
+    /**
+     * The hook asked whom one may reach; null: anyone may reach anyone.
+     */
+    hook: HookSettings | null;
+    /**
+     * The hook's signing secret, given once: as the hook is set, and as it is made anew.
+     */
+    hook_secret?: string;
+    /**
+     * Pushes say what a message says (false: that one came).
+     */
+    push_preview: boolean;
+    /**
+     * Messages older are removed; null: kept for good.
+     */
+    retention_days: number | null;
+};
+/**
+ * Changes how the project runs its conversations; what it names changes.
+ */
+export type SettingsRequest = {
+    /**
+     * keep or delete.
+     */
+    deleted_user_messages?: "keep" | "delete";
+    /**
+     * The hook; null removes it.
+     */
+    hook?: HookSettingsRequest | null;
+    /**
+     * Pushes say what a message says.
+     */
+    push_preview?: boolean;
+    /**
+     * 1 to 36,500; null: for good.
+     */
+    retention_days?: number | null;
+};
+/**
+ * What changed for the reader since their cursor.
+ */
+export type SyncPage = {
+    /**
+     * The reader's conversations that changed, with their own place in each.
+     */
+    conversations: Conversation[];
+    /**
+     * What to ask the next sync with (since).
+     */
+    cursor: string;
+    /**
+     * The messages the reader removed for themselves.
+     */
+    hidden: HiddenMessage[];
+    /**
+     * The people of the reader's small conversations who changed (reads, roles, comings and goings).
+     */
+    members: Member[];
+    /**
+     * The messages written, changed or removed, the reader sees.
+     */
+    messages: Message[];
+    /**
+     * The conversations the reader no longer has.
+     */
+    removed_conversations: RemovedConversation[];
+    /**
+     * Everything to start from: the reader drops what it kept and keeps this (its conversations without their messages).
+     */
+    reset: boolean;
+    /**
+     * The reader's scheduled messages that changed.
+     */
+    scheduled: ScheduledMessage[];
+    /**
+     * The threads the reader follows that changed.
+     */
+    threads: ThreadState[];
+};
+/**
+ * What a message of the platform's tells: a change to its conversation.
+ */
+export type SystemEvent = {
+    /**
+     * Who did it; null: the project's server.
+     */
+    actor_id: string | null;
+    /**
+     * A role it gave.
+     */
+    role?: string;
+    /**
+     * A timer it set.
+     */
+    timer_seconds?: number;
+    /**
+     * A title it set.
+     */
+    title?: string;
+    /**
+     * What happened: created, members_added, member_left, member_removed, role_changed, title_changed, description_changed, photo_changed, timer_changed, vanish_on, vanish_off, settings_changed, screenshot.
+     */
+    type: string;
+    /**
+     * Whom it was done to.
+     */
+    user_ids?: string[];
+};
+/**
+ * A thread the reader follows, with the message it answers.
+ */
+export type ThreadItem = {
+    root: Message;
+    thread: ThreadState;
+};
+export type ThreadPage = {
+    /**
+     * The threads.
+     */
+    data: ThreadItem[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * The reader's place in a thread they follow.
+ */
+export type ThreadState = {
+    /**
+     * Its conversation.
+     */
+    conversation_id: string;
+    /**
+     * When it was last answered.
+     */
+    last_reply_at: string | null;
+    /**
+     * How far the reader read it.
+     */
+    read_seq: number;
+    /**
+     * The message the thread answers.
+     */
+    thread_id: string;
+    /**
+     * Its answers the reader has not read.
+     */
+    unread_count: number;
+    /**
+     * How many times it changed.
+     */
+    version: number;
+};
+/**
+ * The reader is typing.
+ */
+export type TypingRequest = {
+    /**
+     * The thread they type in.
+     */
+    thread_id?: string;
+};
+/**
+ * Changes a conversation's details and how it runs; what it names changes.
+ */
+export type UpdateConversation = {
+    /**
+     * Who adds people (admins change it).
+     */
+    add_policy?: "all" | "admins";
+    /**
+     * A group's description; null clears it.
+     */
+    description?: string | null;
+    /**
+     * Who changes details and timer (admins change it).
+     */
+    edit_policy?: "all" | "admins";
+    /**
+     * Whether someone added reads what was said before them (admins change it).
+     */
+    history_for_new_members?: boolean;
+    /**
+     * Where the app reads a group's picture; null clears it.
+     */
+    photo?: string | null;
+    /**
+     * Who writes: all or admins (admins change it).
+     */
+    send_policy?: "all" | "admins";
+    /**
+     * How long a new message lives; null: for good.
+     */
+    timer_seconds?: number | null;
+    /**
+     * A group's title.
+     */
+    title?: string | null;
+    /**
+     * A direct conversation's vanish mode.
+     */
+    vanish?: boolean;
+};
+/**
+ * Changes a member's role.
+ */
+export type UpdateMemberRequest = {
+    /**
+     * owner (the owner hands the group over), admin or member.
+     */
+    role: "owner" | "admin" | "member";
+};
+/**
+ * Changes a profile; what it names changes.
+ */
+export type UpdateProfile = {
+    /**
+     * How long the messages of conversations they open from now on live.
+     */
+    default_timer_seconds?: number | null;
+    /**
+     * Where the app reads the picture.
+     */
+    image?: string | null;
+    /**
+     * A name (1 to 100 characters).
+     */
+    name?: string | null;
+    /**
+     * Whether their reads show in a direct conversation (off: nor do the other's to them).
+     */
+    read_receipts?: boolean;
+    /**
+     * Whether others see when they were last here.
+     */
+    show_last_seen?: boolean;
+};
+/**
+ * Changes a message still to be sent.
+ */
+export type UpdateScheduled = {
+    /**
+     * Whom its words name.
+     */
+    mentions?: Mention[];
+    /**
+     * When it goes.
+     */
+    send_at?: string;
+    /**
+     * What it will say.
+     */
+    text?: string;
+};
+/**
+ * Where a file is uploaded.
+ */
+export type Upload = {
+    /**
+     * Until when the URL takes it.
+     */
+    expires_at: string;
+    /**
+     * The upload: a message carries it by this id.
+     */
+    id: string;
+    /**
+     * The size it takes.
+     */
+    size: number;
+    /**
+     * Where the app PUTs the file (encrypted).
+     */
+    url: string;
+};
+/**
+ * Asks for a URL to upload one file to.
+ */
+export type UploadRequest = {
+    /**
+     * The file's size (encrypted), 1 byte to 100 MiB.
+     */
+    size: number;
+};
+/**
+ * How a message seen a limited number of times stands for the reader.
+ */
+export type ViewOnce = {
+    /**
+     * How many times each may open it: 1, or 2 (once more).
+     */
+    limit: number;
+    /**
+     * Who opened it (its writer reads this).
+     */
+    opened_by?: string[];
+    /**
+     * How long the app shows it each time (the app's to keep).
+     */
+    seconds: number | null;
+    /**
+     * How many times the reader opened it.
+     */
+    views: number;
+};
+/**
+ * Makes a message's files seen a limited number of times.
+ */
+export type ViewOnceRequest = {
+    /**
+     * How many times each may open it: 1, or 2 (once more).
+     */
+    limit: number;
+    /**
+     * How long the app shows it each time.
+     */
+    seconds?: number;
+};
+/**
+ * A message seen once, opened.
+ */
+export type Viewed = {
+    /**
+     * Its files.
+     */
+    attachments: ViewedFile[];
+    /**
+     * How many times they may.
+     */
+    limit: number;
+    /**
+     * How long the app shows it.
+     */
+    seconds: number | null;
+    /**
+     * How many times the reader opened it, this one counted.
+     */
+    views: number;
+};
+/**
+ * One file of a message seen once, as its opening gives it.
+ */
+export type ViewedFile = {
+    /**
+     * Its type.
+     */
+    content_type: string;
+    /**
+     * Until when.
+     */
+    expires_at: string;
+    /**
+     * The key that opens it.
+     */
+    file_key: string;
+    /**
+     * The file.
+     */
+    id: string;
+    /**
+     * Its size.
+     */
+    size: number;
+    /**
+     * Its preview.
+     */
+    thumbnail: string | null;
+    /**
+     * Where it is read.
+     */
+    url: string;
+};
+/** The events this module sends the project's webhooks (x-palbase-events), by type: each one's payload, the event's data. */
+export interface Events {
+    /**
+     * messaging.conversation.created: a conversation was made — by a person, or the project's server.
+     */
+    "messaging.conversation.created": ConversationCreatedEvent;
+    /**
+     * messaging.conversation.deleted: a conversation was deleted for everyone.
+     */
+    "messaging.conversation.deleted": ConversationDeletedEvent;
+    /**
+     * messaging.report.created: a person reported a conversation, someone in it or messages of it; read it with the secret key.
+     */
+    "messaging.report.created": ReportCreatedEvent;
+}
+/** Palbase Messaging */
+export declare function client(t: Transport): {
+    /**
+     * When the project's server read people's messages
+     *
+     * Every time the project's server read or removed people's messages, the newest first (kept 400 days).
+     */
+    adminAccessLog(input?: {
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, AccessLogPage>>;
+    /**
+     * The project's conversations
+     *
+     * The project's conversations (a person's, when `user_id` names one), the latest first.
+     */
+    adminListConversations(input?: {
+        query?: {
+            user_id?: string; /** How many (1 to 100; 30 when absent). */
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ConversationPage>>;
+    /**
+     * Make a conversation for people
+     *
+     * The project's server makes a conversation for people — the direct one between two (the one there is, 200, when there is), or a group it may give an owner (`owner_id`) or keep its own. The project's hook is not asked: the server decides.
+     */
+    adminCreateConversation(input: {
+        body: AdminConversationRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ConversationCreated> | Reply<201, ConversationCreated>>;
+    /**
+     * A conversation with its people
+     *
+     * A conversation of the project's, with its people.
+     */
+    adminGetConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Conversation>>;
+    /**
+     * Delete a conversation
+     *
+     * The conversation goes for everyone, its messages, files and keys with it. In the access log.
+     */
+    adminDeleteConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Add people to a group
+     *
+     * The project's server adds people to a group (no hook asked).
+     */
+    adminAddMembers(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: AddMembersRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MembersAdded>>;
+    /**
+     * Take a person out of a group
+     *
+     * The project's server takes a person out of a group.
+     */
+    adminRemoveMember(input: {
+        path: {
+            conversation_id: string; /** The member. */
+            user_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * What a conversation said
+     *
+     * What the conversation said, the newest first — every read in the access log.
+     */
+    adminListMessages(input: {
+        path: {
+            conversation_id: string;
+        };
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MessagePage>>;
+    /**
+     * Say something in a conversation
+     *
+     * The project's server says something in a conversation, as the app. Sent again with the same `client_message_id`, it is the same message.
+     */
+    adminSendMessage(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: AdminMessageRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message> | Reply<201, Message>>;
+    /**
+     * Remove a message
+     *
+     * What a message said goes, for everyone. In the access log.
+     */
+    adminDeleteMessage(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * A person's name and picture
+     *
+     * The project's server names a person and gives their picture, as its own records say.
+     */
+    adminPutProfile(input: {
+        path: {
+            user_id: string;
+        };
+        body: AdminProfileRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Profile>>;
+    /**
+     * The reports people made
+     *
+     * The reports the project's people made, the newest first (without what they carry: read one to get it).
+     */
+    adminListReports(input?: {
+        query?: {
+            status?: "open" | "resolved"; /** How many (1 to 100; 30 when absent). */
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ReportPage>>;
+    /**
+     * One report, with what it carries
+     *
+     * A report with its reporter's note and what the messages it names said when reported (their files with the keys that open them). In the access log.
+     */
+    adminGetReport(input: {
+        path: {
+            report_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Report>>;
+    /**
+     * Resolve a report
+     *
+     * The report is dealt with, and how (the project's own word).
+     */
+    adminResolveReport(input: {
+        path: {
+            report_id: string;
+        };
+        body: ResolveRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Report>>;
+    /**
+     * The people the reader blocks
+     *
+     * The people the reader blocks.
+     */
+    listBlocks(input?: {
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, BlockPage>>;
+    /**
+     * Block a person
+     *
+     * The reader blocks a person: their direct messages never reach the reader (they are not told), and they open no conversation with them and add them to no group.
+     */
+    block(input: {
+        path: {
+            user_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Block>>;
+    /**
+     * Unblock a person
+     *
+     * The reader no longer blocks a person. What they sent while blocked stays unseen.
+     */
+    unblock(input: {
+        path: {
+            user_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * The reader's conversations
+     *
+     * The signed-in person's conversations, the latest first, with their own place in each, what they have not read and the last message each shows. A direct conversation someone else opened shows once something is said in it; one they cleared, once something new is.
+     */
+    listConversations(input?: {
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ConversationPage>>;
+    /**
+     * The direct conversation with a person
+     *
+     * The one conversation between the reader and another person: made the first time — when the project's hook lets them reach them — and the same one every time after (200). The other sees it once something is said in it.
+     */
+    openDirectConversation(input: {
+        body: DirectRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Conversation> | Reply<201, Conversation>>;
+    /**
+     * Make a group
+     *
+     * A group the reader owns, with the people the project's hook lets them reach and who do not block them (`not_added` says whom else, and why). An Idempotency-Key makes it once.
+     */
+    createGroup(input: {
+        headers?: {
+            "Idempotency-Key"?: string;
+        };
+        body: GroupRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, ConversationCreated>>;
+    /**
+     * One of the reader's conversations
+     *
+     * One of the reader's conversations, with their own place in it, and its people when it is small (a larger one's are paged: …/members).
+     */
+    getConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Conversation>>;
+    /**
+     * Delete a group for everyone
+     *
+     * A group's owner or admin deletes it for everyone: its messages, its files and its keys go. A direct conversation is cleared, not deleted (…/clear).
+     */
+    deleteConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change a conversation
+     *
+     * A group's title, description and picture and its timer (whom its edit policy lets), its policies (its admins); a direct conversation's timer and vanish mode (either of the two). Each change is told in the conversation, as a message of the platform's. Leaving vanish mode takes with it what was read in it.
+     */
+    updateConversation(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: UpdateConversation; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Conversation>>;
+    /**
+     * Clear a conversation for oneself
+     *
+     * The reader removes what the conversation said, for themselves; it leaves their list until something new is said.
+     */
+    clearConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MemberState>>;
+    /**
+     * The reader left the conversation's screen
+     *
+     * The reader's app says they left the conversation's screen. In vanish mode, what the other sent that they read goes.
+     */
+    closeConversation(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * A conversation's people
+     *
+     * The conversation's people, a page at a time (by id).
+     */
+    listMembers(input: {
+        path: {
+            conversation_id: string;
+        };
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MemberPage>>;
+    /**
+     * Add people to a group
+     *
+     * The reader adds people to a group — when its add policy lets them, the project's hook lets them reach them and they do not block the reader. Someone who left is let back in.
+     */
+    addMembers(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: AddMembersRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MembersAdded>>;
+    /**
+     * Leave a group, or remove someone
+     *
+     * The reader leaves a group (their own id), or its admins remove another (never the owner). An owner who leaves hands the group to an admin, or to whoever was in it longest; a group left by everyone is deleted. They keep what it said while they were in it.
+     */
+    removeMember(input: {
+        path: {
+            conversation_id: string; /** The member. */
+            user_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change a member's role
+     *
+     * A group's admins make a member an admin, or a member again; its owner hands the group to another (becoming an admin).
+     */
+    updateMember(input: {
+        path: {
+            conversation_id: string; /** The member. */
+            user_id: string;
+        };
+        body: UpdateMemberRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MembersChanged>>;
+    /**
+     * A conversation's messages
+     *
+     * The conversation's own timeline as the reader sees it, the newest first, a page at a time; a message removed is there, said removed.
+     */
+    listMessages(input: {
+        path: {
+            conversation_id: string;
+        };
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MessagePage>>;
+    /**
+     * Send a message
+     *
+     * The reader says something in the conversation — words, files (uploaded first), an answer to a message or in its thread, for a while (`expires_in`) or to be seen a limited number of times (`view_once`) — now (201), or at `send_at` (202, a scheduled message). Sent again with the same `client_message_id`, it is the same message (200), never a second. A direct message to someone who blocks the reader never reaches them.
+     */
+    sendMessage(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: SendRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message> | Reply<201, Message> | Reply<202, ScheduledMessage>>;
+    /**
+     * One message
+     *
+     * One message the reader sees.
+     */
+    getMessage(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message>>;
+    /**
+     * Remove a message
+     *
+     * `for=everyone` (the default): its writer removes a message for everyone within 48 hours (a group's admins at any time). `for=me`: anyone removes it for themselves.
+     */
+    deleteMessage(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        };
+        query?: {
+            for?: "everyone" | "me";
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message> | Reply<204, undefined>>;
+    /**
+     * Change a message
+     *
+     * Its writer changes what a message says, within 15 minutes of sending it; its files stay.
+     */
+    editMessage(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        };
+        body: EditRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message>>;
+    /**
+     * Where a message's file is read
+     *
+     * A URL reading one of a message's files (encrypted: its key is in the message). A message seen once gives its files by …/view alone.
+     */
+    attachmentUrl(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string; /** The file. */
+            attachment_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, FileURL>>;
+    /**
+     * React to a message
+     *
+     * The reader reacts to a message with an emoji, beside their other reactions to it (Slack's); with `replace`, in their place (one a person, WhatsApp's). Again with the same emoji, nothing more. A person gives one message 20 emoji at most.
+     */
+    react(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string; /** The emoji, percent-encoded in the path. */
+            emoji: string;
+        };
+        body?: ReactRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message>>;
+    /**
+     * Take a reaction back
+     *
+     * The reader takes back their reaction with the emoji.
+     */
+    unreact(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string; /** The emoji, percent-encoded in the path. */
+            emoji: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Message>>;
+    /**
+     * Who read a message
+     *
+     * Who of the conversation read the message, and whose apps took it (its writer aside).
+     */
+    messageReaders(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Readers>>;
+    /**
+     * A thread's answers
+     *
+     * The answers in a message's thread, the oldest first, a page at a time.
+     */
+    listReplies(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        };
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MessagePage>>;
+    /**
+     * Open a message seen once
+     *
+     * The reader opens a message seen a limited number of times: its files and the keys that open them, once (or twice when it allows once more). Once everyone it was for opened it as often as it allows, what it carried goes.
+     */
+    viewOnce(input: {
+        path: {
+            conversation_id: string; /** The message. */
+            message_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Viewed>>;
+    /**
+     * How a conversation notifies the reader
+     *
+     * Mutes the conversation until a time (null: unmuted), and says what notifies the reader of it — every message, those that name them, none.
+     */
+    setConversationNotifications(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: NotificationsRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MemberState>>;
+    /**
+     * The reader took a screenshot
+     *
+     * The reader's app saw them take a picture of the conversation's screen: the others are told, in the conversation, as a message of the platform's.
+     */
+    reportScreenshot(input: {
+        path: {
+            conversation_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Message>>;
+    /**
+     * The reader is typing
+     *
+     * The conversation's other people hear the reader is typing (in a thread, when it names one), for a few seconds, on their realtime channels. Nothing is kept.
+     */
+    typing(input: {
+        path: {
+            conversation_id: string;
+        };
+        body?: TypingRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * A URL to upload a file to
+     *
+     * A URL the reader's app uploads one file to — encrypted with a key of its own, which the message carries — before a message carries it. The file is the project's: counted under its storage. One no message carries within a day is removed.
+     */
+    createUpload(input: {
+        path: {
+            conversation_id: string;
+        };
+        body: UploadRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Upload>>;
+    /**
+     * The reader's own profile
+     *
+     * The reader's own profile and settings.
+     */
+    getMyProfile(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MyProfile>>;
+    /**
+     * Change the reader's own profile
+     *
+     * The reader's name and picture, whether others see when they were last here, and how long the messages of the conversations they open from now on live (null: for good).
+     */
+    updateMyProfile(input: {
+        body: UpdateProfile; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MyProfile>>;
+    /**
+     * The reader is here
+     *
+     * The reader's app says they are here (every half minute while it is open); they show online a while after.
+     */
+    presence(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * People's profiles
+     *
+     * People as the conversations show them — their name and picture, and whether they are here, when they let others see it and the reader lets others see theirs.
+     */
+    getProfiles(input: {
+        query: {
+            user_ids: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ProfileList>>;
+    /**
+     * How far the reader read
+     *
+     * How far the reader read conversations and threads, and how far their app took them. A read moves forward only. A message meant to go once read goes its time after everyone it was for read it. A small conversation's people hear it as it happens.
+     */
+    receipts(input: {
+        body: ReceiptsRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Report a conversation, a person or messages
+     *
+     * The reader reports a conversation, someone in it or messages they see in it, saying why. What the messages say is kept with the report, sealed — it outlives them — and the project's backend is told (`messaging.report.created`) to read it with its secret key.
+     */
+    report(input: {
+        body: ReportRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, ReportCreated>>;
+    /**
+     * The reader's scheduled messages
+     *
+     * The reader's messages still to be sent, the soonest first.
+     */
+    listScheduled(input?: {
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ScheduledPage>>;
+    /**
+     * Take a scheduled message back
+     *
+     * The reader takes a message still to be sent back; it never goes.
+     */
+    cancelScheduled(input: {
+        path: {
+            scheduled_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change a scheduled message
+     *
+     * What a message still to be sent says, or when it goes.
+     */
+    updateScheduled(input: {
+        path: {
+            scheduled_id: string;
+        };
+        body: UpdateScheduled; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ScheduledMessage>>;
+    /**
+     * How the project runs its conversations
+     *
+     * How long messages are kept, whether pushes say what a message says, what becomes of a deleted user's messages, and the hook asked whom one may reach.
+     */
+    getSettings(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Settings>>;
+    /**
+     * Change how the project runs its conversations
+     *
+     * What it names changes: how long messages are kept (null: for good), whether pushes say what a message says, what becomes of a deleted user's messages, and the hook asked whom one may reach (null: none). The hook is POSTed `{event: "messaging.can_message", action: "direct" | "group_add", from_user_id, to_user_ids, conversation_id}`, signed as Standard Webhooks sign (webhook-id, webhook-timestamp, webhook-signature), and answers 200 `{allowed_user_ids: [...]}`. A hook set for the first time is given its signing secret, here, once.
+     */
+    putSettings(input: {
+        body: SettingsRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Settings>>;
+    /**
+     * Make the hook's secret anew
+     *
+     * The hook's signing secret made anew, given here once; the old one signs nothing more.
+     */
+    rotateHookSecret(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Settings>>;
+    /**
+     * What changed for the reader
+     *
+     * What changed for the signed-in person since `since` (the `cursor` the last sync handed out): their conversations with their own place in each and what they have not read, the people of the small ones, the messages written, changed or removed, what they removed for themselves, the threads they follow, the messages they scheduled. Nothing is missed; a change may come twice — each says its `version`. With no `since`, or one older than 30 days, it is everything to start from (`reset`): the conversations without their messages, read a page at a time.
+     */
+    sync(input?: {
+        query?: {
+            since?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, SyncPage>>;
+    /**
+     * The threads the reader follows
+     *
+     * The threads the reader follows — the ones they answered in, started, or were named in — the last answered first, each with the message it answers and what they have not read of it.
+     */
+    listThreads(input?: {
+        query?: {
+            limit?: number; /** The cursor a page handed out (next_cursor). */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ThreadPage>>;
+};
+export type Client = ReturnType<typeof client>;