## API Report File for "iceshrimp-sdk"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { EventEmitter } from 'eventemitter3';

// @public (undocumented)
export type Acct = {
    username: string;
    host: string | null;
};

// @public (undocumented)
type Announcement = {
    id: ID;
    createdAt: DateString;
    updatedAt: DateString | null;
    text: string;
    title: string;
    imageUrl: string | null;
    isRead?: boolean;
};

// @public (undocumented)
type Antenna = {
    id: ID;
    createdAt: DateString;
    name: string;
    keywords: string[][];
    excludeKeywords: string[][];
    src: "home" | "all" | "users" | "list" | "group" | "instances";
    userListId: ID | null;
    userGroupId: ID | null;
    users: string[];
    instances: string[];
    caseSensitive: boolean;
    notify: boolean;
    withReplies: boolean;
    withFile: boolean;
    hasUnreadNote: boolean;
};

declare namespace api {
    export {
        isAPIError,
        APIError,
        FetchLike,
        APIClient
    }
}
export { api }

// @public (undocumented)
class APIClient {
    constructor(opts: {
        origin: APIClient["origin"];
        credential?: APIClient["credential"];
        fetch?: APIClient["fetch"] | null | undefined;
    });
    // (undocumented)
    credential: string | null | undefined;
    // (undocumented)
    fetch: FetchLike;
    // (undocumented)
    origin: string;
    // Warning: (ae-forgotten-export) The symbol "IsCaseMatched" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "GetCaseResult" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    request<E extends keyof Endpoints, P extends Endpoints[E]["req"]>(endpoint: E, params?: P, credential?: string | null | undefined): Promise<Endpoints[E]["res"] extends {
        $switch: {
            $cases: [any, any][];
            $default: any;
        };
    } ? IsCaseMatched<E, P, 0> extends true ? GetCaseResult<E, P, 0> : IsCaseMatched<E, P, 1> extends true ? GetCaseResult<E, P, 1> : IsCaseMatched<E, P, 2> extends true ? GetCaseResult<E, P, 2> : IsCaseMatched<E, P, 3> extends true ? GetCaseResult<E, P, 3> : IsCaseMatched<E, P, 4> extends true ? GetCaseResult<E, P, 4> : IsCaseMatched<E, P, 5> extends true ? GetCaseResult<E, P, 5> : IsCaseMatched<E, P, 6> extends true ? GetCaseResult<E, P, 6> : IsCaseMatched<E, P, 7> extends true ? GetCaseResult<E, P, 7> : IsCaseMatched<E, P, 8> extends true ? GetCaseResult<E, P, 8> : IsCaseMatched<E, P, 9> extends true ? GetCaseResult<E, P, 9> : Endpoints[E]["res"]["$switch"]["$default"] : Endpoints[E]["res"]>;
}

// @public (undocumented)
type APIError = {
    id: string;
    code: string;
    message: string;
    kind: "client" | "server";
    info: Record<string, any>;
};

// Warning: (ae-forgotten-export) The symbol "TODO_2" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
type App = TODO_2;

// @public (undocumented)
type AuthSession = {
    id: ID;
    app: App;
    token: string;
};

// @public (undocumented)
type Blocking = {
    id: ID;
    createdAt: DateString;
    blockeeId: User["id"];
    blockee: UserDetailed;
};

// @public (undocumented)
type Channel = {
    id: ID;
};

// Warning: (ae-forgotten-export) The symbol "AnyOf" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export abstract class ChannelConnection<Channel extends AnyOf<Channels> = any> extends EventEmitter<Channel["events"]> {
    constructor(stream: Stream, channel: string, name?: string);
    // (undocumented)
    channel: string;
    // (undocumented)
    abstract dispose(): void;
    // (undocumented)
    abstract id: string;
    // (undocumented)
    inCount: number;
    // (undocumented)
    name?: string;
    // (undocumented)
    outCount: number;
    // (undocumented)
    send<T extends keyof Channel["receives"]>(type: T, body: Channel["receives"][T]): void;
    // (undocumented)
    protected stream: Stream;
}

// @public (undocumented)
export type Channels = {
    main: {
        params: null;
        events: {
            notification: (payload: Notification_2) => void;
            mention: (payload: Note) => void;
            reply: (payload: Note) => void;
            renote: (payload: Note) => void;
            follow: (payload: User) => void;
            followed: (payload: User) => void;
            unfollow: (payload: User) => void;
            meUpdated: (payload: MeDetailed) => void;
            pageEvent: (payload: PageEvent) => void;
            urlUploadFinished: (payload: {
                marker: string;
                file: DriveFile;
            }) => void;
            readAllNotifications: () => void;
            unreadNotification: (payload: Notification_2) => void;
            unreadMention: (payload: Note["id"]) => void;
            readAllUnreadMentions: () => void;
            unreadSpecifiedNote: (payload: Note["id"]) => void;
            readAllUnreadSpecifiedNotes: () => void;
            readAllMessagingMessages: () => void;
            messagingMessage: (payload: MessagingMessage) => void;
            unreadMessagingMessage: (payload: MessagingMessage) => void;
            readAllAntennas: () => void;
            unreadAntenna: (payload: Antenna) => void;
            readAllAnnouncements: () => void;
            readAllChannels: () => void;
            unreadChannel: (payload: Note["id"]) => void;
            myTokenRegenerated: () => void;
            reversiNoInvites: () => void;
            reversiInvited: (payload: FIXME) => void;
            signin: (payload: FIXME) => void;
            registryUpdated: (payload: {
                scope?: string[];
                key: string;
                value: any | null;
            }) => void;
            driveFileCreated: (payload: DriveFile) => void;
            readAntenna: (payload: Antenna) => void;
        };
        receives: null;
    };
    homeTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    localTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    hybridTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    recommendedTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    globalTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    antenna: {
        params: {
            antennaId: Antenna["id"];
        };
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    messaging: {
        params: {
            otherparty?: User["id"] | null;
            group?: UserGroup["id"] | null;
        };
        events: {
            message: (payload: MessagingMessage) => void;
            deleted: (payload: MessagingMessage["id"]) => void;
            read: (payload: MessagingMessage["id"][]) => void;
            typers: (payload: User[]) => void;
        };
        receives: {
            read: {
                id: MessagingMessage["id"];
            };
        };
    };
    serverStats: {
        params: null;
        events: {
            stats: (payload: FIXME) => void;
        };
        receives: {
            requestLog: {
                id: string | number;
                length: number;
            };
        };
    };
    queueStats: {
        params: null;
        events: {
            stats: (payload: FIXME) => void;
        };
        receives: {
            requestLog: {
                id: string | number;
                length: number;
            };
        };
    };
};

// @public (undocumented)
type Clip = TODO_2;

// @public (undocumented)
type CustomEmoji = {
    id: string;
    name: string;
    url: string;
    category: string;
    aliases: string[];
};

// @public (undocumented)
type DateString = string;

// @public (undocumented)
type DetailedInstanceMetadata = LiteInstanceMetadata & {
    features: Record<string, any>;
};

// @public (undocumented)
type DriveFile = {
    id: ID;
    createdAt: DateString;
    isSensitive: boolean;
    name: string;
    thumbnailUrl: string;
    url: string;
    type: string;
    size: number;
    md5: string;
    blurhash: string;
    comment: string | null;
    properties: Record<string, any>;
};

// @public (undocumented)
type DriveFolder = TODO_2;

// @public (undocumented)
export type Endpoints = {
    "admin/abuse-user-reports": {
        req: TODO;
        res: TODO;
    };
    "admin/delete-all-files-of-a-user": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "admin/delete-logs": {
        req: NoParams;
        res: null;
    };
    "admin/get-index-stats": {
        req: TODO;
        res: TODO;
    };
    "admin/get-table-stats": {
        req: TODO;
        res: TODO;
    };
    "admin/invite": {
        req: TODO;
        res: TODO;
    };
    "admin/logs": {
        req: TODO;
        res: TODO;
    };
    "admin/meta": {
        req: TODO;
        res: TODO;
    };
    "admin/reset-password": {
        req: TODO;
        res: TODO;
    };
    "admin/resolve-abuse-user-report": {
        req: TODO;
        res: TODO;
    };
    "admin/resync-chart": {
        req: TODO;
        res: TODO;
    };
    "admin/send-email": {
        req: TODO;
        res: TODO;
    };
    "admin/server-info": {
        req: TODO;
        res: TODO;
    };
    "admin/show-moderation-logs": {
        req: TODO;
        res: TODO;
    };
    "admin/show-user": {
        req: TODO;
        res: TODO;
    };
    "admin/show-users": {
        req: TODO;
        res: TODO;
    };
    "admin/silence-user": {
        req: TODO;
        res: TODO;
    };
    "admin/suspend-user": {
        req: TODO;
        res: TODO;
    };
    "admin/unsilence-user": {
        req: TODO;
        res: TODO;
    };
    "admin/unsuspend-user": {
        req: TODO;
        res: TODO;
    };
    "admin/update-meta": {
        req: TODO;
        res: TODO;
    };
    "admin/vacuum": {
        req: TODO;
        res: TODO;
    };
    "admin/accounts/create": {
        req: TODO;
        res: TODO;
    };
    "admin/announcements/create": {
        req: TODO;
        res: TODO;
    };
    "admin/announcements/delete": {
        req: {
            id: Announcement["id"];
        };
        res: null;
    };
    "admin/announcements/list": {
        req: TODO;
        res: TODO;
    };
    "admin/announcements/update": {
        req: TODO;
        res: TODO;
    };
    "admin/drive/clean-remote-files": {
        req: TODO;
        res: TODO;
    };
    "admin/drive/cleanup": {
        req: TODO;
        res: TODO;
    };
    "admin/drive/files": {
        req: TODO;
        res: TODO;
    };
    "admin/drive/show-file": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/add": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/copy": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/list-remote": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/list": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/remove": {
        req: TODO;
        res: TODO;
    };
    "admin/emoji/update": {
        req: TODO;
        res: TODO;
    };
    "admin/federation/delete-all-files": {
        req: {
            host: string;
        };
        res: null;
    };
    "admin/federation/refresh-remote-instance-metadata": {
        req: TODO;
        res: TODO;
    };
    "admin/federation/remove-all-following": {
        req: TODO;
        res: TODO;
    };
    "admin/federation/update-instance": {
        req: TODO;
        res: TODO;
    };
    "admin/moderators/add": {
        req: TODO;
        res: TODO;
    };
    "admin/moderators/remove": {
        req: TODO;
        res: TODO;
    };
    "admin/promo/create": {
        req: TODO;
        res: TODO;
    };
    "admin/queue/clear": {
        req: TODO;
        res: TODO;
    };
    "admin/queue/deliver-delayed": {
        req: TODO;
        res: TODO;
    };
    "admin/queue/inbox-delayed": {
        req: TODO;
        res: TODO;
    };
    "admin/queue/jobs": {
        req: TODO;
        res: TODO;
    };
    "admin/queue/stats": {
        req: TODO;
        res: TODO;
    };
    "admin/relays/add": {
        req: TODO;
        res: TODO;
    };
    "admin/relays/list": {
        req: TODO;
        res: TODO;
    };
    "admin/relays/remove": {
        req: TODO;
        res: TODO;
    };
    announcements: {
        req: {
            limit?: number;
            withUnreads?: boolean;
            sinceId?: Announcement["id"];
            untilId?: Announcement["id"];
        };
        res: Announcement[];
    };
    "antennas/create": {
        req: TODO;
        res: Antenna;
    };
    "antennas/delete": {
        req: {
            antennaId: Antenna["id"];
        };
        res: null;
    };
    "antennas/list": {
        req: NoParams;
        res: Antenna[];
    };
    "antennas/notes": {
        req: {
            antennaId: Antenna["id"];
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
        };
        res: Note[];
    };
    "antennas/show": {
        req: {
            antennaId: Antenna["id"];
        };
        res: Antenna;
    };
    "antennas/update": {
        req: TODO;
        res: Antenna;
    };
    "antennas/mark-read": {
        req: TODO;
        res: Antenna;
    };
    "ap/get": {
        req: {
            uri: string;
        };
        res: Record<string, any>;
    };
    "ap/show": {
        req: {
            uri: string;
        };
        res: {
            type: "Note";
            object: Note;
        } | {
            type: "User";
            object: UserDetailed;
        };
    };
    "app/create": {
        req: TODO;
        res: App;
    };
    "app/show": {
        req: {
            appId: App["id"];
        };
        res: App;
    };
    "auth/accept": {
        req: {
            token: string;
        };
        res: null;
    };
    "auth/session/generate": {
        req: {
            appSecret: string;
        };
        res: {
            token: string;
            url: string;
        };
    };
    "auth/session/show": {
        req: {
            token: string;
        };
        res: AuthSession;
    };
    "auth/session/userkey": {
        req: {
            appSecret: string;
            token: string;
        };
        res: {
            accessToken: string;
            user: User;
        };
    };
    "blocking/create": {
        req: {
            userId: User["id"];
        };
        res: UserDetailed;
    };
    "blocking/delete": {
        req: {
            userId: User["id"];
        };
        res: UserDetailed;
    };
    "blocking/list": {
        req: {
            limit?: number;
            sinceId?: Blocking["id"];
            untilId?: Blocking["id"];
        };
        res: Blocking[];
    };
    "channels/create": {
        req: TODO;
        res: TODO;
    };
    "channels/featured": {
        req: TODO;
        res: TODO;
    };
    "channels/follow": {
        req: TODO;
        res: TODO;
    };
    "channels/followed": {
        req: TODO;
        res: TODO;
    };
    "channels/owned": {
        req: TODO;
        res: TODO;
    };
    "channels/pin-note": {
        req: TODO;
        res: TODO;
    };
    "channels/show": {
        req: TODO;
        res: TODO;
    };
    "channels/timeline": {
        req: TODO;
        res: TODO;
    };
    "channels/unfollow": {
        req: TODO;
        res: TODO;
    };
    "channels/update": {
        req: TODO;
        res: TODO;
    };
    "charts/active-users": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: {
            local: {
                users: number[];
            };
            remote: {
                users: number[];
            };
        };
    };
    "charts/drive": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: {
            local: {
                decCount: number[];
                decSize: number[];
                incCount: number[];
                incSize: number[];
                totalCount: number[];
                totalSize: number[];
            };
            remote: {
                decCount: number[];
                decSize: number[];
                incCount: number[];
                incSize: number[];
                totalCount: number[];
                totalSize: number[];
            };
        };
    };
    "charts/federation": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: {
            instance: {
                dec: number[];
                inc: number[];
                total: number[];
            };
        };
    };
    "charts/hashtag": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: TODO;
    };
    "charts/instance": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
            host: string;
        };
        res: {
            drive: {
                decFiles: number[];
                decUsage: number[];
                incFiles: number[];
                incUsage: number[];
                totalFiles: number[];
                totalUsage: number[];
            };
            followers: {
                dec: number[];
                inc: number[];
                total: number[];
            };
            following: {
                dec: number[];
                inc: number[];
                total: number[];
            };
            notes: {
                dec: number[];
                inc: number[];
                total: number[];
                diffs: {
                    normal: number[];
                    renote: number[];
                    reply: number[];
                };
            };
            requests: {
                failed: number[];
                received: number[];
                succeeded: number[];
            };
            users: {
                dec: number[];
                inc: number[];
                total: number[];
            };
        };
    };
    "charts/network": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: TODO;
    };
    "charts/notes": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: {
            local: {
                dec: number[];
                inc: number[];
                total: number[];
                diffs: {
                    normal: number[];
                    renote: number[];
                    reply: number[];
                };
            };
            remote: {
                dec: number[];
                inc: number[];
                total: number[];
                diffs: {
                    normal: number[];
                    renote: number[];
                    reply: number[];
                };
            };
        };
    };
    "charts/user/drive": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
            userId: User["id"];
        };
        res: {
            decCount: number[];
            decSize: number[];
            incCount: number[];
            incSize: number[];
            totalCount: number[];
            totalSize: number[];
        };
    };
    "charts/user/following": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
            userId: User["id"];
        };
        res: TODO;
    };
    "charts/user/notes": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
            userId: User["id"];
        };
        res: {
            dec: number[];
            inc: number[];
            total: number[];
            diffs: {
                normal: number[];
                renote: number[];
                reply: number[];
            };
        };
    };
    "charts/user/reactions": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
            userId: User["id"];
        };
        res: TODO;
    };
    "charts/users": {
        req: {
            span: "day" | "hour";
            limit?: number;
            offset?: number | null;
        };
        res: {
            local: {
                dec: number[];
                inc: number[];
                total: number[];
            };
            remote: {
                dec: number[];
                inc: number[];
                total: number[];
            };
        };
    };
    "clips/add-note": {
        req: TODO;
        res: TODO;
    };
    "clips/create": {
        req: TODO;
        res: TODO;
    };
    "clips/delete": {
        req: {
            clipId: Clip["id"];
        };
        res: null;
    };
    "clips/list": {
        req: TODO;
        res: TODO;
    };
    "clips/notes": {
        req: TODO;
        res: TODO;
    };
    "clips/show": {
        req: TODO;
        res: TODO;
    };
    "clips/update": {
        req: TODO;
        res: TODO;
    };
    drive: {
        req: NoParams;
        res: {
            capacity: number;
            usage: number;
        };
    };
    "drive/files": {
        req: {
            folderId?: DriveFolder["id"] | null;
            type?: DriveFile["type"] | null;
            limit?: number;
            sinceId?: DriveFile["id"];
            untilId?: DriveFile["id"];
        };
        res: DriveFile[];
    };
    "drive/files/attached-notes": {
        req: TODO;
        res: TODO;
    };
    "drive/files/check-existence": {
        req: TODO;
        res: TODO;
    };
    "drive/files/create": {
        req: TODO;
        res: TODO;
    };
    "drive/files/delete": {
        req: {
            fileId: DriveFile["id"];
        };
        res: null;
    };
    "drive/files/find-by-hash": {
        req: TODO;
        res: TODO;
    };
    "drive/files/find": {
        req: {
            name: string;
            folderId?: DriveFolder["id"] | null;
        };
        res: DriveFile[];
    };
    "drive/files/show": {
        req: {
            fileId?: DriveFile["id"];
            url?: string;
        };
        res: DriveFile;
    };
    "drive/files/update": {
        req: {
            fileId: DriveFile["id"];
            folderId?: DriveFolder["id"] | null;
            name?: string;
            isSensitive?: boolean;
            comment?: string | null;
        };
        res: DriveFile;
    };
    "drive/files/upload-from-url": {
        req: {
            url: string;
            folderId?: DriveFolder["id"] | null;
            isSensitive?: boolean;
            comment?: string | null;
            marker?: string | null;
            force?: boolean;
        };
        res: null;
    };
    "drive/folders": {
        req: {
            folderId?: DriveFolder["id"] | null;
            limit?: number;
            sinceId?: DriveFile["id"];
            untilId?: DriveFile["id"];
        };
        res: DriveFolder[];
    };
    "drive/folders/create": {
        req: {
            name?: string;
            parentId?: DriveFolder["id"] | null;
        };
        res: DriveFolder;
    };
    "drive/folders/delete": {
        req: {
            folderId: DriveFolder["id"];
        };
        res: null;
    };
    "drive/folders/find": {
        req: {
            name: string;
            parentId?: DriveFolder["id"] | null;
        };
        res: DriveFolder[];
    };
    "drive/folders/show": {
        req: {
            folderId: DriveFolder["id"];
        };
        res: DriveFolder;
    };
    "drive/folders/update": {
        req: {
            folderId: DriveFolder["id"];
            name?: string;
            parentId?: DriveFolder["id"] | null;
        };
        res: DriveFolder;
    };
    "drive/stream": {
        req: {
            type?: DriveFile["type"] | null;
            limit?: number;
            sinceId?: DriveFile["id"];
            untilId?: DriveFile["id"];
        };
        res: DriveFile[];
    };
    endpoint: {
        req: {
            endpoint: string;
        };
        res: {
            params: {
                name: string;
                type: string;
            }[];
        };
    };
    endpoints: {
        req: NoParams;
        res: string[];
    };
    "federation/dns": {
        req: {
            host: string;
        };
        res: {
            a: string[];
            aaaa: string[];
            cname: string[];
            txt: string[];
        };
    };
    "federation/followers": {
        req: {
            host: string;
            limit?: number;
            sinceId?: Following["id"];
            untilId?: Following["id"];
        };
        res: FollowingFolloweePopulated[];
    };
    "federation/following": {
        req: {
            host: string;
            limit?: number;
            sinceId?: Following["id"];
            untilId?: Following["id"];
        };
        res: FollowingFolloweePopulated[];
    };
    "federation/instances": {
        req: {
            host?: string | null;
            blocked?: boolean | null;
            notResponding?: boolean | null;
            suspended?: boolean | null;
            federating?: boolean | null;
            subscribing?: boolean | null;
            publishing?: boolean | null;
            limit?: number;
            offset?: number;
            sort?: "+pubSub" | "-pubSub" | "+notes" | "-notes" | "+users" | "-users" | "+following" | "-following" | "+followers" | "-followers" | "+caughtAt" | "-caughtAt" | "+lastCommunicatedAt" | "-lastCommunicatedAt" | "+driveUsage" | "-driveUsage" | "+driveFiles" | "-driveFiles";
        };
        res: Instance[];
    };
    "federation/show-instance": {
        req: {
            host: string;
        };
        res: Instance;
    };
    "federation/update-remote-user": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "federation/users": {
        req: {
            host: string;
            limit?: number;
            sinceId?: User["id"];
            untilId?: User["id"];
        };
        res: UserDetailed[];
    };
    "following/create": {
        req: {
            userId: User["id"];
        };
        res: User;
    };
    "following/delete": {
        req: {
            userId: User["id"];
        };
        res: User;
    };
    "following/requests/accept": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "following/requests/cancel": {
        req: {
            userId: User["id"];
        };
        res: User;
    };
    "following/requests/list": {
        req: NoParams;
        res: FollowRequest[];
    };
    "following/requests/reject": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "gallery/featured": {
        req: TODO;
        res: TODO;
    };
    "gallery/popular": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts/create": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts/delete": {
        req: {
            postId: GalleryPost["id"];
        };
        res: null;
    };
    "gallery/posts/like": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts/show": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts/unlike": {
        req: TODO;
        res: TODO;
    };
    "gallery/posts/update": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/games": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/games/show": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/games/surrender": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/invitations": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/match": {
        req: TODO;
        res: TODO;
    };
    "games/reversi/match/cancel": {
        req: TODO;
        res: TODO;
    };
    "get-online-users-count": {
        req: NoParams;
        res: {
            count: number;
        };
    };
    "hashtags/list": {
        req: TODO;
        res: TODO;
    };
    "hashtags/search": {
        req: TODO;
        res: TODO;
    };
    "hashtags/show": {
        req: TODO;
        res: TODO;
    };
    "hashtags/trend": {
        req: TODO;
        res: TODO;
    };
    "hashtags/users": {
        req: TODO;
        res: TODO;
    };
    i: {
        req: NoParams;
        res: User;
    };
    "i/apps": {
        req: TODO;
        res: TODO;
    };
    "i/authorized-apps": {
        req: TODO;
        res: TODO;
    };
    "i/change-password": {
        req: TODO;
        res: TODO;
    };
    "i/delete-account": {
        req: {
            password: string;
        };
        res: null;
    };
    "i/export-blocking": {
        req: TODO;
        res: TODO;
    };
    "i/export-following": {
        req: TODO;
        res: TODO;
    };
    "i/export-mute": {
        req: TODO;
        res: TODO;
    };
    "i/export-notes": {
        req: TODO;
        res: TODO;
    };
    "i/export-user-lists": {
        req: TODO;
        res: TODO;
    };
    "i/favorites": {
        req: {
            limit?: number;
            sinceId?: NoteFavorite["id"];
            untilId?: NoteFavorite["id"];
        };
        res: NoteFavorite[];
    };
    "i/gallery/likes": {
        req: TODO;
        res: TODO;
    };
    "i/gallery/posts": {
        req: TODO;
        res: TODO;
    };
    "i/import-following": {
        req: TODO;
        res: TODO;
    };
    "i/import-user-lists": {
        req: TODO;
        res: TODO;
    };
    "i/move": {
        req: TODO;
        res: TODO;
    };
    "i/known-as": {
        req: TODO;
        res: TODO;
    };
    "i/notifications": {
        req: {
            limit?: number;
            sinceId?: Notification_2["id"];
            untilId?: Notification_2["id"];
            following?: boolean;
            markAsRead?: boolean;
            includeTypes?: Notification_2["type"][];
            excludeTypes?: Notification_2["type"][];
        };
        res: Notification_2[];
    };
    "i/page-likes": {
        req: TODO;
        res: TODO;
    };
    "i/pages": {
        req: TODO;
        res: TODO;
    };
    "i/pin": {
        req: {
            noteId: Note["id"];
        };
        res: MeDetailed;
    };
    "i/read-all-messaging-messages": {
        req: TODO;
        res: TODO;
    };
    "i/read-all-unread-notes": {
        req: TODO;
        res: TODO;
    };
    "i/read-announcement": {
        req: TODO;
        res: TODO;
    };
    "i/regenerate-token": {
        req: {
            password: string;
        };
        res: null;
    };
    "i/registry/get-all": {
        req: {
            scope?: string[];
        };
        res: Record<string, any>;
    };
    "i/registry/get-detail": {
        req: {
            key: string;
            scope?: string[];
        };
        res: {
            updatedAt: DateString;
            value: any;
        };
    };
    "i/registry/get": {
        req: {
            key: string;
            scope?: string[];
        };
        res: any;
    };
    "i/registry/keys-with-type": {
        req: {
            scope?: string[];
        };
        res: Record<string, "null" | "array" | "number" | "string" | "boolean" | "object">;
    };
    "i/registry/keys": {
        req: {
            scope?: string[];
        };
        res: string[];
    };
    "i/registry/remove": {
        req: {
            key: string;
            scope?: string[];
        };
        res: null;
    };
    "i/registry/scopes": {
        req: NoParams;
        res: string[][];
    };
    "i/registry/set": {
        req: {
            key: string;
            value: any;
            scope?: string[];
        };
        res: null;
    };
    "i/revoke-token": {
        req: TODO;
        res: TODO;
    };
    "i/signin-history": {
        req: {
            limit?: number;
            sinceId?: Signin["id"];
            untilId?: Signin["id"];
        };
        res: Signin[];
    };
    "i/unpin": {
        req: {
            noteId: Note["id"];
        };
        res: MeDetailed;
    };
    "i/update-email": {
        req: {
            password: string;
            email?: string | null;
        };
        res: MeDetailed;
    };
    "i/update": {
        req: {
            name?: string | null;
            description?: string | null;
            lang?: string | null;
            location?: string | null;
            birthday?: string | null;
            avatarId?: DriveFile["id"] | null;
            bannerId?: DriveFile["id"] | null;
            fields?: {
                name: string;
                value: string;
            }[];
            isLocked?: boolean;
            isExplorable?: boolean;
            hideOnlineStatus?: boolean;
            carefulBot?: boolean;
            autoAcceptFollowed?: boolean;
            noCrawle?: boolean;
            preventAiLearning?: boolean;
            isBot?: boolean;
            isCat?: boolean;
            injectFeaturedNote?: boolean;
            receiveAnnouncementEmail?: boolean;
            alwaysMarkNsfw?: boolean;
            mutedWords?: string[][];
            mutingNotificationTypes?: Notification_2["type"][];
            emailNotificationTypes?: string[];
        };
        res: MeDetailed;
    };
    "i/user-group-invites": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/done": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/key-done": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/password-less": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/register-key": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/register": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/update-key": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/remove-key": {
        req: TODO;
        res: TODO;
    };
    "i/2fa/unregister": {
        req: TODO;
        res: TODO;
    };
    "messaging/history": {
        req: {
            limit?: number;
            group?: boolean;
        };
        res: MessagingMessage[];
    };
    "messaging/messages": {
        req: {
            userId?: User["id"];
            groupId?: UserGroup["id"];
            limit?: number;
            sinceId?: MessagingMessage["id"];
            untilId?: MessagingMessage["id"];
            markAsRead?: boolean;
        };
        res: MessagingMessage[];
    };
    "messaging/messages/create": {
        req: {
            userId?: User["id"];
            groupId?: UserGroup["id"];
            text?: string;
            fileId?: DriveFile["id"];
        };
        res: MessagingMessage;
    };
    "messaging/messages/delete": {
        req: {
            messageId: MessagingMessage["id"];
        };
        res: null;
    };
    "messaging/messages/read": {
        req: {
            messageId: MessagingMessage["id"];
        };
        res: null;
    };
    meta: {
        req: {
            detail?: boolean;
        };
        res: {
            $switch: {
                $cases: [
                [
                    {
                    detail: true;
                },
                DetailedInstanceMetadata
                ],
                [
                    {
                    detail: false;
                },
                LiteInstanceMetadata
                ],
                [
                    {
                    detail: boolean;
                },
                LiteInstanceMetadata | DetailedInstanceMetadata
                ]
                ];
                $default: LiteInstanceMetadata;
            };
        };
    };
    "miauth/gen-token": {
        req: TODO;
        res: TODO;
    };
    "mute/create": {
        req: TODO;
        res: TODO;
    };
    "mute/delete": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "mute/list": {
        req: TODO;
        res: TODO;
    };
    "renote-mute/create": {
        req: TODO;
        res: TODO;
    };
    "renote-mute/delete": {
        req: {
            userId: User["id"];
        };
        res: null;
    };
    "renote-mute/list": {
        req: TODO;
        res: TODO;
    };
    "my/apps": {
        req: TODO;
        res: TODO;
    };
    notes: {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
        };
        res: Note[];
    };
    "notes/children": {
        req: {
            noteId: Note["id"];
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
        };
        res: Note[];
    };
    "notes/clips": {
        req: TODO;
        res: TODO;
    };
    "notes/conversation": {
        req: TODO;
        res: TODO;
    };
    "notes/create": {
        req: NoteSubmitReq;
        res: {
            createdNote: Note;
        };
    };
    "notes/delete": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notes/edit": {
        req: NoteSubmitReq;
        res: {
            createdNote: Note;
        };
    };
    "notes/favorites/create": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notes/favorites/delete": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notes/featured": {
        req: TODO;
        res: Note[];
    };
    "notes/global-timeline": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/recommended-timeline": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/hybrid-timeline": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/local-timeline": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/mentions": {
        req: {
            following?: boolean;
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
        };
        res: Note[];
    };
    "notes/polls/recommendation": {
        req: TODO;
        res: TODO;
    };
    "notes/polls/vote": {
        req: {
            noteId: Note["id"];
            choice: number;
        };
        res: null;
    };
    "notes/reactions": {
        req: {
            noteId: Note["id"];
            type?: string | null;
            limit?: number;
        };
        res: NoteReaction[];
    };
    "notes/reactions/create": {
        req: {
            noteId: Note["id"];
            reaction: string;
        };
        res: null;
    };
    "notes/reactions/delete": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notes/renotes": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            noteId: Note["id"];
        };
        res: Note[];
    };
    "notes/replies": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            noteId: Note["id"];
        };
        res: Note[];
    };
    "notes/search-by-tag": {
        req: TODO;
        res: TODO;
    };
    "notes/search": {
        req: TODO;
        res: TODO;
    };
    "notes/show": {
        req: {
            noteId: Note["id"];
        };
        res: Note;
    };
    "notes/state": {
        req: TODO;
        res: TODO;
    };
    "notes/timeline": {
        req: {
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/unrenote": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notes/user-list-timeline": {
        req: {
            listId: UserList["id"];
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "notes/watching/create": {
        req: TODO;
        res: TODO;
    };
    "notes/watching/delete": {
        req: {
            noteId: Note["id"];
        };
        res: null;
    };
    "notifications/create": {
        req: {
            body: string;
            header?: string | null;
            icon?: string | null;
        };
        res: null;
    };
    "notifications/mark-all-as-read": {
        req: NoParams;
        res: null;
    };
    "notifications/read": {
        req: {
            notificationId: Notification_2["id"];
        };
        res: null;
    };
    "page-push": {
        req: {
            pageId: Page["id"];
            event: string;
            var?: any;
        };
        res: null;
    };
    "pages/create": {
        req: TODO;
        res: Page;
    };
    "pages/delete": {
        req: {
            pageId: Page["id"];
        };
        res: null;
    };
    "pages/featured": {
        req: NoParams;
        res: Page[];
    };
    "pages/like": {
        req: {
            pageId: Page["id"];
        };
        res: null;
    };
    "pages/show": {
        req: {
            pageId?: Page["id"];
            name?: string;
            username?: string;
        };
        res: Page;
    };
    "pages/unlike": {
        req: {
            pageId: Page["id"];
        };
        res: null;
    };
    "pages/update": {
        req: TODO;
        res: null;
    };
    ping: {
        req: NoParams;
        res: {
            pong: number;
        };
    };
    "pinned-users": {
        req: TODO;
        res: TODO;
    };
    "promo/read": {
        req: TODO;
        res: TODO;
    };
    "request-reset-password": {
        req: {
            username: string;
            email: string;
        };
        res: null;
    };
    "reset-password": {
        req: {
            token: string;
            password: string;
        };
        res: null;
    };
    "room/show": {
        req: TODO;
        res: TODO;
    };
    "room/update": {
        req: TODO;
        res: TODO;
    };
    stats: {
        req: NoParams;
        res: Stats;
    };
    "server-info": {
        req: NoParams;
        res: ServerInfo;
    };
    "latest-version": {
        req: NoParams;
        res: TODO;
    };
    "sw/register": {
        req: TODO;
        res: TODO;
    };
    "username/available": {
        req: {
            username: string;
        };
        res: {
            available: boolean;
        };
    };
    users: {
        req: {
            limit?: number;
            offset?: number;
            sort?: UserSorting;
            origin?: OriginType;
        };
        res: User[];
    };
    "users/clips": {
        req: TODO;
        res: TODO;
    };
    "users/followers": {
        req: {
            userId?: User["id"];
            username?: User["username"];
            host?: User["host"] | null;
            limit?: number;
            sinceId?: Following["id"];
            untilId?: Following["id"];
        };
        res: FollowingFollowerPopulated[];
    };
    "users/following": {
        req: {
            userId?: User["id"];
            username?: User["username"];
            host?: User["host"] | null;
            limit?: number;
            sinceId?: Following["id"];
            untilId?: Following["id"];
        };
        res: FollowingFolloweePopulated[];
    };
    "users/gallery/posts": {
        req: TODO;
        res: TODO;
    };
    "users/get-frequently-replied-users": {
        req: TODO;
        res: TODO;
    };
    "users/groups/create": {
        req: TODO;
        res: TODO;
    };
    "users/groups/delete": {
        req: {
            groupId: UserGroup["id"];
        };
        res: null;
    };
    "users/groups/invitations/accept": {
        req: TODO;
        res: TODO;
    };
    "users/groups/invitations/reject": {
        req: TODO;
        res: TODO;
    };
    "users/groups/invite": {
        req: TODO;
        res: TODO;
    };
    "users/groups/joined": {
        req: TODO;
        res: TODO;
    };
    "users/groups/owned": {
        req: TODO;
        res: TODO;
    };
    "users/groups/pull": {
        req: TODO;
        res: TODO;
    };
    "users/groups/show": {
        req: TODO;
        res: TODO;
    };
    "users/groups/transfer": {
        req: TODO;
        res: TODO;
    };
    "users/groups/update": {
        req: TODO;
        res: TODO;
    };
    "users/lists/create": {
        req: {
            name: string;
        };
        res: UserList;
    };
    "users/lists/delete": {
        req: {
            listId: UserList["id"];
        };
        res: null;
    };
    "users/lists/list": {
        req: NoParams;
        res: UserList[];
    };
    "users/lists/pull": {
        req: {
            listId: UserList["id"];
            userId: User["id"];
        };
        res: null;
    };
    "users/lists/push": {
        req: {
            listId: UserList["id"];
            userId: User["id"];
        };
        res: null;
    };
    "users/lists/show": {
        req: {
            listId: UserList["id"];
        };
        res: UserList;
    };
    "users/lists/update": {
        req: {
            listId: UserList["id"];
            name: string;
        };
        res: UserList;
    };
    "users/notes": {
        req: {
            userId: User["id"];
            limit?: number;
            sinceId?: Note["id"];
            untilId?: Note["id"];
            sinceDate?: number;
            untilDate?: number;
        };
        res: Note[];
    };
    "users/pages": {
        req: TODO;
        res: TODO;
    };
    "users/recommendation": {
        req: TODO;
        res: TODO;
    };
    "users/relation": {
        req: TODO;
        res: TODO;
    };
    "users/report-abuse": {
        req: TODO;
        res: TODO;
    };
    "users/search-by-username-and-host": {
        req: TODO;
        res: TODO;
    };
    "users/search": {
        req: TODO;
        res: TODO;
    };
    "users/show": {
        req: ShowUserReq | {
            userIds: User["id"][];
        };
        res: {
            $switch: {
                $cases: [[{
                    userIds: User["id"][];
                }, UserDetailed[]]];
                $default: UserDetailed;
            };
        };
    };
    "users/stats": {
        req: TODO;
        res: TODO;
    };
};

declare namespace entities {
    export {
        ID,
        DateString,
        User,
        UserLite,
        UserDetailed,
        UserGroup,
        UserList,
        MeDetailed,
        DriveFile,
        DriveFolder,
        GalleryPost,
        Note,
        NoteReaction,
        Notification_2 as Notification,
        MessagingMessage,
        CustomEmoji,
        LiteInstanceMetadata,
        DetailedInstanceMetadata,
        InstanceMetadata,
        ServerInfo,
        Stats,
        Page,
        PageEvent,
        Announcement,
        Antenna,
        App,
        AuthSession,
        Clip,
        NoteFavorite,
        FollowRequest,
        Channel,
        Following,
        FollowingFolloweePopulated,
        FollowingFollowerPopulated,
        Blocking,
        Instance,
        Signin,
        UserSorting,
        OriginType
    }
}
export { entities }

// @public (undocumented)
type FetchLike = (input: string, init?: {
    method?: string;
    body?: string;
    credentials?: RequestCredentials;
    cache?: RequestCache;
}) => Promise<{
    status: number;
    json(): Promise<any>;
}>;

// @public (undocumented)
export const ffVisibility: readonly ["public", "followers", "private"];

// @public (undocumented)
type Following = {
    id: ID;
    createdAt: DateString;
    followerId: User["id"];
    followeeId: User["id"];
};

// @public (undocumented)
type FollowingFolloweePopulated = Following & {
    followee: UserDetailed;
};

// @public (undocumented)
type FollowingFollowerPopulated = Following & {
    follower: UserDetailed;
};

// @public (undocumented)
type FollowRequest = {
    id: ID;
    follower: User;
    followee: User;
};

// @public (undocumented)
type GalleryPost = TODO_2;

// @public (undocumented)
type ID = string;

// @public (undocumented)
type Instance = {
    id: ID;
    caughtAt: DateString;
    host: string;
    usersCount: number;
    notesCount: number;
    followingCount: number;
    followersCount: number;
    driveUsage: number;
    driveFiles: number;
    latestRequestSentAt: DateString | null;
    latestStatus: number | null;
    latestRequestReceivedAt: DateString | null;
    lastCommunicatedAt: DateString;
    isNotResponding: boolean;
    isSuspended: boolean;
    softwareName: string | null;
    softwareVersion: string | null;
    openRegistrations: boolean | null;
    name: string | null;
    description: string | null;
    maintainerName: string | null;
    maintainerEmail: string | null;
    iconUrl: string | null;
    faviconUrl: string | null;
    themeColor: string | null;
    infoUpdatedAt: DateString | null;
};

// @public (undocumented)
type InstanceMetadata = LiteInstanceMetadata | DetailedInstanceMetadata;

// @public (undocumented)
function isAPIError(reason: any): reason is APIError;

// @public (undocumented)
type LiteInstanceMetadata = {
    maintainerName: string | null;
    maintainerEmail: string | null;
    version: string;
    name: string | null;
    uri: string;
    description: string | null;
    tosUrl: string | null;
    disableRegistration: boolean;
    disableLocalTimeline: boolean;
    disableRecommendedTimeline: boolean;
    disableGlobalTimeline: boolean;
    driveCapacityPerLocalUserMb: number;
    driveCapacityPerRemoteUserMb: number;
    enableHcaptcha: boolean;
    hcaptchaSiteKey: string | null;
    enableRecaptcha: boolean;
    recaptchaSiteKey: string | null;
    swPublickey: string | null;
    maxNoteTextLength: number;
    enableEmail: boolean;
    enableGithubIntegration: boolean;
    enableDiscordIntegration: boolean;
    searchEngine: string;
    emojis: CustomEmoji[];
    images: {
        error: string;
        notFound: string;
        info: string;
    };
};

// @public (undocumented)
type MeDetailed = UserDetailed & {
    avatarId: DriveFile["id"];
    bannerId: DriveFile["id"];
    autoAcceptFollowed: boolean;
    alwaysMarkNsfw: boolean;
    carefulBot: boolean;
    emailNotificationTypes: string[];
    hasPendingReceivedFollowRequest: boolean;
    hasUnreadAnnouncement: boolean;
    hasUnreadAntenna: boolean;
    hasUnreadChannel: boolean;
    hasUnreadMentions: boolean;
    hasUnreadMessagingMessage: boolean;
    hasUnreadNotification: boolean;
    hasUnreadSpecifiedNotes: boolean;
    hideOnlineStatus: boolean;
    injectFeaturedNote: boolean;
    integrations: Record<string, any>;
    isDeleted: boolean;
    isExplorable: boolean;
    mutedWords: string[][];
    mutingNotificationTypes: string[];
    noCrawle: boolean;
    preventAiLearning: boolean;
    receiveAnnouncementEmail: boolean;
    usePasswordLessLogin: boolean;
    [other: string]: any;
};

// @public (undocumented)
type MessagingMessage = {
    id: ID;
    createdAt: DateString;
    file: DriveFile | null;
    fileId: DriveFile["id"] | null;
    isRead: boolean;
    reads: User["id"][];
    text: string | null;
    user: User;
    userId: User["id"];
    recipient?: User | null;
    recipientId: User["id"] | null;
    group?: UserGroup | null;
    groupId: UserGroup["id"] | null;
};

// @public (undocumented)
type Note = {
    id: ID;
    createdAt: DateString;
    text: string | null;
    cw: string | null;
    user: User;
    userId: User["id"];
    reply?: Note;
    replyId: Note["id"];
    renote?: Note;
    renoteId: Note["id"];
    files: DriveFile[];
    fileIds: DriveFile["id"][];
    visibility: "public" | "home" | "followers" | "specified";
    visibleUserIds?: User["id"][];
    localOnly?: boolean;
    channel?: Channel["id"];
    myReaction?: string;
    isRenoted?: boolean;
    reactions: Record<string, number>;
    renoteCount: number;
    repliesCount: number;
    poll?: {
        expiresAt: DateString | null;
        multiple: boolean;
        choices: {
            isVoted: boolean;
            text: string;
            votes: number;
        }[];
    };
    emojis: {
        name: string;
        url: string;
    }[];
    uri?: string;
    url?: string;
    updatedAt?: DateString;
    isHidden?: boolean;
};

// @public (undocumented)
type NoteFavorite = {
    id: ID;
    createdAt: DateString;
    noteId: Note["id"];
    note: Note;
};

// @public (undocumented)
type NoteReaction = {
    id: ID;
    createdAt: DateString;
    user: UserLite;
    type: string;
};

// @public (undocumented)
export const noteVisibilities: readonly ["public", "home", "followers", "specified"];

// @public (undocumented)
type Notification_2 = {
    id: ID;
    createdAt: DateString;
    isRead: boolean;
} & ({
    type: "reaction";
    reaction: string;
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "reply";
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "renote";
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "quote";
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "mention";
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "pollVote";
    user: User;
    userId: User["id"];
    note: Note;
} | {
    type: "follow";
    user: User;
    userId: User["id"];
} | {
    type: "followRequestAccepted";
    user: User;
    userId: User["id"];
} | {
    type: "receiveFollowRequest";
    user: User;
    userId: User["id"];
} | {
    type: "groupInvited";
    invitation: UserGroup;
    user: User;
    userId: User["id"];
} | {
    type: "app";
    header?: string | null;
    body: string;
    icon?: string | null;
});

// @public (undocumented)
export const notificationTypes: readonly ["follow", "mention", "reply", "renote", "quote", "reaction", "pollVote", "pollEnded", "receiveFollowRequest", "followRequestAccepted", "groupInvited", "app"];

// @public (undocumented)
type OriginType = "combined" | "local" | "remote";

// @public (undocumented)
type Page = {
    id: ID;
    createdAt: DateString;
    updatedAt: DateString;
    userId: User["id"];
    user: User;
    content: Record<string, any>[];
    variables: Record<string, any>[];
    title: string;
    name: string;
    summary: string | null;
    hideTitleWhenPinned: boolean;
    alignCenter: boolean;
    font: string;
    script: string;
    eyeCatchingImageId: DriveFile["id"] | null;
    eyeCatchingImage: DriveFile | null;
    attachedFiles: any;
    likedCount: number;
    isLiked?: boolean;
};

// @public (undocumented)
type PageEvent = {
    pageId: Page["id"];
    event: string;
    var: any;
    userId: User["id"];
    user: User;
};

// @public (undocumented)
export const permissions: string[];

// @public (undocumented)
type ServerInfo = {
    machine: string;
    cpu: {
        model: string;
        cores: number;
    };
    mem: {
        total: number;
    };
    fs: {
        total: number;
        used: number;
    };
};

// @public (undocumented)
type Signin = {
    id: ID;
    createdAt: DateString;
    ip: string;
    headers: Record<string, any>;
    success: boolean;
};

// @public (undocumented)
type Stats = {
    notesCount: number;
    originalNotesCount: number;
    usersCount: number;
    originalUsersCount: number;
    instances: number;
    driveUsageLocal: number;
    driveUsageRemote: number;
};

// Warning: (ae-forgotten-export) The symbol "StreamEvents" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export class Stream extends EventEmitter<StreamEvents> {
    constructor(origin: string, user: {
        token: string;
    } | null, options?: {
        WebSocket?: any;
    });
    // (undocumented)
    close(): void;
    // Warning: (ae-forgotten-export) The symbol "NonSharedConnection" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    disconnectToChannel(connection: NonSharedConnection): void;
    // Warning: (ae-forgotten-export) The symbol "SharedConnection" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    removeSharedConnection(connection: SharedConnection): void;
    // Warning: (ae-forgotten-export) The symbol "Pool" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    removeSharedConnectionPool(pool: Pool): void;
    // (undocumented)
    send(typeOrPayload: any, payload?: any): void;
    // (undocumented)
    state: "initializing" | "reconnecting" | "connected";
    // (undocumented)
    useChannel<C extends keyof Channels>(channel: C, params?: Channels[C]["params"], name?: string): ChannelConnection<Channels[C]>;
}

// @public (undocumented)
type User = UserLite | UserDetailed;

// @public (undocumented)
type UserDetailed = UserLite & {
    bannerBlurhash: string | null;
    bannerColor: string | null;
    bannerUrl: string | null;
    birthday: string | null;
    createdAt: DateString;
    description: string | null;
    ffVisibility: "public" | "followers" | "private";
    fields: {
        name: string;
        value: string;
        verified?: boolean;
    }[];
    followersCount: number;
    followingCount: number;
    hasPendingFollowRequestFromYou: boolean;
    hasPendingFollowRequestToYou: boolean;
    isAdmin: boolean;
    isBlocked: boolean;
    isBlocking: boolean;
    isBot: boolean;
    isCat: boolean;
    isFollowed: boolean;
    isFollowing: boolean;
    isLocked: boolean;
    isModerator: boolean;
    isMuted: boolean;
    isRenoteMuted: boolean;
    isSilenced: boolean;
    isSuspended: boolean;
    lang: string | null;
    lastFetchedAt?: DateString;
    location: string | null;
    notesCount: number;
    pinnedNoteIds: ID[];
    pinnedNotes: Note[];
    pinnedPage: Page | null;
    pinnedPageId: string | null;
    publicReactions: boolean;
    securityKeys: boolean;
    twoFactorEnabled: boolean;
    updatedAt: DateString | null;
    uri: string | null;
    url: string | null;
};

// @public (undocumented)
type UserGroup = TODO_2;

// @public (undocumented)
type UserList = {
    id: ID;
    createdAt: DateString;
    name: string;
    userIds: User["id"][];
};

// @public (undocumented)
type UserLite = {
    id: ID;
    username: string;
    host: string | null;
    name: string;
    onlineStatus: "online" | "active" | "offline" | "unknown";
    avatarUrl: string;
    avatarBlurhash: string;
    alsoKnownAs: string[];
    movedToUri: any;
    emojis: {
        name: string;
        url: string;
    }[];
    instance?: {
        name: Instance["name"];
        softwareName: Instance["softwareName"];
        softwareVersion: Instance["softwareVersion"];
        iconUrl: Instance["iconUrl"];
        faviconUrl: Instance["faviconUrl"];
        themeColor: Instance["themeColor"];
    };
};

// @public (undocumented)
type UserSorting = "+follower" | "-follower" | "+createdAt" | "-createdAt" | "+updatedAt" | "-updatedAt";

// Warnings were encountered during analysis:
//
// src/api.types.ts:67:32 - (ae-forgotten-export) The symbol "TODO" needs to be exported by the entry point index.d.ts
// src/api.types.ts:72:25 - (ae-forgotten-export) The symbol "NoParams" needs to be exported by the entry point index.d.ts
// src/api.types.ts:809:3 - (ae-forgotten-export) The symbol "NoteSubmitReq" needs to be exported by the entry point index.d.ts
// src/api.types.ts:1079:3 - (ae-forgotten-export) The symbol "ShowUserReq" needs to be exported by the entry point index.d.ts
// src/streaming.types.ts:46:4 - (ae-forgotten-export) The symbol "FIXME" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```