import { Beatmap } from "./namespaces/Beatmap.js"; import { Beatmapset } from "./namespaces/Beatmapset.js"; import { Changelog } from "./namespaces/Changelog.js"; import { Chat } from "./namespaces/Chat.js"; import { Comment } from "./namespaces/Comment.js"; import { Event } from "./namespaces/Event.js"; import { Forum } from "./namespaces/Forum.js"; import { Home } from "./namespaces/Home.js"; import { Match } from "./namespaces/Match.js"; import { Miscellaneous } from "./namespaces/Miscellaneous.js"; import { Multiplayer } from "./namespaces/Multiplayer.js"; import { NewsPost } from "./namespaces/NewsPost.js"; import { Score } from "./namespaces/Score.js"; import { Spotlight } from "./namespaces/Spotlight.js"; import { Team } from "./namespaces/Team.js"; import { User } from "./namespaces/User.js"; import { WikiPage } from "./namespaces/Wiki.js"; export { Beatmap, Beatmapset, Changelog, Chat, Comment, Event, Forum, Home, Match, Miscellaneous, Multiplayer, NewsPost, Score, Spotlight, Team, User, WikiPage, }; /** The name "Ruleset" is synonymous with "Game mode" or "Gamemode" */ export declare enum Ruleset { osu = 0, taiko = 1, /** Better known as "osu!catch" or "Catch the Beat", "fruits" is the name used throughout the API */ fruits = 2, mania = 3 } /** A major style of a {@link Ruleset}, currently only refers to osu!mania's 4k and 7k */ export declare enum Variant { "" = 0, "4k" = 4, "7k" = 7 } /** Also known as "Game Modifier" https://osu.ppy.sh/wiki/en/Gameplay/Game_modifier */ export type Mod = { acronym: string; /** Lazer allows mods to be customized, applied customizations will appear here */ settings?: { [k: string]: any; }; }; /** {@link Scope}s that are compatible with delegation (for bot accounts) https://osu.ppy.sh/docs/#client-credentials-delegation */ export type DelegableScope = "chat.write" | "chat.write_manage" | "delegate" | "forum.write" | "forum.write_manage" | "group_permissions" | "multiplayer.write_manage"; /** {@link Scope}s that cannot be used with the {@link DelegableScope} "delegate" */ export type UndelegableScope = "chat.read" | "friends.read" | "identify" | "public"; /** * Scopes determine what the API instance can do as a user! https://osu.ppy.sh/docs/index.html#scopes * @remarks "identify" is always implicitly provided, **"public" is implicitly needed for almost everything!!** * The need for the "public" scope is only made explicit when the method can only be used as a user (non-guest) */ export type Scope = UndelegableScope | DelegableScope; /** * Generates a link for users to click on in order to use your application! * @param client_id The Client ID, find it at https://osu.ppy.sh/home/account/edit#new-oauth-application * @param redirect_uri The specified Application Callback URL, aka where the user will be redirected upon clicking the button to authorize * @param scopes What you want to do with/as the user * @param server The API server (defaults to **https://osu.ppy.sh**, leave as is if you don't know exactly what you're doing) * @returns The link people should click on */ export declare function generateAuthorizationURL(client_id: number, redirect_uri: string, scopes: Scope[], server?: string): string; /** If the {@link API} throws an error, it should always be an {@link APIError}! */ export declare class APIError extends Error { message: string; server: API["server"]; method: Parameters[0]; endpoint: Parameters[1]; parameters: Parameters[2]; response?: { status_code: number; json: unknown; } | undefined; original_error?: Error | undefined; /** * @param message The reason why things didn't go as expected * @param server The server to which the request was sent * @param method The method used for this request (like "get", "post", etc...) * @param endpoint The type of resource that was requested from the server * @param parameters The filters that were used to specify what resource was wanted * @param response The status code and the original body that was returned by the server, if there is one * @param original_error The error that caused the api to throw an {@link APIError} in the first place, if there is one */ constructor(message: string, server: API["server"], method: Parameters[0], endpoint: Parameters[1], parameters: Parameters[2], response?: { status_code: number; json: unknown; } | undefined, original_error?: Error | undefined); } /** An API instance is needed to make requests to the server! */ export declare class API { /** If you have the credentials for a client and do not wish to act on behalf of a user, you might want to use this constructor */ constructor(client_id: API["client_id"], client_secret: API["client_secret"], settings?: Partial); /** If you have the credentials for a client as well as a code that allows to act on behalf of a user, you might want to use this constructor */ constructor(client_id: API["client_id"], client_secret: API["client_secret"], redirect_uri: string, code: string, settings?: Partial); /** If you'd like the freedom to set an {@link API.access_token} that you already have and avoid specifying client credentials, this constructor might be for you */ constructor(settings: Partial); /** * The alternative way of creating an API instance, awaiting this method waits for the server's authorization * and allows you to catch errors if the authorization fails * @param client_id The ID of your client, which you can get on https://osu.ppy.sh/home/account/edit#oauth * @param client_secret The Secret of your client, which you can get or reset on https://osu.ppy.sh/home/account/edit#oauth * @param user If the instance is supposed to represent a user, use their Authorization Code and your application's Callback URL (keep undefined otherwise) * @param settings Additional settings you'd like to specify now rather than later, check out the Accessors at https://osu-v2.taevas.xyz/classes/API.html */ static createAsync(client_id: API["client_id"], client_secret: API["client_secret"], user?: { /** The Application Callback URL; Where the User has been redirected to after saying "okay" to your application doing stuff */ redirect_uri: string; /** The code that appeared as a GET argument when they got redirected to the Application Callback URL (`redirect_uri`) */ code: string; }, settings?: Partial): Promise; private _access_token; /** The key that allows you to talk with the API */ get access_token(): string; set access_token(token: string); private _refresh_token?; /** * Valid for an unknown amount of time, it allows you to get a new token without going through the Authorization Code Grant again! * Use {@link API.setNewToken} to make use of this token * @remarks There is no refresh_token if the Authorization Code Grant hasn't been done, it would be pointless to have one in that case */ get refresh_token(): string | undefined; set refresh_token(token: string | undefined); private _token_type; /** Should always be "Bearer" */ get token_type(): string; set token_type(token: string); private _expires; /** The expiration date of your {@link API.access_token} */ get expires(): Date; set expires(date: Date); private _client_id; /** The ID of your client, which you can get on https://osu.ppy.sh/home/account/edit#oauth */ get client_id(): number; set client_id(client_id: number); private _client_secret; /** The Secret of your client, which you can get or reset on https://osu.ppy.sh/home/account/edit#oauth */ get client_secret(): string; set client_secret(client_secret: string); private _server; /** The base url of the server where the requests should land (defaults to **https://osu.ppy.sh**) */ get server(): string; set server(server: string); private _route_api; /** Used by practically every method to interact with the {@link API.server} (defaults to **[api, v2]**) */ get route_api(): (string | number)[]; set route_api(route_api: (string | number)[]); private _route_token; /** Used for getting an {@link API.access_token} and using your {@link API.refresh_token} (defaults to **[oauth, token]**) */ get route_token(): (string | number)[]; set route_token(route_token: (string | number)[]); private _scopes; /** The {@link Scope}s your application has, assuming it acts as a user or a delegated bot account */ get scopes(): Scope[]; set scopes(scopes: Scope[]); private _headers; /** Used in practically all requests, those are all the headers the package uses excluding `Authorization`, the one with the token */ get headers(): { [key: string]: any; }; set headers(headers: { [key: string]: any; }); private _user?; /** The osu! user id of the user who went through the Authorization Code Grant */ get user(): number | undefined; set user(user: number | undefined); private number_of_requests; /** Has {@link API.setNewToken} been called and not yet returned anything? */ private is_setting_token; /** * If {@link API.setNewToken} has been called, you can wait for it to be done through this promise * @privateRemarks Its initial form is a promise that never resolves, this is intentional so to avoid a race condition between the request that fetches the initial token and the first request that a user may make, though I'm unsure how reliable this is... */ private token_promise; /** * This creates a new {@link API.access_token}, alongside a new {@link API.refresh_token} if arguments are provided or if a refresh_token already exists * @remarks The API object requires a {@link API.client_id} and a {@link API.client_secret} to successfully get any token * @returns Whether or not the token has changed (**should be true** as otherwise the server would complain and an {@link APIError} would be thrown to give you some details) */ setNewToken(authorization?: { redirect_uri: string; code: string; }): Promise; /** * Revoke your current token! **This will revoke the {@link API.refresh_token} as well if it exists**, so use this with care * @remarks Uses {@link API.route_api} instead of {@link API.route_token}, as normally expected by the server */ revokeToken(): Promise; private _set_token_on_creation; /** If true, when creating your API object, a call to {@link API.setNewToken} will be automatically made (defaults to **true**) */ get set_token_on_creation(): boolean; set set_token_on_creation(bool: boolean); private _set_token_on_401; /** If true, upon failing a request due to a 401, it will call {@link API.setNewToken} (defaults to **true**) */ get set_token_on_401(): boolean; set set_token_on_401(bool: boolean); private _set_token_on_expires; /** * If true, the application will silently call {@link API.setNewToken} when the {@link API.access_token} is set to expire, * as determined by {@link API.expires} (defaults to **true**) * @remarks For this to work, the token must have been set by {@link API.setNewToken} (no matter if the method itself was called manually or not) */ get set_token_on_expires(): boolean; set set_token_on_expires(enabled: boolean); private _token_timer?; /** The Timeout (set by {@link API.setNewToken}) which, once expired, if {@link API.set_token_on_expires} is true, will call {@link API.setNewToken} */ get token_timer(): API["_token_timer"]; set token_timer(timer: NodeJS.Timeout); private _verbose?; /** Which events should be logged (defaults to **none**) */ get verbose(): "none" | "all" | "errors" | undefined; set verbose(verbose: "none" | "all" | "errors" | undefined); private _timeout; /** * The maximum **amount of seconds** requests should take before returning an answer (defaults to **20**) * @remarks 0 means no maximum, no timeout */ get timeout(): number; set timeout(timeout: number); private _signal?; /** The `AbortSignal` used in every request */ get signal(): AbortSignal | undefined; set signal(signal: AbortSignal | undefined); private _retry_maximum_amount; /** * How many retries maximum before throwing an {@link APIError} (defaults to **4**) * @remarks Pro tip: Set that to 0 to **completely** disable retries! */ get retry_maximum_amount(): number; set retry_maximum_amount(retry_maximum_amount: number); private _retry_delay; /** In seconds, how long should it wait after a request failed before retrying? (defaults to **2**) */ get retry_delay(): number; set retry_delay(retry_delay: number); private _retry_on_new_token; /** Should it retry a request upon successfully setting a new token due to {@link API.set_token_on_401} being `true`? (defaults to **true**) */ get retry_on_new_token(): boolean; set retry_on_new_token(retry_on_new_token: boolean); private _retry_on_status_codes; /** Upon failing a request and receiving a response, because of which received status code should the request be retried? (defaults to **[429]**) */ get retry_on_status_codes(): number[]; set retry_on_status_codes(retry_on_status_codes: number[]); private _retry_on_timeout; /** Should it retry a request if that request failed because it has been aborted by the {@link API.timeout}? (defaults to **false**) */ get retry_on_timeout(): boolean; set retry_on_timeout(retry_on_timeout: boolean); /** * Use this instead of `console.log` to log any information * @param is_error Is the logging happening because of an error? * @param to_log Whatever you would put between the parentheses of `console.log()` */ private log; /** * Use this instead of a straight `fetch` to connect to the server * @param is_token_related Is the request related to getting a token? If so, uses `route_token` and bypasses `token_promise` * @param method The HTTP method https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods * @param endpoint The endpoint, may or may not be listed on https://osu.ppy.sh/docs/ * @param parameters GET query in object form, or the request body if the method is not GET * @param info Relevant only when `fetch` calls itself, avoid setting it * @remarks Consider using the higher-level method called {@link API.request} */ private fetch; /** * The function that directly communicates with the API! Almost all functions of the API object uses this function! * @param method The type of request, each endpoint uses a specific one (if it uses multiple, the intent and parameters become different) * @param endpoint What comes in the URL after `api/`, **DO NOT USE TEMPLATE LITERALS (\`) OR THE ADDITION OPERATOR (+), put everything separately for type safety** * @param parameters The things to specify in the request, such as the beatmap_id when looking for a beatmap * @returns A Promise with the API's response */ request(method: "get" | "post" | "put" | "delete", endpoint: Array, parameters?: { [k: string]: any; }): Promise; /** {@inheritDoc Beatmap.lookup} @group Beatmap Methods */ readonly lookupBeatmap: typeof Beatmap.lookup; /** {@inheritDoc Beatmap.getOne} @group Beatmap Methods */ readonly getBeatmap: typeof Beatmap.getOne; /** {@inheritDoc Beatmap.getMultiple} @group Beatmap Methods */ readonly getBeatmaps: typeof Beatmap.getMultiple; /** {@inheritDoc Beatmap.DifficultyAttributes.get} @group Beatmap Methods */ readonly getBeatmapDifficultyAttributes: typeof Beatmap.DifficultyAttributes.get; /** {@inheritDoc Beatmap.DifficultyAttributes.getOsu} @group Beatmap Methods */ readonly getBeatmapDifficultyAttributesOsu: typeof Beatmap.DifficultyAttributes.getOsu; /** {@inheritDoc Beatmap.DifficultyAttributes.getTaiko} @group Beatmap Methods */ readonly getBeatmapDifficultyAttributesTaiko: typeof Beatmap.DifficultyAttributes.getTaiko; /** {@inheritDoc Beatmap.DifficultyAttributes.getFruits} @group Beatmap Methods */ readonly getBeatmapDifficultyAttributesFruits: typeof Beatmap.DifficultyAttributes.getFruits; /** {@inheritDoc Beatmap.DifficultyAttributes.getMania} @group Beatmap Methods */ readonly getBeatmapDifficultyAttributesMania: typeof Beatmap.DifficultyAttributes.getMania; /** {@inheritDoc Beatmap.getScores} @group Beatmap Methods */ readonly getBeatmapScores: typeof Beatmap.getScores; /** {@inheritDoc Beatmap.getUserScore} @group Beatmap Methods */ readonly getBeatmapUserScore: typeof Beatmap.getUserScore; /** {@inheritDoc Beatmap.getUserScores} @group Beatmap Methods */ readonly getBeatmapUserScores: typeof Beatmap.getUserScores; /** {@inheritDoc Beatmap.UserTag.getAll} @group Beatmap Methods */ readonly getBeatmapUserTags: typeof Beatmap.UserTag.getAll; /** {@inheritDoc Beatmap.Pack.getOne} @group Beatmap Methods */ readonly getBeatmapPack: typeof Beatmap.Pack.getOne; /** {@inheritDoc Beatmap.Pack.getMultiple} @group Beatmap Methods */ readonly getBeatmapPacks: typeof Beatmap.Pack.getMultiple; /** {@inheritDoc Beatmapset.search} @group Beatmapset Methods */ readonly searchBeatmapsets: typeof Beatmapset.search; /** {@inheritDoc Beatmapset.lookup} @group Beatmapset Methods */ readonly lookupBeatmapset: typeof Beatmapset.lookup; /** {@inheritDoc Beatmapset.getOne} @group Beatmapset Methods */ readonly getBeatmapset: typeof Beatmapset.getOne; /** {@inheritDoc Beatmapset.Discussion.getMultiple} @group Beatmapset Methods */ readonly getBeatmapsetDiscussions: typeof Beatmapset.Discussion.getMultiple; /** {@inheritDoc Beatmapset.Discussion.Post.getMultiple} @group Beatmapset Methods */ readonly getBeatmapsetDiscussionPosts: typeof Beatmapset.Discussion.Post.getMultiple; /** {@inheritDoc Beatmapset.Discussion.Vote.getMultiple} @group Beatmapset Methods */ readonly getBeatmapsetDiscussionVotes: typeof Beatmapset.Discussion.Vote.getMultiple; /** {@inheritDoc Beatmapset.Event.getMultiple} @group Beatmapset Methods */ readonly getBeatmapsetEvents: typeof Beatmapset.Event.getMultiple; /** {@inheritDoc Changelog.Build.lookup} @group Changelog Methods */ readonly lookupChangelogBuild: typeof Changelog.Build.lookup; /** {@inheritDoc Changelog.Build.getOne} @group Changelog Methods */ readonly getChangelogBuild: typeof Changelog.Build.getOne; /** {@inheritDoc Changelog.Build.getMultiple} @group Changelog Methods */ readonly getChangelogBuilds: typeof Changelog.Build.getMultiple; /** {@inheritDoc Changelog.UpdateStream.getAll} @group Changelog Methods */ readonly getChangelogStreams: typeof Changelog.UpdateStream.getAll; /** {@inheritDoc Chat.keepAlive} @group Chat Methods */ readonly keepChatAlive: typeof Chat.keepAlive; /** {@inheritDoc Chat.Message.getMultiple} @group Chat Methods */ readonly getChatMessages: typeof Chat.Message.getMultiple; /** {@inheritDoc Chat.Message.send} @group Chat Methods */ readonly sendChatMessage: typeof Chat.Message.send; /** {@inheritDoc Chat.Message.sendPrivate} @group Chat Methods */ readonly sendChatPrivateMessage: typeof Chat.Message.sendPrivate; /** {@inheritDoc Chat.Channel.getOne} @group Chat Methods */ readonly getChatChannel: typeof Chat.Channel.getOne; /** {@inheritDoc Chat.Channel.getAll} @group Chat Methods */ readonly getChatChannels: typeof Chat.Channel.getAll; /** {@inheritDoc Chat.Channel.markAsRead} @group Chat Methods */ readonly markChatChannelAsRead: typeof Chat.Channel.markAsRead; /** {@inheritDoc Chat.Channel.createPrivate} @group Chat Methods */ readonly createChatPrivateChannel: typeof Chat.Channel.createPrivate; /** {@inheritDoc Chat.Channel.createAnnouncement} @group Chat Methods */ readonly createChatAnnouncementChannel: typeof Chat.Channel.createAnnouncement; /** {@inheritDoc Chat.Channel.joinOne} @group Chat Methods */ readonly joinChatChannel: typeof Chat.Channel.joinOne; /** {@inheritDoc Chat.Channel.leaveOne} @group Chat Methods */ readonly leaveChatChannel: typeof Chat.Channel.leaveOne; /** {@inheritDoc Chat.Websocket.getHeaders} @group Chat Methods */ readonly getChatWebsocketHeaders: typeof Chat.Websocket.getHeaders; /** {@inheritDoc Chat.Websocket.generate} @group Chat Methods */ readonly generateChatWebsocket: typeof Chat.Websocket.generate; /** {@inheritDoc Comment.getOne} @group Comment Methods */ readonly getComment: typeof Comment.getOne; /** {@inheritDoc Comment.getMultiple} @group Comment Methods */ readonly getComments: typeof Comment.getMultiple; /** {@inheritDoc Event.getMultiple} @group Event Methods */ readonly getEvents: typeof Event.getMultiple; /** {@inheritDoc Forum.getOne} @group Forum Methods */ readonly getForum: typeof Forum.getOne; /** {@inheritDoc Forum.getMultiple} @group Forum Methods */ readonly getForums: typeof Forum.getMultiple; /** {@inheritDoc Forum.Topic.getOne} @group Forum Methods */ readonly getForumTopic: typeof Forum.Topic.getOne; /** {@inheritDoc Forum.Topic.getMultiple} @group Forum Methods */ readonly getForumTopics: typeof Forum.Topic.getMultiple; /** {@inheritDoc Forum.Topic.create} @group Forum Methods */ readonly createForumTopic: typeof Forum.Topic.create; /** {@inheritDoc Forum.Topic.reply} @group Forum Methods */ readonly replyForumTopic: typeof Forum.Topic.reply; /** {@inheritDoc Forum.Topic.editTitle} @group Forum Methods */ readonly editForumTopicTitle: typeof Forum.Topic.editTitle; /** {@inheritDoc Forum.Topic.lock} @group Forum Methods */ readonly lockForumTopic: typeof Forum.Topic.lock; /** {@inheritDoc Forum.Topic.pin} @group Forum Methods */ readonly pinForumTopic: typeof Forum.Topic.pin; /** {@inheritDoc Forum.Post.edit} @group Forum Methods */ readonly editForumPost: typeof Forum.Post.edit; /** {@inheritDoc Home.Search.getUsers} @group Home Methods */ readonly searchUser: typeof Home.Search.getUsers; /** {@inheritDoc Home.Search.getWikiPages} @group Home Methods */ readonly searchWiki: typeof Home.Search.getWikiPages; /** {@inheritDoc Match.getOne} @group Match Methods */ readonly getMatch: typeof Match.getOne; /** {@inheritDoc Match.getMultiple} @group Match Methods */ readonly getMatches: typeof Match.getMultiple; /** {@inheritDoc Miscellaneous.Country.getRanking} @group Miscellaneous Methods */ readonly getCountryRanking: typeof Miscellaneous.Country.getRanking; /** {@inheritDoc Miscellaneous.getSeasonalBackgrounds} @group Miscellaneous Methods */ readonly getSeasonalBackgrounds: typeof Miscellaneous.getSeasonalBackgrounds; /** {@inheritDoc Multiplayer.Room.getOne} @group Multiplayer Methods */ readonly getRoom: typeof Multiplayer.Room.getOne; /** {@inheritDoc Multiplayer.Room.getMultiple} @group Multiplayer Methods */ readonly getRooms: typeof Multiplayer.Room.getMultiple; /** {@inheritDoc Multiplayer.Room.Leader.getMultiple} @group Multiplayer Methods */ readonly getRoomLeaderboard: typeof Multiplayer.Room.Leader.getMultiple; /** {@inheritDoc Multiplayer.Room.PlaylistItem.getScores} @group Multiplayer Methods */ readonly getPlaylistItemScores: typeof Multiplayer.Room.PlaylistItem.getScores; /** {@inheritDoc Multiplayer.Room.Event.getAll} @group Multiplayer Methods */ readonly getRoomEvents: typeof Multiplayer.Room.Event.getAll; /** {@inheritDoc NewsPost.getOne} @group NewsPost Methods */ readonly getNewsPost: typeof NewsPost.getOne; /** {@inheritDoc NewsPost.getMultiple} @group NewsPost Methods */ readonly getNewsPosts: typeof NewsPost.getMultiple; /** {@inheritDoc Score.getOne} @group Score Methods */ readonly getScore: typeof Score.getOne; /** {@inheritDoc Score.getSome} @group Score Methods */ readonly getScores: typeof Score.getSome; /** {@inheritDoc Score.getReplay} @group Score Methods */ readonly getReplay: typeof Score.getReplay; /** {@inheritDoc Spotlight.getAll} @group Spotlight Methods */ readonly getSpotlights: typeof Spotlight.getAll; /** {@inheritDoc Spotlight.getRanking} @group Spotlight Methods */ readonly getSpotlightRanking: typeof Spotlight.getRanking; /** {@inheritDoc Team.getOne} @group Team Methods */ readonly getTeam: typeof Team.getOne; /** {@inheritDoc User.getResourceOwner} @group User Methods */ readonly getResourceOwner: typeof User.getResourceOwner; /** {@inheritDoc User.getOne} @group User Methods */ readonly getUser: typeof User.getOne; /** {@inheritDoc User.getMultiple} @group User Methods */ readonly getUsers: typeof User.getMultiple; /** {@inheritDoc User.lookupMultiple} @group User Methods */ readonly lookupUsers: typeof User.lookupMultiple; /** {@inheritDoc User.getScores} @group User Methods */ readonly getUserScores: typeof User.getScores; /** {@inheritDoc User.getBeatmaps} @group User Methods */ readonly getUserBeatmaps: typeof User.getBeatmaps; /** {@inheritDoc User.getPassedBeatmaps} @group User Methods */ readonly getUserPassedBeatmaps: typeof User.getPassedBeatmaps; /** {@inheritDoc User.getMostPlayed} @group User Methods */ readonly getUserMostPlayed: typeof User.getMostPlayed; /** {@inheritDoc User.getRecentActivity} @group User Methods */ readonly getUserRecentActivity: typeof User.getRecentActivity; /** {@inheritDoc User.getRanking} @group User Methods */ readonly getUserRanking: typeof User.getRanking; /** {@inheritDoc User.getFriends} @group User Methods */ readonly getFriends: typeof User.getFriends; /** {@inheritDoc User.getFavouriteBeatmapsetsIds} @group User Methods */ readonly getFavouriteBeatmapsetsIds: typeof User.getFavouriteBeatmapsetsIds; /** {@inheritDoc User.Kudosu.getHistory} @group User Methods */ readonly getUserKudosuHistory: typeof User.Kudosu.getHistory; /** {@inheritDoc User.Kudosu.getRanking} @group User Methods */ readonly getKudosuRanking: typeof User.Kudosu.getRanking; /** {@inheritDoc WikiPage.getOne} @group WikiPage Methods */ readonly getWikiPage: typeof WikiPage.getOne; }