## API Report File for "cherrypick-js"

> 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;
};

declare namespace acct {
    export {
        parse,
        toString_2 as toString,
        Acct
    }
}
export { acct }

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

// @public (undocumented)
type AdminInstanceMetadata = DetailedInstanceMetadata & {
    blockedHosts: string[];
    app192IconUrl: string | null;
    app512IconUrl: string | null;
    manifestJsonOverride: string;
};

// @public (undocumented)
type Announcement = {
    id: ID;
    createdAt: DateString;
    updatedAt: DateString | null;
    text: string;
    title: string;
    imageUrl: string | null;
    display: 'normal' | 'banner' | 'dialog';
    icon: 'info' | 'warning' | 'error' | 'success';
    needConfirmationToRead: boolean;
    forYou: boolean;
    isRead?: boolean;
};

// @public (undocumented)
type Antenna = {
    id: ID;
    createdAt: DateString;
    name: string;
    keywords: string[][];
    excludeKeywords: string[][];
    src: 'home' | 'all' | 'users' | 'list' | 'group';
    userListId: ID | null;
    userGroupId: ID | null;
    users: 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>;
};

// @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;
            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;
    };
    mediaTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    hybridTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    catTimeline: {
        params: null;
        events: {
            note: (payload: Note) => void;
        };
        receives: null;
    };
    globalTimeline: {
        params: null;
        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 & {
    pinnedPages: string[];
    pinnedClipId: string | null;
    cacheRemoteFiles: boolean;
    cacheRemoteSensitiveFiles: boolean;
    requireSetup: boolean;
    proxyAccountName: string | null;
    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: NoParams;
        res: AdminInstanceMetadata;
    };
    '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/ad/create': {
        req: TODO;
        res: TODO;
    };
    'admin/ad/delete': {
        req: {
            id: Ad['id'];
        };
        res: null;
    };
    'admin/ad/list': {
        req: TODO;
        res: TODO;
    };
    'admin/ad/update': {
        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/abuse-report-resolver/create': {
        req: TODO;
        res: TODO;
    };
    'admin/abuse-report-resolver/list': {
        req: TODO;
        res: TODO;
    };
    'admin/abuse-report-resolver/update': {
        req: TODO;
        res: TODO;
    };
    'admin/abuse-report-resolver/delete': {
        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/adds': {
        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/invite/create': {
        req: TODO;
        res: TODO;
    };
    'admin/invite/list': {
        req: TODO;
        res: TODO;
    };
    'admin/invite/revoke': {
        req: TODO;
        res: TODO;
    };
    'admin/invite/revoke-unused': {
        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;
    };
    '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: {
            folderId?: string;
            name?: string;
            comment?: string;
            isSentisive?: boolean;
            force?: boolean;
        };
        res: DriveFile;
    };
    '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: null;
        res: GalleryPost[];
    };
    'gallery/popular': {
        req: null;
        res: GalleryPost[];
    };
    'gallery/posts': {
        req: {
            limit?: number;
            sinceId?: GalleryPost['id'];
            untilId?: GalleryPost['id'];
        };
        res: GalleryPost[];
    };
    'gallery/posts/create': {
        req: {
            title: GalleryPost['title'];
            description?: GalleryPost['description'];
            fileIds: GalleryPost['fileIds'];
            isSensitive?: GalleryPost['isSensitive'];
        };
        res: GalleryPost;
    };
    'gallery/posts/delete': {
        req: {
            postId: GalleryPost['id'];
        };
        res: null;
    };
    'gallery/posts/like': {
        req: {
            postId: GalleryPost['id'];
        };
        res: null;
    };
    'gallery/posts/show': {
        req: {
            postId: GalleryPost['id'];
        };
        res: GalleryPost;
    };
    'gallery/posts/unlike': {
        req: {
            postId: GalleryPost['id'];
        };
        res: null;
    };
    'gallery/posts/update': {
        req: {
            postId: GalleryPost['id'];
            title: GalleryPost['title'];
            description?: GalleryPost['description'];
            fileIds: GalleryPost['fileIds'];
            isSensitive?: GalleryPost['isSensitive'];
        };
        res: GalleryPost;
    };
    '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/get-word-muted-notes-count': {
        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/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;
            isBot?: boolean;
            isCat?: boolean;
            injectFeaturedNote?: boolean;
            receiveAnnouncementEmail?: boolean;
            alwaysMarkNsfw?: boolean;
            mutedWords?: string[][];
            mutingNotificationTypes?: Notification_2['type'][];
            emailNotificationTypes?: string[];
            alsoKnownAs?: 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/remove-key': {
        req: TODO;
        res: TODO;
    };
    'i/2fa/unregister': {
        req: TODO;
        res: TODO;
    };
    'flash/gen-token': {
        req: TODO;
        res: TODO;
    };
    'invite/create': {
        req: NoParams;
        res: Invite;
    };
    'invite/delete': {
        req: {
            inviteId: Invite['id'];
        };
        res: null;
    };
    'invite/list': {
        req: {
            limit?: number;
            sinceId?: Invite['id'];
            untilId?: Invite['id'];
        };
        res: Invite[];
    };
    'invite/limit': {
        req: NoParams;
        res: InviteLimit;
    };
    '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;
    };
    '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: {
            visibility?: 'public' | 'home' | 'followers' | 'specified';
            visibleUserIds?: User['id'][];
            text?: null | string;
            cw?: null | string;
            viaMobile?: boolean;
            localOnly?: boolean;
            fileIds?: DriveFile['id'][];
            replyId?: null | Note['id'];
            renoteId?: null | Note['id'];
            channelId?: null | Channel['id'];
            poll?: null | {
                choices: string[];
                multiple?: boolean;
                expiresAt?: null | number;
                expiredAfter?: null | number;
            };
            event?: null | {
                title: string;
                start: number;
                end?: null | number;
                metadata: Record<string, string>;
            };
        };
        res: {
            createdNote: Note;
        };
    };
    'notes/delete': {
        req: {
            noteId: Note['id'];
        };
        res: null;
    };
    '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/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/events/search': {
        req: {
            query?: string;
            sinceId?: Note['id'];
            untilId?: Note['id'];
            limit?: number;
            offset?: number;
            users?: User['id'][];
            sinceDate?: number;
            untilDate?: number;
            sortBy?: 'startDate' | 'craetedAt';
            filters?: {
                key: string[];
                values: (string | null)[];
            }[];
        };
        res: Note[];
    };
    '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/test-notification': {
        req: NoParams;
        res: null;
    };
    'notifications/mark-all-as-read': {
        req: NoParams;
        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;
    };
    'signup': {
        req: {
            username: string;
            password: string;
            host?: string;
            invitationCode?: string;
            emailAddress?: string;
            'hcaptcha-response'?: string;
            'g-recaptcha-response'?: string;
            'turnstile-response'?: string;
        };
        res: MeSignup | null;
    };
    'stats': {
        req: NoParams;
        res: Stats;
    };
    'server-info': {
        req: NoParams;
        res: ServerInfo;
    };
    '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/flashs': {
        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;
            };
        };
    };
};

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

// @public (undocumented)
type FetchLike = (input: string, init?: {
    method?: string;
    body?: string;
    credentials?: RequestCredentials;
    cache?: RequestCache;
    headers: {
        [key in string]: string;
    };
}) => 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 = {
    id: ID;
    createdAt: DateString;
    updatedAt: DateString;
    userId: User['id'];
    user: User;
    title: string;
    description: string | null;
    fileIds: DriveFile['id'][];
    files: DriveFile[];
    isSensitive: boolean;
    likedCount: number;
    isLiked?: boolean;
};

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

// @public (undocumented)
type Instance = {
    id: ID;
    firstRetrievedAt: 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;
    isBlocked: 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)
type Invite = {
    id: ID;
    code: string;
    expiresAt: DateString | null;
    createdAt: DateString;
    createdBy: UserLite | null;
    usedBy: UserLite | null;
    usedAt: DateString | null;
    used: boolean;
};

// @public (undocumented)
type InviteLimit = {
    remaining: number;
};

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

// @public (undocumented)
type LiteInstanceMetadata = {
    maintainerName: string | null;
    maintainerEmail: string | null;
    version: string;
    name: string | null;
    shortName: string | null;
    uri: string;
    description: string | null;
    langs: string[];
    tosUrl: string | null;
    repositoryUrl: string;
    feedbackUrl: string;
    disableRegistration: boolean;
    disableLocalTimeline: boolean;
    disableMediaTimeline: boolean;
    disableTimeline: boolean;
    disableGlobalTimeline: boolean;
    driveCapacityPerLocalUserMb: number;
    driveCapacityPerRemoteUserMb: number;
    emailRequiredForSignup: boolean;
    enableHcaptcha: boolean;
    hcaptchaSiteKey: string | null;
    enableRecaptcha: boolean;
    recaptchaSiteKey: string | null;
    enableTurnstile: boolean;
    turnstileSiteKey: string | null;
    swPublickey: string | null;
    themeColor: string | null;
    mascotImageUrl: string | null;
    bannerUrl: string | null;
    serverErrorImageUrl: string | null;
    infoImageUrl: string | null;
    notFoundImageUrl: string | null;
    iconUrl: string | null;
    backgroundImageUrl: string | null;
    logoImageUrl: string | null;
    maxNoteTextLength: number;
    enableEmail: boolean;
    enableTwitterIntegration: boolean;
    enableGithubIntegration: boolean;
    enableDiscordIntegration: boolean;
    enableServiceWorker: boolean;
    emojis: CustomEmoji[];
    defaultDarkTheme: string | null;
    defaultLightTheme: string | null;
    ads: {
        id: ID;
        ratio: number;
        place: string;
        url: string;
        imageUrl: string;
    }[];
    translatorAvailable: boolean;
    serverRules: 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;
    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;
    receiveAnnouncementEmail: boolean;
    usePasswordLessLogin: boolean;
    unreadAnnouncements: Announcement[];
    twoFactorBackupCodesStock: 'full' | 'partial' | 'none';
    [other: string]: any;
};

// @public (undocumented)
type MeDetailedWithSecret = MeDetailed & {
    email: string;
    emailVerified: boolean;
    securityKeysList: {
        id: string;
        name: string;
        lastUsed: string;
    }[];
};

// @public (undocumented)
type MeSignup = MeDetailedWithSecret & {
    token: string;
};

// @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 ModerationLog = {
    id: ID;
    createdAt: DateString;
    userId: User['id'];
    user: UserDetailed | null;
} & ({
    type: 'updateServerSettings';
    info: ModerationLogPayloads['updateServerSettings'];
} | {
    type: 'suspend';
    info: ModerationLogPayloads['suspend'];
} | {
    type: 'unsuspend';
    info: ModerationLogPayloads['unsuspend'];
} | {
    type: 'updateUserNote';
    info: ModerationLogPayloads['updateUserNote'];
} | {
    type: 'addCustomEmoji';
    info: ModerationLogPayloads['addCustomEmoji'];
} | {
    type: 'updateCustomEmoji';
    info: ModerationLogPayloads['updateCustomEmoji'];
} | {
    type: 'deleteCustomEmoji';
    info: ModerationLogPayloads['deleteCustomEmoji'];
} | {
    type: 'assignRole';
    info: ModerationLogPayloads['assignRole'];
} | {
    type: 'unassignRole';
    info: ModerationLogPayloads['unassignRole'];
} | {
    type: 'updateRole';
    info: ModerationLogPayloads['updateRole'];
} | {
    type: 'deleteRole';
    info: ModerationLogPayloads['deleteRole'];
} | {
    type: 'clearQueue';
    info: ModerationLogPayloads['clearQueue'];
} | {
    type: 'promoteQueue';
    info: ModerationLogPayloads['promoteQueue'];
} | {
    type: 'deleteDriveFile';
    info: ModerationLogPayloads['deleteDriveFile'];
} | {
    type: 'deleteNote';
    info: ModerationLogPayloads['deleteNote'];
} | {
    type: 'createGlobalAnnouncement';
    info: ModerationLogPayloads['createGlobalAnnouncement'];
} | {
    type: 'createUserAnnouncement';
    info: ModerationLogPayloads['createUserAnnouncement'];
} | {
    type: 'updateGlobalAnnouncement';
    info: ModerationLogPayloads['updateGlobalAnnouncement'];
} | {
    type: 'updateUserAnnouncement';
    info: ModerationLogPayloads['updateUserAnnouncement'];
} | {
    type: 'deleteGlobalAnnouncement';
    info: ModerationLogPayloads['deleteGlobalAnnouncement'];
} | {
    type: 'deleteUserAnnouncement';
    info: ModerationLogPayloads['deleteUserAnnouncement'];
} | {
    type: 'resetPassword';
    info: ModerationLogPayloads['resetPassword'];
} | {
    type: 'suspendRemoteInstance';
    info: ModerationLogPayloads['suspendRemoteInstance'];
} | {
    type: 'unsuspendRemoteInstance';
    info: ModerationLogPayloads['unsuspendRemoteInstance'];
} | {
    type: 'markSensitiveDriveFile';
    info: ModerationLogPayloads['markSensitiveDriveFile'];
} | {
    type: 'unmarkSensitiveDriveFile';
    info: ModerationLogPayloads['unmarkSensitiveDriveFile'];
});

// @public (undocumented)
export const moderationLogTypes: readonly ["updateServerSettings", "suspend", "unsuspend", "updateUserNote", "addCustomEmoji", "updateCustomEmoji", "deleteCustomEmoji", "assignRole", "unassignRole", "updateRole", "deleteRole", "clearQueue", "promoteQueue", "deleteDriveFile", "deleteNote", "createGlobalAnnouncement", "createUserAnnouncement", "updateGlobalAnnouncement", "updateUserAnnouncement", "deleteGlobalAnnouncement", "deleteUserAnnouncement", "resetPassword", "suspendRemoteInstance", "unsuspendRemoteInstance", "markSensitiveDriveFile", "unmarkSensitiveDriveFile"];

// @public (undocumented)
export const mutedNoteReasons: readonly ["word", "manual", "spam", "other"];

// @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'];
    event?: {
        title: string;
        start: DateString;
        end: DateString | null;
        metadata: Record<string, string>;
    };
    files: DriveFile[];
    fileIds: DriveFile['id'][];
    visibility: 'public' | 'home' | 'followers' | 'specified';
    visibleUserIds?: User['id'][];
    localOnly?: boolean;
    myReaction?: string;
    reactions: Record<string, number>;
    renoteCount: number;
    repliesCount: number;
    clippedCount?: number;
    poll?: {
        expiresAt: DateString | null;
        multiple: boolean;
        choices: {
            isVoted: boolean;
            text: string;
            votes: number;
        }[];
    };
    emojis: {
        name: string;
        url: string;
    }[];
    uri?: string;
    url?: string;
    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: 'note';
    user: User;
    userId: User['id'];
    note: Note;
} | {
    type: 'pollEnded';
    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;
} | {
    type: 'test';
});

// @public (undocumented)
export const notificationTypes: readonly ["note", "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)
function parse(acct: string): Acct;

// @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;
    // (undocumented)
    heartbeat(): void;
    // (undocumented)
    ping(): 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: string): void;
    // (undocumented)
    send(typeOrPayload: string, payload: any): void;
    // (undocumented)
    send(typeOrPayload: Record<string, any> | 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)
function toString_2(acct: Acct): string;

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

// @public (undocumented)
type UserDetailed = UserLite & {
    alsoKnownAs: string[];
    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;
    }[];
    verifiedLinks: string[];
    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;
    isSilenced: boolean;
    isSuspended: boolean;
    lang: string | null;
    lastFetchedAt?: DateString;
    location: string | null;
    movedTo: string;
    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;
    notify: 'normal' | 'none';
};

// @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;
    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:16:32 - (ae-forgotten-export) The symbol "TODO" needs to be exported by the entry point index.d.ts
// src/api.types.ts:18:25 - (ae-forgotten-export) The symbol "NoParams" needs to be exported by the entry point index.d.ts
// src/api.types.ts:659:18 - (ae-forgotten-export) The symbol "ShowUserReq" needs to be exported by the entry point index.d.ts
// src/entities.ts:587:2 - (ae-forgotten-export) The symbol "ModerationLogPayloads" needs to be exported by the entry point index.d.ts
// src/streaming.types.ts:33:4 - (ae-forgotten-export) The symbol "FIXME" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```