## API Report File for "iceshrimp-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;
};

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

// @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/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/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/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/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,
        Ad,
        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;
    	enableServiceWorker: boolean;
    	emojis: CustomEmoji[];
    	ads: {
        		id: ID;
        		ratio: number;
        		place: string;
        		url: string;
        		imageUrl: 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)
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"];
    	files: DriveFile[];
    	fileIds: DriveFile["id"][];
    	visibility: "public" | "home" | "followers" | "specified";
    	visibleUserIds?: User["id"][];
    	localOnly?: boolean;
    	channel?: Channel["id"];
    	myReaction?: string;
    	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;
        	}[];
    	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:80:37 - (ae-forgotten-export) The symbol "TODO" needs to be exported by the entry point index.d.ts
// src/api.types.ts:83:28 - (ae-forgotten-export) The symbol "NoParams" needs to be exported by the entry point index.d.ts
// src/api.types.ts:853:5 - (ae-forgotten-export) The symbol "NoteSubmitReq" needs to be exported by the entry point index.d.ts
// src/api.types.ts:1094:3 - (ae-forgotten-export) The symbol "ShowUserReq" needs to be exported by the entry point index.d.ts
// src/streaming.types.ts:56:18 - (ae-forgotten-export) The symbol "FIXME" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```