import { CreateAxiosDefaults } from 'axios';
import type { AxiosInstance, AxiosResponse, CancelToken } from 'axios';
export declare abstract class OtrApiWrapperBase {
    protected configuration: IOtrApiWrapperConfiguration;
    constructor(configuration?: IOtrApiWrapperConfiguration);
    protected getBaseUrl(..._: any[]): string;
    /**
     * Exposes the underlying axios client for configuration
     */
    configureClient(configure: (instance: AxiosInstance) => Promise<void> | void): Promise<void>;
}
/**
* Request parameters available for use when requesting {@link AdminNotesWrapper.prototype.createNote | api/v1/[entity]/[entityId]/notes}
*/
export type AdminNotesCreateNoteRequestParams = {
    /**
    * (required) Entity id
    */
    entityId: number;
    /**
    * (required) Type of entity to target for admin note actions
    */
    entity: AdminNoteRouteTarget;
    /**
    * (required) Content of the admin note
    */
    body: string;
};
/**
* Request parameters available for use when requesting {@link AdminNotesWrapper.prototype.listNotes | api/v1/[entity]/[entityId]/notes}
*/
export type AdminNotesListNotesRequestParams = {
    /**
    * (required) Entity id
    */
    entityId: number;
    /**
    * (required) Type of entity to target for admin note actions
    */
    entity: AdminNoteRouteTarget;
};
/**
* Request parameters available for use when requesting {@link AdminNotesWrapper.prototype.updateNote | api/v1/[entity]/notes/[noteId]}
*/
export type AdminNotesUpdateNoteRequestParams = {
    /**
    * (required) Admin note id
    */
    noteId: number;
    /**
    * (required) Type of entity to target for admin note actions
    */
    entity: AdminNoteRouteTarget;
    /**
    * (required) New content of the admin note
    */
    body: string;
};
/**
* Request parameters available for use when requesting {@link AdminNotesWrapper.prototype.deleteNote | api/v1/[entity]/notes/[noteId]}
*/
export type AdminNotesDeleteNoteRequestParams = {
    /**
    * (required) Admin note id
    */
    noteId: number;
    /**
    * (required) Type of entity to target for admin note actions
    */
    entity: AdminNoteRouteTarget;
};
export declare class AdminNotesWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Create an admin note for an entity
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link AdminNotesCreateNoteRequestParams})
    * @return Returns the created admin note
    */
    createNote(params: AdminNotesCreateNoteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AdminNoteDTO>>;
    protected processCreateNote(response: AxiosResponse): Promise<OtrApiResponse<AdminNoteDTO>>;
    /**
    * List admin notes for an entity
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link AdminNotesListNotesRequestParams})
    * @return Returns all admin notes for the entity
    */
    listNotes(params: AdminNotesListNotesRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AdminNoteDTO[]>>;
    protected processListNotes(response: AxiosResponse): Promise<OtrApiResponse<AdminNoteDTO[]>>;
    /**
    * Update an admin note
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link AdminNotesUpdateNoteRequestParams})
    * @return Returns the updated admin note
    */
    updateNote(params: AdminNotesUpdateNoteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AdminNoteDTO>>;
    protected processUpdateNote(response: AxiosResponse): Promise<OtrApiResponse<AdminNoteDTO>>;
    /**
    * Delete an admin note
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link AdminNotesDeleteNoteRequestParams})
    * @return The admin note was deleted
    */
    deleteNote(params: AdminNotesDeleteNoteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDeleteNote(response: AxiosResponse): Promise<OtrApiResponse<void>>;
}
/**
* Request parameters available for use when requesting {@link AuditWrapper.prototype.getEntityAudits | api/v1/audit/entity/[entityType]/[entityId]}
*/
export type AuditGetEntityAuditsRequestParams = {
    /**
    * (required) The type of entity to get audits for
    */
    entityType: AuditEntityType;
    /**
    * (required) The ID of the entity to get audits for
    */
    entityId: number;
};
/**
* Request parameters available for use when requesting {@link AuditWrapper.prototype.getUserAudits | api/v1/audit/user/[userId]}
*/
export type AuditGetUserAuditsRequestParams = {
    /**
    * (required) The ID of the user to get audits for
    */
    userId: number;
};
export declare class AuditWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get audits for a specific entity
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link AuditGetEntityAuditsRequestParams})
    * @return Returns a list of audits for the specified entity
    */
    getEntityAudits(params: AuditGetEntityAuditsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AuditDTO[]>>;
    protected processGetEntityAudits(response: AxiosResponse): Promise<OtrApiResponse<AuditDTO[]>>;
    /**
    * Get audits performed by a specific user
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link AuditGetUserAuditsRequestParams})
    * @return Returns a list of audits performed by the specified user
    */
    getUserAudits(params: AuditGetUserAuditsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AuditDTO[]>>;
    protected processGetUserAudits(response: AxiosResponse): Promise<OtrApiResponse<AuditDTO[]>>;
}
/**
* Request parameters available for use when requesting {@link AuthWrapper.prototype.login | api/v1/auth/login}
*/
export type AuthLoginRequestParams = {
    /**
    * (optional) Redirects the client to the given uri after login
    */
    redirectUri?: string | undefined;
};
/**
* Request parameters available for use when requesting {@link AuthWrapper.prototype.logout | api/v1/auth/logout}
*/
export type AuthLogoutRequestParams = {
    /**
    * (optional) Redirects the client to the given uri after logout
    */
    redirectUri?: string | undefined;
};
/**
* Request parameters available for use when requesting {@link AuthWrapper.prototype.authenticateClient | api/v1/auth/token}
*/
export type AuthAuthenticateClientRequestParams = {
    /**
    * (required) Client id
    */
    clientId: number;
    /**
    * (required) Client secret
    */
    clientSecret: string;
};
export declare class AuthWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Logs in to o!TR
    * @param params Request parameters (see {@link AuthLoginRequestParams})
    * @return OK
    */
    login(params: AuthLoginRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processLogin(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Logs out from o!TR
    * @param params Request parameters (see {@link AuthLogoutRequestParams})
    * @return OK
    */
    logout(params: AuthLogoutRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processLogout(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Authenticate using client credentials
    * @param params Request parameters (see {@link AuthAuthenticateClientRequestParams})
    * @return Returns client access credentials
    */
    authenticateClient(params: AuthAuthenticateClientRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<AccessCredentialsDTO>>;
    protected processAuthenticateClient(response: AxiosResponse): Promise<OtrApiResponse<AccessCredentialsDTO>>;
}
/**
* Request parameters available for use when requesting {@link BeatmapsWrapper.prototype.get | api/v1/beatmaps/[key]}
*/
export type BeatmapsGetRequestParams = {
    /**
    * (required) Search key (id or osu! id)
    */
    key: number;
};
export declare class BeatmapsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * List all beatmaps
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @return Returns all beatmaps
    */
    list(cancelToken?: CancelToken): Promise<OtrApiResponse<BeatmapDTO[]>>;
    protected processList(response: AxiosResponse): Promise<OtrApiResponse<BeatmapDTO[]>>;
    /**
    * Get a beatmap
    *
    * Get a beatmap searching first by id, then by osu! id
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link BeatmapsGetRequestParams})
    * @return Returns a beatmap
    */
    get(params: BeatmapsGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<BeatmapDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<BeatmapDTO>>;
}
/**
* Request parameters available for use when requesting {@link ClientsWrapper.prototype.patchRateLimit | api/v1/clients/[id]/ratelimit}
*/
export type ClientsPatchRateLimitRequestParams = {
    /**
    * (required) Client id
    */
    id: number;
    /**
    * (required) The new rate limit for the client
    */
    body: number;
};
export declare class ClientsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Create a new OAuth client
    *
    * Client secret is only returned from creation.
    * The user will have to reset the secret if they lose access.
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @return Returns created client credentials
    */
    create(cancelToken?: CancelToken): Promise<OtrApiResponse<OAuthClientCreatedDTO>>;
    protected processCreate(response: AxiosResponse): Promise<OtrApiResponse<OAuthClientCreatedDTO>>;
    /**
    * Set the rate limit for a client
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link ClientsPatchRateLimitRequestParams})
    * @return Returns the updated client
    */
    patchRateLimit(params: ClientsPatchRateLimitRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<OAuthClientDTO>>;
    protected processPatchRateLimit(response: AxiosResponse): Promise<OtrApiResponse<OAuthClientDTO>>;
}
export declare class DiagnosticsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Allows clients to determine if the server is running
    * @return The server is running
    */
    ping(cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processPing(response: AxiosResponse): Promise<OtrApiResponse<void>>;
}
/**
* Request parameters available for use when requesting {@link FilteringWrapper.prototype.filter | api/v1/filtering}
*/
export type FilteringFilterRequestParams = {
    /**
    * (required) The filtering request
    */
    body: FilteringRequestDTO;
};
/**
* Request parameters available for use when requesting {@link FilteringWrapper.prototype.getFilterReport | api/v1/filtering/[id]}
*/
export type FilteringGetFilterReportRequestParams = {
    /**
    * (required) The filter report ID
    */
    id: number;
};
export declare class FilteringWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Filter a list of users based on the criteria as described in
    * API.DTOs.FilteringResultDTO
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link FilteringFilterRequestParams})
    * @return The filtering result
    */
    filter(params: FilteringFilterRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<FilteringResultDTO>>;
    protected processFilter(response: AxiosResponse): Promise<OtrApiResponse<FilteringResultDTO>>;
    /**
    * Get a stored filter report by ID
    * @param params Request parameters (see {@link FilteringGetFilterReportRequestParams})
    * @return The filter report
    */
    getFilterReport(params: FilteringGetFilterReportRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<FilterReportDTO>>;
    protected processGetFilterReport(response: AxiosResponse): Promise<OtrApiResponse<FilterReportDTO>>;
}
/**
* Request parameters available for use when requesting {@link GamesWrapper.prototype.get | api/v1/games/[id]}
*/
export type GamesGetRequestParams = {
    id: number;
    /**
    * (optional) Whether the game's scores must be verified
    */
    verified?: boolean | undefined;
};
/**
* Request parameters available for use when requesting {@link GamesWrapper.prototype.update | api/v1/games/[id]}
*/
export type GamesUpdateRequestParams = {
    /**
    * (required) Game id
    */
    id: number;
    /**
    * (optional) JsonPatch data
    */
    body?: Operation[] | undefined;
};
/**
* Request parameters available for use when requesting {@link GamesWrapper.prototype.delete | api/v1/games/[id]}
*/
export type GamesDeleteRequestParams = {
    /**
    * (required) Game id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link GamesWrapper.prototype.mergeScores | api/v1/games/[id]:merge}
*/
export type GamesMergeScoresRequestParams = {
    /**
    * (required) Id of the game to merge scores into
    */
    id: number;
    /**
    * (optional) Game ids whose scores will be merged into the target game
    */
    body?: number[] | undefined;
};
export declare class GamesWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get a game
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link GamesGetRequestParams})
    * @return Returns a game
    */
    get(params: GamesGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<GameDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<GameDTO>>;
    /**
    * Amend game data
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GamesUpdateRequestParams})
    * @return Returns the updated game
    */
    update(params: GamesUpdateRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<GameDTO>>;
    protected processUpdate(response: AxiosResponse): Promise<OtrApiResponse<GameDTO>>;
    /**
    * Delete a game
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GamesDeleteRequestParams})
    * @return The game was deleted successfully
    */
    delete(params: GamesDeleteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDelete(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Merge scores from source games into a target game. The source games must be from the same match
    * and have the same beatmap as the target game. After successful merging, the source games are deleted.
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GamesMergeScoresRequestParams})
    * @return State of the game after merging
    */
    mergeScores(params: GamesMergeScoresRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<GameDTO>>;
    protected processMergeScores(response: AxiosResponse): Promise<OtrApiResponse<GameDTO>>;
}
/**
* Request parameters available for use when requesting {@link GameScoresWrapper.prototype.get | api/v1/gamescores/[id]}
*/
export type GameScoresGetRequestParams = {
    id: number;
};
/**
* Request parameters available for use when requesting {@link GameScoresWrapper.prototype.update | api/v1/gamescores/[id]}
*/
export type GameScoresUpdateRequestParams = {
    /**
    * (required) Score id
    */
    id: number;
    /**
    * (optional) JsonPatch data
    */
    body?: Operation[] | undefined;
};
/**
* Request parameters available for use when requesting {@link GameScoresWrapper.prototype.delete | api/v1/gamescores/[id]}
*/
export type GameScoresDeleteRequestParams = {
    /**
    * (required) Score id
    */
    id: number;
};
export declare class GameScoresWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get a score
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GameScoresGetRequestParams})
    * @return Returns the score
    */
    get(params: GameScoresGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<GameScoreDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<GameScoreDTO>>;
    /**
    * Amend score data
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GameScoresUpdateRequestParams})
    * @return Returns the updated score
    */
    update(params: GameScoresUpdateRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<GameScoreDTO>>;
    protected processUpdate(response: AxiosResponse): Promise<OtrApiResponse<GameScoreDTO>>;
    /**
    * Delete a score
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link GameScoresDeleteRequestParams})
    * @return The score was deleted successfully
    */
    delete(params: GameScoresDeleteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDelete(response: AxiosResponse): Promise<OtrApiResponse<void>>;
}
/**
* Request parameters available for use when requesting {@link LeaderboardsWrapper.prototype.get | api/v1/leaderboards}
*/
export type LeaderboardsGetRequestParams = {
    /**
    * (optional)
    */
    page?: number | undefined;
    /**
    * (optional)
    */
    pageSize?: number | undefined;
    /**
    * (optional) Ruleset for leaderboard data
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) ISO country code (Leaderboard will be global if not provided)
    */
    country?: string | undefined;
    /**
    * (optional) osu! rank floor (The "better" inclusive rank bound.
    * If given, only players with a rank greater than or equal to this value will be included)
    */
    minOsuRank?: number | undefined;
    /**
    * (optional) osu! rank ceiling (The "worse" inclusive rank bound.
    * If given, only players with a rank less than or equal to this value will be included)
    */
    maxOsuRank?: number | undefined;
    /**
    * (optional) Rating floor (The "worse" inclusive rating bound.
    * If given, only players with a rating greater than or equal to this value will be included)
    */
    minRating?: number | undefined;
    /**
    * (optional) Rating ceiling (The "better" inclusive rating bound.
    * If given, only players with a rating less than or equal to this value will be included)
    */
    maxRating?: number | undefined;
    /**
    * (optional) Minimum number of matches played
    */
    minMatches?: number | undefined;
    /**
    * (optional) Maximum number of matches played
    */
    maxMatches?: number | undefined;
    /**
    * (optional) Minimum win rate
    */
    minWinRate?: number | undefined;
    /**
    * (optional) Maximum win rate
    */
    maxWinRate?: number | undefined;
    /**
    * (optional) Explicitly include bronze players
    */
    bronze?: boolean | undefined;
    /**
    * (optional) Explicitly include silver players
    */
    silver?: boolean | undefined;
    /**
    * (optional) Explicitly include gold players
    */
    gold?: boolean | undefined;
    /**
    * (optional) Explicitly include platinum players
    */
    platinum?: boolean | undefined;
    /**
    * (optional) Explicitly include emerald players
    */
    emerald?: boolean | undefined;
    /**
    * (optional) Explicitly include diamond players
    */
    diamond?: boolean | undefined;
    /**
    * (optional) Explicitly include master players
    */
    master?: boolean | undefined;
    /**
    * (optional) Explicitly include grandmaster players
    */
    grandmaster?: boolean | undefined;
    /**
    * (optional) Explicitly include elite grandmaster players
    */
    eliteGrandmaster?: boolean | undefined;
};
export declare class LeaderboardsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get a leaderboard of players which fit an optional request query
    * @param params Request parameters (see {@link LeaderboardsGetRequestParams})
    * @return Returns the leaderboard
    */
    get(params: LeaderboardsGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<LeaderboardDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<LeaderboardDTO>>;
}
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.list | api/v1/matches}
*/
export type MatchesListRequestParams = {
    page: number;
    pageSize: number;
    /**
    * (optional) Filters results for only matches played in a specified ruleset
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filters results for only matches with a partially matching name (case insensitive)
    */
    name?: string | undefined;
    /**
    * (optional) Filters results for only matches that occurred on or after a specified date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filters results for only matches that occurred on or before a specified date
    */
    dateMax?: Date | undefined;
    /**
    * (optional) Filters results for only matches with a specified verification status
    */
    verificationStatus?: VerificationStatus | undefined;
    /**
    * (optional) Filters results for only matches with a specified rejection reason
    */
    rejectionReason?: MatchRejectionReason | undefined;
    /**
    * (optional) Filters results for only matches with a specified processing status
    */
    processingStatus?: MatchProcessingStatus | undefined;
    /**
    * (optional) Filters results for only matches submitted by a user with a specified id
    */
    submittedBy?: number | undefined;
    /**
    * (optional) Filters results for only matches verified by a user with a specified id
    */
    verifiedBy?: number | undefined;
    /**
    * (optional) The key used to sort results by
    */
    sort?: MatchQuerySortType | undefined;
    /**
    * (optional) Whether the results are sorted in descending order by the API.DTOs.MatchRequestQueryDTO.Sort
    */
    descending?: boolean | undefined;
};
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.get | api/v1/matches/[id]}
*/
export type MatchesGetRequestParams = {
    /**
    * (required) Match id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.update | api/v1/matches/[id]}
*/
export type MatchesUpdateRequestParams = {
    /**
    * (required) Match id
    */
    id: number;
    /**
    * (optional) JsonPatch data
    */
    body?: Operation[] | undefined;
};
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.delete | api/v1/matches/[id]}
*/
export type MatchesDeleteRequestParams = {
    /**
    * (required) Match id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.merge | api/v1/matches/[id]:merge}
*/
export type MatchesMergeRequestParams = {
    /**
    * (required) Id of the match to link games to
    */
    id: number;
    /**
    * (optional) Match ids to unlink games from before deletion
    */
    body?: number[] | undefined;
};
/**
* Request parameters available for use when requesting {@link MatchesWrapper.prototype.deletePlayerScores | api/v1/matches/[id]/player/[playerId]}
*/
export type MatchesDeletePlayerScoresRequestParams = {
    /**
    * (required) Match id
    */
    id: number;
    /**
    * (required) Player id
    */
    playerId: number;
};
export declare class MatchesWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get all matches which fit an optional request query
    *
    * Will not include game data
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link MatchesListRequestParams})
    * @return Returns all matches which fit the request query
    */
    list(params: MatchesListRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchDTO[]>>;
    protected processList(response: AxiosResponse): Promise<OtrApiResponse<MatchDTO[]>>;
    /**
    * Get a match
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link MatchesGetRequestParams})
    * @return Returns a match
    */
    get(params: MatchesGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<MatchDTO>>;
    /**
    * Amend match data
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link MatchesUpdateRequestParams})
    * @return Returns the updated match
    */
    update(params: MatchesUpdateRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchDTO>>;
    protected processUpdate(response: AxiosResponse): Promise<OtrApiResponse<MatchDTO>>;
    /**
    * Delete a match
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link MatchesDeleteRequestParams})
    * @return The match was deleted successfully
    */
    delete(params: MatchesDeleteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDelete(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Links games from provided matches into a single match id before deleting
    * the provided matches
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link MatchesMergeRequestParams})
    * @return State of the match after merging
    */
    merge(params: MatchesMergeRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchDTO>>;
    protected processMerge(response: AxiosResponse): Promise<OtrApiResponse<MatchDTO>>;
    /**
    * Delete all scores belonging to a player for a given match
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link MatchesDeletePlayerScoresRequestParams})
    * @return Returns the number of scores deleted
    */
    deletePlayerScores(params: MatchesDeletePlayerScoresRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<number>>;
    protected processDeletePlayerScores(response: AxiosResponse): Promise<OtrApiResponse<number>>;
}
/**
* Request parameters available for use when requesting {@link MeWrapper.prototype.getStats | api/v1/me/stats}
*/
export type MeGetStatsRequestParams = {
    /**
    * (optional) Ruleset to filter for
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filter from earliest date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filter to latest date
    */
    dateMax?: Date | undefined;
};
/**
* Request parameters available for use when requesting {@link MeWrapper.prototype.getTournaments | api/v1/me/tournaments}
*/
export type MeGetTournamentsRequestParams = {
    /**
    * (optional) Ruleset to filter for
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filter from earliest date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filter to latest date
    */
    dateMax?: Date | undefined;
};
/**
* Request parameters available for use when requesting {@link MeWrapper.prototype.updateRuleset | api/v1/me/settings/ruleset}
*/
export type MeUpdateRulesetRequestParams = {
    body: Ruleset;
};
export declare class MeWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get the currently logged in user
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @return Returns the currently logged in user
    */
    get(cancelToken?: CancelToken): Promise<OtrApiResponse<UserDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<UserDTO>>;
    /**
    * Get player stats for the currently logged in user
    *
    * If no ruleset is provided, the player's default is used. Common.Enums.Ruleset.Osu is used as a fallback.
    * If a ruleset is provided but the player has no data for it, all optional fields of the response will be null.
    * API.DTOs.PlayerDashboardStatsDTO.PlayerInfo will always be populated as long as a player is found.
    * If no date range is provided, gets all stats without considering date
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @param params Request parameters (see {@link MeGetStatsRequestParams})
    * @return Returns the currently logged in user's player stats
    */
    getStats(params: MeGetStatsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<PlayerDashboardStatsDTO>>;
    protected processGetStats(response: AxiosResponse): Promise<OtrApiResponse<PlayerDashboardStatsDTO>>;
    /**
    * Get all tournaments the currently logged in user has participated in
    *
    * If no ruleset is provided, returns tournaments from all rulesets.
    * If no date range is provided, gets all tournaments without date filtering.
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @param params Request parameters (see {@link MeGetTournamentsRequestParams})
    * @return Returns a collection of tournaments
    */
    getTournaments(params: MeGetTournamentsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentCompactDTO[]>>;
    protected processGetTournaments(response: AxiosResponse): Promise<OtrApiResponse<TournamentCompactDTO[]>>;
    /**
    * Update the ruleset for the currently logged in user
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @param params Request parameters (see {@link MeUpdateRulesetRequestParams})
    * @return The operation was successful
    */
    updateRuleset(params: MeUpdateRulesetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processUpdateRuleset(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Sync the ruleset of the currently logged in user to their osu! ruleset
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @return The operation was successful
    */
    syncRuleset(cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processSyncRuleset(response: AxiosResponse): Promise<OtrApiResponse<void>>;
}
export declare class PlatformStatsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get various platform-wide stats
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @return Returns various platform-wide stats
    */
    get(cancelToken?: CancelToken): Promise<OtrApiResponse<PlatformStatsDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<PlatformStatsDTO>>;
}
/**
* Request parameters available for use when requesting {@link PlayersWrapper.prototype.get | api/v1/players/[key]}
*/
export type PlayersGetRequestParams = {
    /**
    * (required) Search key (id, osu! id, or osu! username)
    */
    key: string;
};
/**
* Request parameters available for use when requesting {@link PlayersWrapper.prototype.getStats | api/v1/players/[key]/stats}
*/
export type PlayersGetStatsRequestParams = {
    /**
    * (required) Search key
    */
    key: string;
    /**
    * (optional) Ruleset to filter for
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filter from earliest date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filter to latest date
    */
    dateMax?: Date | undefined;
};
/**
* Request parameters available for use when requesting {@link PlayersWrapper.prototype.getTournaments | api/v1/players/[key]/tournaments}
*/
export type PlayersGetTournamentsRequestParams = {
    /**
    * (required) Search key (id, osu! id, or osu! username)
    */
    key: string;
    /**
    * (optional) Ruleset to filter for
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filter from earliest date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filter to latest date
    */
    dateMax?: Date | undefined;
};
export declare class PlayersWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get a player
    *
    * Get a player searching first by id, then by osu! id, then osu! username
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link PlayersGetRequestParams})
    * @return Returns a player
    */
    get(params: PlayersGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<PlayerCompactDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<PlayerCompactDTO>>;
    /**
    * Get a player's stats
    *
    * Gets player by versatile search.
    * If no ruleset is provided, the player's default is used. Common.Enums.Ruleset.Osu is used as a fallback.
    * If a ruleset is provided but the player has no data for it, all optional fields of the response will be null.
    * API.DTOs.PlayerDashboardStatsDTO.PlayerInfo will always be populated as long as a player is found.
    * If no date range is provided, gets all stats without considering date
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link PlayersGetStatsRequestParams})
    * @return Returns a player's stats
    */
    getStats(params: PlayersGetStatsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<PlayerDashboardStatsDTO>>;
    protected processGetStats(response: AxiosResponse): Promise<OtrApiResponse<PlayerDashboardStatsDTO>>;
    /**
    * Get all tournaments a player has participated in
    *
    * Gets tournaments for a player by versatile search.
    * If no ruleset is provided, returns tournaments from all rulesets.
    * If no date range is provided, gets all tournaments without date filtering.
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link PlayersGetTournamentsRequestParams})
    * @return Returns a collection of tournaments
    */
    getTournaments(params: PlayersGetTournamentsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentCompactDTO[]>>;
    protected processGetTournaments(response: AxiosResponse): Promise<OtrApiResponse<TournamentCompactDTO[]>>;
}
/**
* Request parameters available for use when requesting {@link SearchWrapper.prototype.search | api/v1/search}
*/
export type SearchSearchRequestParams = {
    /**
    * (required) Search key
    */
    searchKey: string;
};
export declare class SearchWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Search for tournaments, matches, and users
    *
    * Search uses partial matching on: tournament name and abbreviation, match name, and player name
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link SearchSearchRequestParams})
    * @return Returns a list of tournaments, matches, and usernames matching the given search key
    */
    search(params: SearchSearchRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<SearchResponseCollectionDTO>>;
    protected processSearch(response: AxiosResponse): Promise<OtrApiResponse<SearchResponseCollectionDTO>>;
}
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.delete | api/v1/tournaments/[id]}
*/
export type TournamentsDeleteRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.get | api/v1/tournaments/[id]}
*/
export type TournamentsGetRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.update | api/v1/tournaments/[id]}
*/
export type TournamentsUpdateRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
    /**
    * (optional) JsonPatch data
    */
    body?: Operation[] | undefined;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.acceptPreVerificationStatuses | api/v1/tournaments/[id]:accept-pre-verification-statuses}
*/
export type TournamentsAcceptPreVerificationStatusesRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.rerunAutomationChecks | api/v1/tournaments/[id]:reset-automation-statuses}
*/
export type TournamentsRerunAutomationChecksRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
    /**
    * (optional) Whether to overwrite data which has already been Verified or Rejected
    */
    force?: boolean | undefined;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.insertBeatmaps | api/v1/tournaments/[id]/beatmaps}
*/
export type TournamentsInsertBeatmapsRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
    /**
    * (optional) A collection of osu! beatmap ids
    */
    body?: number[] | undefined;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.deleteBeatmaps | api/v1/tournaments/[id]/beatmaps}
*/
export type TournamentsDeleteBeatmapsRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
    /**
    * (optional) An optional collection of specific beatmap ids to remove from the pooled beatmaps collection
    */
    body?: number[] | undefined;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.getBeatmaps | api/v1/tournaments/[id]/beatmaps}
*/
export type TournamentsGetBeatmapsRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.list | api/v1/tournaments}
*/
export type TournamentsListRequestParams = {
    page: number;
    pageSize: number;
    /**
    * (optional) Filters results for only tournaments that are verified
    */
    verified?: boolean | undefined;
    /**
    * (optional) Filters results for only tournaments played in a specified ruleset
    */
    ruleset?: Ruleset | undefined;
    /**
    * (optional) Filters results for only tournaments with a partially matching name or abbreviation (case insensitive)
    */
    searchQuery?: string | undefined;
    /**
    * (optional) Filters results for only tournaments that occurred on or after a specified date
    */
    dateMin?: Date | undefined;
    /**
    * (optional) Filters results for only tournaments that occurred on or before a specified date
    */
    dateMax?: Date | undefined;
    /**
    * (optional) Filters results for only tournaments with a specified verification status
    */
    verificationStatus?: VerificationStatus | undefined;
    /**
    * (optional) Filters results for only tournaments with a specified rejection reason
    */
    rejectionReason?: TournamentRejectionReason | undefined;
    /**
    * (optional) Filters results for only tournaments with a specified processing status
    */
    processingStatus?: TournamentProcessingStatus | undefined;
    /**
    * (optional) Filters results for only tournaments submitted by a user with a specified id
    */
    submittedBy?: number | undefined;
    /**
    * (optional) Filters results for only tournaments verified by a user with a specified id
    */
    verifiedBy?: number | undefined;
    /**
    * (optional) Filters results for only tournaments played with a specified lobby size
    */
    lobbySize?: number | undefined;
    /**
    * (optional) The key used to sort results by
    */
    sort?: TournamentQuerySortType | undefined;
    /**
    * (optional) Whether the results are sorted in descending order by the API.DTOs.TournamentRequestQueryDTO.Sort
    */
    descending?: boolean | undefined;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.create | api/v1/tournaments}
*/
export type TournamentsCreateRequestParams = {
    /**
    * (required) Tournament submission data
    */
    body: TournamentSubmissionDTO;
};
/**
* Request parameters available for use when requesting {@link TournamentsWrapper.prototype.listMatches | api/v1/tournaments/[id]/matches}
*/
export type TournamentsListMatchesRequestParams = {
    /**
    * (required) Tournament id
    */
    id: number;
};
export declare class TournamentsWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Delete a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsDeleteRequestParams})
    * @return The tournament was deleted successfully
    */
    delete(params: TournamentsDeleteRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDelete(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Get a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link TournamentsGetRequestParams})
    * @return Returns a tournament
    */
    get(params: TournamentsGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<TournamentDTO>>;
    /**
    * Amend tournament data
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsUpdateRequestParams})
    * @return Returns the updated tournament
    */
    update(params: TournamentsUpdateRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentCompactDTO>>;
    protected processUpdate(response: AxiosResponse): Promise<OtrApiResponse<TournamentCompactDTO>>;
    /**
    * Mark pre-rejected items as rejected, marks pre-verified
    * items as verified. Applies for the tournament and all children.
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsAcceptPreVerificationStatusesRequestParams})
    * @return All items were updated successfully
    */
    acceptPreVerificationStatuses(params: TournamentsAcceptPreVerificationStatusesRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentDTO>>;
    protected processAcceptPreVerificationStatuses(response: AxiosResponse): Promise<OtrApiResponse<TournamentDTO>>;
    /**
    * Rerun automation checks for a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsRerunAutomationChecksRequestParams})
    * @return The entities were updated successfully
    */
    rerunAutomationChecks(params: TournamentsRerunAutomationChecksRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processRerunAutomationChecks(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Add beatmaps to a tournament by osu! id
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsInsertBeatmapsRequestParams})
    * @return The beatmaps were added successfully
    */
    insertBeatmaps(params: TournamentsInsertBeatmapsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processInsertBeatmaps(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Delete all pooled beatmaps from a tournament. This does not alter the beatmaps table. This only
    * deletes the mapping between a tournament and a pooled beatmap.
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link TournamentsDeleteBeatmapsRequestParams})
    * @return All beatmaps were successfully removed
    */
    deleteBeatmaps(params: TournamentsDeleteBeatmapsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDeleteBeatmaps(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Get all beatmaps pooled by a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link TournamentsGetBeatmapsRequestParams})
    * @return Returns a collection of pooled beatmaps
    */
    getBeatmaps(params: TournamentsGetBeatmapsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<BeatmapDTO[]>>;
    protected processGetBeatmaps(response: AxiosResponse): Promise<OtrApiResponse<BeatmapDTO[]>>;
    /**
    * Get all tournaments which fit an optional request query
    *
    * Results will not include match data
    * @param params Request parameters (see {@link TournamentsListRequestParams})
    * @return Returns all tournaments which fit the request query
    */
    list(params: TournamentsListRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentDTO[]>>;
    protected processList(response: AxiosResponse): Promise<OtrApiResponse<TournamentDTO[]>>;
    /**
    * Submit a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): user
    * @param params Request parameters (see {@link TournamentsCreateRequestParams})
    * @return Returns location information for the created tournament
    */
    create(params: TournamentsCreateRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<TournamentCreatedResultDTO>>;
    protected processCreate(response: AxiosResponse): Promise<OtrApiResponse<TournamentCreatedResultDTO>>;
    /**
    * List all matches from a tournament
    *
    * Requires Authorization:
    *
    * Claim(s): user, client
    * @param params Request parameters (see {@link TournamentsListMatchesRequestParams})
    * @return Returns all matches from a tournament
    */
    listMatches(params: TournamentsListMatchesRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchDTO[]>>;
    protected processListMatches(response: AxiosResponse): Promise<OtrApiResponse<MatchDTO[]>>;
}
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.get | api/v1/users/[id]}
*/
export type UsersGetRequestParams = {
    /**
    * (required) User id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.updateScopes | api/v1/users/[id]/scopes}
*/
export type UsersUpdateScopesRequestParams = {
    /**
    * (required) User id
    */
    id: number;
    /**
    * (required) List of scopes to assign to the user
    */
    body: string[];
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.getSubmissions | api/v1/users/[id]/submissions}
*/
export type UsersGetSubmissionsRequestParams = {
    /**
    * (required) User id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.rejectSubmissions | api/v1/users/[id]/submissions:reject}
*/
export type UsersRejectSubmissionsRequestParams = {
    /**
    * (required) User id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.getClients | api/v1/users/[id]/clients}
*/
export type UsersGetClientsRequestParams = {
    /**
    * (required) User id
    */
    id: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.deleteClient | api/v1/users/[id]/clients/[clientId]}
*/
export type UsersDeleteClientRequestParams = {
    /**
    * (required) User id
    */
    id: number;
    /**
    * (required) OAuth client id
    */
    clientId: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.resetClientSecret | api/v1/users/[id]/clients/[clientId]/secret:reset}
*/
export type UsersResetClientSecretRequestParams = {
    /**
    * (required) User id
    */
    id: number;
    /**
    * (required) OAuth client id
    */
    clientId: number;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.updateRuleset | api/v1/users/[id]/settings/ruleset}
*/
export type UsersUpdateRulesetRequestParams = {
    /**
    * (required) User id
    */
    id: number;
    /**
    * (required) The new ruleset
    */
    body: Ruleset;
};
/**
* Request parameters available for use when requesting {@link UsersWrapper.prototype.syncRuleset | api/v1/users/[id]/settings/ruleset:sync}
*/
export type UsersSyncRulesetRequestParams = {
    /**
    * (required) User id
    */
    id: number;
};
export declare class UsersWrapper extends OtrApiWrapperBase {
    protected instance: AxiosInstance;
    protected baseUrl: string;
    protected jsonParseReviver: ((key: string, value: any) => any) | undefined;
    constructor(configuration: IOtrApiWrapperConfiguration);
    /**
    * Get a user
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersGetRequestParams})
    * @return Returns a user
    */
    get(params: UsersGetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<UserDTO>>;
    protected processGet(response: AxiosResponse): Promise<OtrApiResponse<UserDTO>>;
    /**
    * Update a user's scopes
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link UsersUpdateScopesRequestParams})
    * @return Returns the updated user
    */
    updateScopes(params: UsersUpdateScopesRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<UserDTO>>;
    protected processUpdateScopes(response: AxiosResponse): Promise<OtrApiResponse<UserDTO>>;
    /**
    * Get a user's match submissions
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersGetSubmissionsRequestParams})
    * @return Returns a list of submissions
    */
    getSubmissions(params: UsersGetSubmissionsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<MatchSubmissionStatusDTO[]>>;
    protected processGetSubmissions(response: AxiosResponse): Promise<OtrApiResponse<MatchSubmissionStatusDTO[]>>;
    /**
    * Reject a user's match submissions
    *
    * Requires Authorization:
    *
    * Claim(s): admin
    * @param params Request parameters (see {@link UsersRejectSubmissionsRequestParams})
    * @return The operation was successful
    */
    rejectSubmissions(params: UsersRejectSubmissionsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processRejectSubmissions(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Get a user's OAuth clients
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersGetClientsRequestParams})
    * @return Returns a list of OAuth clients
    */
    getClients(params: UsersGetClientsRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<OAuthClientDTO[]>>;
    protected processGetClients(response: AxiosResponse): Promise<OtrApiResponse<OAuthClientDTO[]>>;
    /**
    * Delete a user's OAuth client
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersDeleteClientRequestParams})
    * @return The deletion was successful
    */
    deleteClient(params: UsersDeleteClientRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processDeleteClient(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Reset the secret of a user's OAuth client
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersResetClientSecretRequestParams})
    * @return Returns new client credentials
    */
    resetClientSecret(params: UsersResetClientSecretRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<OAuthClientCreatedDTO>>;
    protected processResetClientSecret(response: AxiosResponse): Promise<OtrApiResponse<OAuthClientCreatedDTO>>;
    /**
    * Update the ruleset of a user
    *
    * If a user's preferred ruleset was previously being synced with the one selected on their osu! profile,
    * updating it will stop their preferred ruleset from being synced in the future unless it is requested
    * to be synced again
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersUpdateRulesetRequestParams})
    * @return The operation was successful
    */
    updateRuleset(params: UsersUpdateRulesetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processUpdateRuleset(response: AxiosResponse): Promise<OtrApiResponse<void>>;
    /**
    * Sync the ruleset of a user with their osu! ruleset
    *
    * Sets the user's preferred ruleset to the one currently selected on their osu! profile
    * and in the future will continuously update if the ruleset selected on their osu! profile changes
    *
    * Requires Authorization:
    *
    * Policy: AccessUserResources
    * @param params Request parameters (see {@link UsersSyncRulesetRequestParams})
    * @return The operation was successful
    */
    syncRuleset(params: UsersSyncRulesetRequestParams, cancelToken?: CancelToken): Promise<OtrApiResponse<void>>;
    protected processSyncRuleset(response: AxiosResponse): Promise<OtrApiResponse<void>>;
}
/** Represents access credentials and their expiry */
export interface AccessCredentialsDTO {
    /** Access token */
    accessToken: string;
    /** Lifetime of the access token in seconds */
    expiresIn: number;
}
/** Represents a note for an entity created by an admin */
export interface AdminNoteDTO {
    /** The id of the admin note */
    id: number;
    /** Timestamp of creation */
    created: Date;
    /** Timestamp of the last update, if available */
    updated?: Date | undefined;
    /** Id of the parent entity */
    referenceId: number;
    /** The admin user that created the note */
    adminUser: UserCompactDTO;
    /** Content of the note */
    note: string;
}
/** Type of entity to target for admin note actions */
export declare enum AdminNoteRouteTarget {
    /**  */
    Game = "game",
    /**  */
    GameScore = "gamescore",
    /**  */
    Match = "match",
    /**  */
    OAuthClient = "oauthclient",
    /**  */
    Player = "player",
    /**  */
    Tournament = "tournament"
}
/** Represents an aggregate of match statistics for a player during a period of time */
export interface AggregatePlayerMatchStatsDTO {
    /** The player's average match cost during the period */
    averageMatchCostAggregate: number;
    /** The peak rating achieved by the player during the period */
    highestRating: number;
    /** The amount of rating gained from the start of the period to the end of the period */
    ratingGained: number;
    /** The amount of games won during the period */
    gamesWon: number;
    /** The amount of games lost during the period */
    gamesLost: number;
    /** The amount of games played during the period */
    gamesPlayed: number;
    /** The amount of matches won during the period */
    matchesWon: number;
    /** The amount of matches lost during the period */
    matchesLost: number;
    /** The amount of matches played during the period */
    readonly matchesPlayed: number;
    /** A value between 0 and 1 representing the player's game win rate during the period */
    readonly gameWinRate: number;
    /** A value between 0 and 1 representing the player's match win rate during the period */
    readonly matchWinRate: number;
    /** The most amount of matches won in a row during the period */
    bestWinStreak: number;
    /** Across all matches the player has played in, the average score across the entire lobby. This average includes
scores for games the player may have not been in for */
    matchAverageScoreAggregate: number;
    /** Across all matches the player has played in, the average miss count of the lobby, across all games in that match */
    matchAverageMissesAggregate: number;
    /** Across all matches the player has played in, the average accuracy of the lobby, across all games in that match */
    matchAverageAccuracyAggregate: number;
    /** The amount of maps the player participates in, on average. */
    averageGamesPlayedAggregate: number;
    /** The average lobby ranking the player has on maps they participate in.
A top-score is 1, bottom score would be team size * 2 */
    averagePlacingAggregate: number;
    /** The beginning of the period for which the statistics are calculated. */
    periodStart?: Date | undefined;
    /** The end of the period for which the statistics are calculated. */
    periodEnd?: Date | undefined;
}
export declare enum AuditActionType {
    /** The entity was created */
    Created = 0,
    /** The entity was updated */
    Updated = 1,
    /** The entity was deleted */
    Deleted = 2
}
/** Represents an audit record tracking changes made to entities in the system */
export interface AuditDTO {
    /** Primary key of the audit record */
    id: number;
    /** Id of the user who performed the action, if available (Will be null for system-generated actions or actions performed by anonymous users) */
    userId?: number | undefined;
    /** The type of action that was performed on the entity */
    actionType: AuditActionType;
    /** The type of entity that was modified */
    entityType: AuditEntityType;
    /** Timestamp when the action was performed */
    timestamp: Date;
    /** Id of the entity that was modified (This is a locked copy of the entity's primary key that persists even if the original entity is deleted) */
    entityId: number;
    /** JSON object containing all field changes made to the entity.
Format: { "FieldName": { "NewValue": value, "OriginalValue": value }, ... } */
    changes: string;
}
export declare enum AuditEntityType {
    Game = 0,
    GameScore = 1,
    Match = 2,
    Tournament = 3
}
/** The possible authorization policies enforced on a route. Authorization policies differ from Roles as they may require special conditions to be satisfied. See the description of a policy for more information. */
export declare enum AuthorizationPolicies {
    /** Policy that allows access from the user that owns the resource as well as any admin users */
    AccessUserResources = "AccessUserResources"
}
/** Represents a beatmap's attributes */
export interface BeatmapAttributesDTO {
    /** Mods applied */
    mods: Mods;
    /** Star rating with applied mods */
    sr: number;
}
/** Represents a beatmap */
export interface BeatmapDTO {
    /** Id of the beatmap */
    id: number;
    /** osu! id of the beatmap */
    osuId: number;
    /** Beats per minute */
    bpm?: number | undefined;
    /** Star rating */
    sr: number;
    /** Circle size */
    cs: number;
    /** Approach rate */
    ar: number;
    /** HP drain rate */
    hp: number;
    /** Overall difficulty */
    od: number;
    /** Song length */
    totalLength: number;
    /** Name of the difficulty */
    diffName?: string | undefined;
    /** Beatmapset id */
    beatmapsetId?: number | undefined;
    /** Beatmapset */
    beatmapset?: BeatmapsetCompactDTO | undefined;
    /** Beatmap attributes */
    attributes: BeatmapAttributesDTO[];
    /** Beatmap creators */
    creators: PlayerCompactDTO[];
}
export declare enum BeatmapRankedStatus {
    Pending = 0,
    Ranked = 1,
    Approved = 2,
    Qualified = 3,
    Loved = 4,
    Graveyard = -2,
    WorkInProgress = -1
}
/** Represents a compact version of a beatmapset */
export interface BeatmapsetCompactDTO {
    /** Beatmapset id */
    id: number;
    /** osu! beatmapset id */
    osuId: number;
    /** Artist */
    artist: string;
    /** Title */
    title: string;
    /** Ranked status */
    rankedStatus: BeatmapRankedStatus;
    /** Date of ranking, if applicable */
    rankedDate?: Date | undefined;
    /** Date of submission */
    submittedDate?: Date | undefined;
    /** Id of the Player who created the set */
    creatorId: number;
    /** The set creator */
    creator?: PlayerCompactDTO | undefined;
}
/** A beatmapset with beatmaps included */
export interface BeatmapsetDTO extends BeatmapsetCompactDTO {
    /** Beatmaps which are part of this set */
    beatmaps?: BeatmapDTO[];
}
/** Represents a newly created resource */
export interface CreatedResultBaseDTO {
    /** Id of the resource */
    id: number;
    /** Location of the resource */
    location: string;
}
/** Represents a complete filter report including metadata and results */
export interface FilterReportDTO {
    /** The unique identifier of the filter report */
    id: number;
    /** The timestamp when the filter report was created */
    created: Date;
    /** The ID of the user who created the filter report */
    userId: number;
    /** The original filtering request */
    request?: FilteringRequestDTO | undefined;
    /** The filtering results */
    response?: FilteringResultDTO | undefined;
}
export declare enum FilteringFailReason {
    /** No failure reason */
    None = 0,
    /** The player's rating is below the minimum threshold */
    MinRating = 1,
    /** The player's rating is above the maximum threshold */
    MaxRating = 2,
    /**
    * The player has not played in the minimum specified
    * number of tournaments
    */
    NotEnoughTournaments = 4,
    /** The player's all-time peak rating is above the maximum threshold */
    PeakRatingTooHigh = 8,
    /** The player has not played in the minimum specified number of matches */
    NotEnoughMatches = 16,
    /** The player has played in more than the maximum specified number of matches */
    TooManyMatches = 32,
    /** The player has participated in more than the maximum specified number of tournaments */
    TooManyTournaments = 64
}
/** Represents a set of criteria used by the API.Controllers.FilteringController to determine player eligibility for a tournament */
export interface FilteringRequestDTO {
    /** The ruleset by which data will be referenced, required */
    ruleset: Ruleset;
    /** Players with a current rating below this value will be filtered */
    minRating?: number | undefined;
    /** Players with a current rating above this value will be filtered */
    maxRating?: number | undefined;
    /** If set, requires players to have participated in at least
this many distinct tournaments */
    tournamentsPlayed?: number | undefined;
    /** If set, requires players to have an all-time peak rating less than
this value */
    peakRating?: number | undefined;
    /** If set, requires players to have played in at least
this many matches */
    matchesPlayed?: number | undefined;
    /** If set, requires players to have played in at most
this many matches */
    maxMatchesPlayed?: number | undefined;
    /** If set, requires players to have participated in at most
this many distinct tournaments */
    maxTournamentsPlayed?: number | undefined;
    /** A list of osu! player ids that will be filtered */
    osuPlayerIds: number[];
}
/** Represents a filtering result for a collection of players */
export interface FilteringResultDTO {
    /** The number of players who passed filtering */
    playersPassed: number;
    /** The number of players who failed filtering */
    playersFailed: number;
    /** A collection of filtering results, one per submitted player,
in the same order as submitted in the API.DTOs.FilteringRequestDTO */
    filteringResults: PlayerFilteringResultDTO[];
    /** The ID of the filter report stored in the database */
    filterReportId: number;
}
/** Represents essential game information without nested data */
export interface GameCompactDTO {
    /** Primary key */
    id: number;
    /** osu! id */
    osuId: number;
    /** The ruleset */
    ruleset: Ruleset;
    /** The verification status */
    verificationStatus: VerificationStatus;
    /** The processing status */
    processingStatus: GameProcessingStatus;
    /** Warning flags */
    warningFlags: GameWarningFlags;
    /** The rejection reason */
    rejectionReason: GameRejectionReason;
    /** Timestamp of the beginning of the game */
    startTime: Date;
    /** Timestamp of the end of the game */
    endTime?: Date | undefined;
}
/** Represents a single game (osu! beatmap) played in a match */
export interface GameDTO {
    /** Primary key */
    id: number;
    /** osu! id */
    osuId: number;
    /** The ruleset */
    ruleset: Ruleset;
    /** The scoring type used */
    scoringType: ScoringType;
    /** The team type used */
    teamType: TeamType;
    /** The mods enabled */
    mods: Mods;
    /** Denotes if the mod setting is "free mod" */
    isFreeMod: boolean;
    /** The verification status */
    verificationStatus: VerificationStatus;
    /** The processing status */
    processingStatus: GameProcessingStatus;
    /** Warning flags */
    warningFlags: GameWarningFlags;
    /** The rejection reason */
    rejectionReason: GameRejectionReason;
    /** Timestamp of the beginning of the game */
    startTime: Date;
    /** Timestamp of the end of the game */
    endTime?: Date | undefined;
    /** The beatmap played */
    beatmap: BeatmapDTO;
    /** Win record */
    rosters: GameRosterDTO[];
    /** All associated admin notes */
    adminNotes: AdminNoteDTO[];
    /** All match scores */
    scores: GameScoreDTO[];
}
export declare enum GameProcessingStatus {
    /** The !:Database.Entities.Game needs automation checks */
    NeedsAutomationChecks = 0,
    /**
    * The !:Database.Entities.Game is awaiting verification from a
    * !:Database.Entities.User with verifier permission
    */
    NeedsVerification = 1,
    /**
    * The !:Database.Entities.Game needs stat calculation
    *
    * Generates the !:Database.Entities.GameRoster
    */
    NeedsStatCalculation = 2,
    /** The !:Database.Entities.Game has completed all processing steps */
    Done = 3
}
export declare enum GameRejectionReason {
    /** The !:Database.Entities.Game is not rejected */
    None = 0,
    /** The !:Database.Entities.Game's osu! API data did not contain any !:Database.Entities.GameScores */
    NoScores = 1,
    /** The !:Database.Entities.Game has invalid mods applied */
    InvalidMods = 2,
    /** The !:Database.Entities.Game's Common.Enums.Ruleset does not match that of the parent !:Database.Entities.Tournament */
    RulesetMismatch = 4,
    /** The !:Database.Entities.Game's Common.Enums.ScoringType is not Common.Enums.ScoringType.ScoreV2 */
    InvalidScoringType = 8,
    /** The !:Database.Entities.Game's Common.Enums.TeamType is not Common.Enums.TeamType.TeamVs */
    InvalidTeamType = 16,
    /**
    * The !:Database.Entities.Game's Common.Enums.TeamType is not Common.Enums.TeamType.TeamVs
    * and attempting Common.Enums.TeamType.TeamVs conversion was not successful
    */
    FailedTeamVsConversion = 32,
    /**
    * The !:Database.Entities.Game's number of !:Database.Entities.Game.Scores with a Common.Enums.Verification.VerificationStatus
    * of Common.Enums.Verification.VerificationStatus.Verified or Common.Enums.Verification.VerificationStatus.PreVerified is < 2
    */
    NoValidScores = 64,
    /**
    * The !:Database.Entities.Game's number of !:Database.Entities.Game.Scores with a Common.Enums.Verification.VerificationStatus
    * of Common.Enums.Verification.VerificationStatus.Verified or Common.Enums.Verification.VerificationStatus.PreVerified divided by 2 is
    * not equal to the !:Database.Entities.Tournament.LobbySize of the parent !:Database.Entities.Tournament
    * in case of Common.Enums.TeamType.HeadToHead!:Database.Entities.Games.
    * In the case of 2 or more teams, ensures that there are an equal number of players in the lobby for each team.
    */
    LobbySizeMismatch = 128,
    /** The !:Database.Entities.Game's !:Database.Entities.Game.EndTime could not be determined */
    NoEndTime = 256,
    /** The System.Text.RegularExpressions.Match the !:Database.Entities.Game was played in was rejected */
    RejectedMatch = 512,
    /**
    * The !:Database.Entities.Tournament has a known collection of PooledBeatmaps
    * and the !:Database.Entities.Beatmap played in the !:Database.Entities.Game is not present
    * in said collection
    */
    BeatmapNotPooled = 1024
}
/** Represents aggregate statistics and roster for both teams in a game */
export interface GameRosterDTO {
    /** Id of the game */
    gameId: number;
    /** Winning team */
    team: Team;
    /** Combined score of the losing team */
    score: number;
    /** Ids of all players on the losing team */
    roster: number[];
}
/** Represents a single score set in a game */
export interface GameScoreDTO {
    /** Primary key */
    id: number;
    /** Id of the Player that set the score */
    playerId: number;
    /** Ruleset the score was set in */
    ruleset: Ruleset;
    /** Team the Player was on */
    team: Team;
    /** Letter grade */
    grade: ScoreGrade;
    /** Total score */
    score: number;
    /** Placement of the score compared to all others in the same game */
    placement: number;
    /** Max combo */
    maxCombo: number;
    /** Count of notes hit with a judgement of 50 */
    count50: number;
    /** Count of notes hit with a judgement of 100 */
    count100: number;
    /** Count of notes hit with a judgement of 300 */
    count300: number;
    /** Count of notes hit with a judgement of Katu */
    countKatu: number;
    /** Count of notes hit with a judgement of Geki */
    countGeki: number;
    /** Count of missed notes */
    countMiss: number;
    /** Applied mods */
    mods: Mods;
    /** Accuracy */
    accuracy: number;
    /** The current state of verification */
    verificationStatus: VerificationStatus;
    /** The current state of processing */
    processingStatus: ScoreProcessingStatus;
    /** The rejection reason */
    rejectionReason: ScoreRejectionReason;
    /** All associated admin notes */
    adminNotes: AdminNoteDTO[];
}
export declare enum GameWarningFlags {
    /** The !:Database.Entities.Game has no warnings */
    None = 0,
    /**
    * If the parent !:Database.Entities.Tournament does not have a submitted pool of
    * !:Database.Entities.Beatmaps, and the !:Database.Entities.Game's !:Database.Entities.Game.Beatmap
    * is played only once throughout the entire !:Database.Entities.Tournament
    */
    BeatmapUsedOnce = 1
}
export interface ProblemDetails {
    type?: string | undefined;
    title?: string | undefined;
    status?: number | undefined;
    detail?: string | undefined;
    instance?: string | undefined;
    [key: string]: any;
}
export interface HttpValidationProblemDetails extends ProblemDetails {
    errors?: {
        [key: string]: string[];
    };
    [key: string]: any;
}
export interface LeaderboardDTO {
    /** The maximum page count for which there will be results */
    pages: number;
    ruleset: Ruleset;
    leaderboard: PlayerRatingStatsDTO[];
}
export interface MatchCompactDTO {
    /** Primary key */
    id: number;
    /** osu! id */
    osuId: number;
    /** Title of the lobby */
    name: string;
    /** Ruleset */
    ruleset: Ruleset;
    /** Start time */
    startTime?: Date | undefined;
    /** End time */
    endTime?: Date | undefined;
    /** Verification status */
    verificationStatus: VerificationStatus;
    /** Rejection reason */
    rejectionReason: MatchRejectionReason;
    /** Warning flags */
    warningFlags: MatchWarningFlags;
    /** Processing status */
    processingStatus: MatchProcessingStatus;
    /** Timestamp of the last time the match was processed */
    lastProcessingDate: Date;
    /** Games played in this match */
    games: GameCompactDTO[];
    /** All associated admin notes */
    adminNotes: AdminNoteDTO[];
}
/** Represents a created match */
export interface MatchCreatedResultDTO extends CreatedResultBaseDTO {
    /** osu! match id */
    osuId?: number;
}
/** Represents a played match */
export interface MatchDTO {
    /** The API.DTOs.TournamentCompactDTO this match was played in */
    tournament?: TournamentCompactDTO;
    /** The participating Database.Entities.Players */
    players?: PlayerCompactDTO[];
    /** Match stats for each participant */
    playerMatchStats?: PlayerMatchStatsDTO[];
    /** Rating adjustments for each participant */
    ratingAdjustments?: RatingAdjustmentDTO[];
    /** Match win record information (Generated by the o!TR Processor) */
    matchWinRecord?: MatchWinRecordDTO | undefined;
    /** Roster information for teams in this match */
    rosters?: MatchRosterDTO[];
    /** List of games played during the match */
    games?: GameDTO[];
    [key: string]: any;
}
export declare enum MatchProcessingStatus {
    /** The System.Text.RegularExpressions.Match needs data requested from the osu! API */
    NeedsData = 0,
    /** The System.Text.RegularExpressions.Match needs automation checks */
    NeedsAutomationChecks = 1,
    /**
    * The System.Text.RegularExpressions.Match is awaiting verification from a
    * !:Database.Entities.User with verifier permission
    */
    NeedsVerification = 2,
    /**
    * The System.Text.RegularExpressions.Match needs stat calculation
    *
    * Generates the !:Database.Entities.MatchRoster and !:Database.Entities.PlayerMatchStats
    */
    NeedsStatCalculation = 3,
    /**
    * The System.Text.RegularExpressions.Match is awaiting rating processor data
    *
    * Generates all !:Database.Entities.Processor.RatingAdjustments
    */
    NeedsRatingProcessorData = 4,
    /** The System.Text.RegularExpressions.Match has completed all processing steps */
    Done = 5
}
export declare enum MatchQuerySortType {
    /** Sort by primary key */
    Id = 0,
    /** Sort by osu! id */
    OsuId = 1,
    /** Sort by start time */
    StartTime = 2,
    /** Sort by end time */
    EndTime = 3,
    /** Sort by creation date */
    Created = 4
}
export declare enum MatchRejectionReason {
    /** The System.Text.RegularExpressions.Match is not rejected */
    None = 0,
    /** The osu! API returned invalid data or no data for the System.Text.RegularExpressions.Match */
    NoData = 1,
    /** The osu! API returned no !:Database.Entities.Games for the System.Text.RegularExpressions.Match */
    NoGames = 2,
    /**
    * The System.Text.RegularExpressions.Match's !:Match.Name does not start with the
    * parent !:Database.Entities.Tournament's !:Database.Entities.Tournament.Abbreviation
    */
    NamePrefixMismatch = 4,
    /**
    * The System.Text.RegularExpressions.Match's !:Entities.Games were eligible for Common.Enums.TeamType.TeamVs
    * conversion and attempting Common.Enums.TeamType.TeamVs conversion was not successful
    */
    FailedTeamVsConversion = 8,
    /**
    * The System.Text.RegularExpressions.Match has no !:Match.Games with a Common.Enums.Verification.VerificationStatus
    * of Common.Enums.Verification.VerificationStatus.Verified or Common.Enums.Verification.VerificationStatus.PreVerified
    */
    NoValidGames = 16,
    /**
    * The System.Text.RegularExpressions.Match's number of !:Match.Games with a Common.Enums.Verification.VerificationStatus
    * of Common.Enums.Verification.VerificationStatus.Verified or Common.Enums.Verification.VerificationStatus.PreVerified is not an odd number
    * (does not satisfy "best of X")
    */
    UnexpectedGameCount = 32,
    /** The System.Text.RegularExpressions.Match's !:Match.EndTime could not be determined */
    NoEndTime = 64,
    /** The !:Database.Entities.Tournament the System.Text.RegularExpressions.Match was played in was rejected */
    RejectedTournament = 128
}
/** Represents roster information for teams in a match */
export interface MatchRosterDTO {
    /** Primary key */
    id: number;
    /** Player IDs for this roster */
    roster: number[];
    /** The team designation */
    team: Team;
    /** The total score for this roster */
    score: number;
    /** Id of the match this roster belongs to */
    matchId: number;
}
/** Represents a search result for a match */
export interface MatchSearchResultDTO {
    /** Id of the match */
    id: number;
    /** osu! match id of the match */
    osuId: number;
    /** Name of the match */
    name: string;
    /** Name of the tournament */
    tournamentName: string;
}
/** Represents the status of a submitted match */
export interface MatchSubmissionStatusDTO {
    /** Id of the match */
    id: number;
    /** osu! match id of the match */
    osuId: number;
    /** Lobby title of the match */
    name?: string | undefined;
    /** Current verification status of the match */
    verificationStatus?: VerificationStatus | undefined;
    /** Date that the match was submitted */
    created: Date;
    /** Date that the match was last updated */
    updated?: Date | undefined;
}
export declare enum MatchWarningFlags {
    /** The System.Text.RegularExpressions.Match has no warnings */
    None = 0,
    /**
    * The System.Text.RegularExpressions.Match's !:Match.Name does not follow common tournament
    * lobby title conventions
    */
    UnexpectedNameFormat = 1,
    /** The System.Text.RegularExpressions.Match's number of !:Match.Games is exactly 3 or 4 */
    LowGameCount = 2,
    /**
    * The System.Text.RegularExpressions.Match has 1 or more !:Database.Entities.Games with a Common.Enums.Verification.GameRejectionReason
    * of Common.Enums.Verification.GameRejectionReason.BeatmapNotPooled outside of the first two !:Database.Entities.Games
    */
    UnexpectedBeatmapsFound = 4,
    /** At least one !:Database.Entities.Player appears in two or more rosters in a System.Text.RegularExpressions.Match */
    OverlappingRosters = 8
}
/** A record of who won and lost a match (Generated by the o!TR Processor) */
export interface MatchWinRecordDTO {
    /** The id of the match */
    matchId: number;
    /** Indicates whether the match ended in a tie */
    isTied: boolean;
    /** The ids of each player on the losing team. Null if tied. */
    loserRoster?: number[] | undefined;
    /** The ids of each player on the winning team. Null if tied. */
    winnerRoster?: number[] | undefined;
    /** The number of points the losing team earned */
    loserPoints: number;
    /** The number of points the winning team earned */
    winnerPoints: number;
    /** The winning team (see Common.Enums.Team). Null if HeadToHead or tied. */
    winnerTeam?: number | undefined;
    /** The losing team (see Common.Enums.Team). Null if HeadToHead or tied. */
    loserTeam?: number | undefined;
}
export declare enum Mods {
    /** No mods enabled */
    None = 0,
    /** No fail (NF) */
    NoFail = 1,
    /** Easy (EZ) */
    Easy = 2,
    /** Touch Device (TD) */
    TouchDevice = 4,
    /** Hidden (HD) */
    Hidden = 8,
    /** Hard Rock (HR) */
    HardRock = 16,
    /** Sudden Death (SD) */
    SuddenDeath = 32,
    /** Double Time (DT) */
    DoubleTime = 64,
    /** Relax (RX) */
    Relax = 128,
    /** Half Time (HT) */
    HalfTime = 256,
    /**
    * Nightcore (NC)
    *
    * Only set along with DoubleTime. i.e: NC only gives 576
    */
    Nightcore = 512,
    /** Flashlight (FL) */
    Flashlight = 1024,
    /** Autoplay (AT) */
    Autoplay = 2048,
    /** Spun Out (SO) */
    SpunOut = 4096,
    /**
    * Autopilot (AP)
    *
    * Autopilot
    */
    Relax2 = 8192,
    /**
    * Perfect (PF)
    *
    * Only set along with Common.Enums.Mods.SuddenDeath. i.e: PF only gives 16416
    */
    Perfect = 16384,
    /**
    * 4 key (4K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    InvalidMods = 22688,
    /**
    * 5 key (5K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key4 = 32768,
    /**
    * 6 key (6K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key5 = 65536,
    /**
    * 7 key (7K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key6 = 131072,
    /**
    * 8 key (8K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key7 = 262144,
    /**
    * Fade In (FI)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key8 = 524288,
    /**
    * Random (RD)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    FadeIn = 1048576,
    /** Cinema (CM) */
    ScoreIncreaseMods = 1049688,
    /** Target Practice (TP) */
    Random = 2097152,
    /**
    * 9 Key (9K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Cinema = 4194304,
    /**
    * Co-op (CO)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Target = 8388608,
    /**
    * 1 Key (1K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key9 = 16777216,
    /**
    * 3 Key (3K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    KeyCoop = 33554432,
    /**
    * 2 Key (2K)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key1 = 67108864,
    /** Score v2 (SV2) */
    Key3 = 134217728,
    /**
    * Mirror (MR)
    *
    * Applicable only to Common.Enums.Ruleset.ManiaOther
    */
    Key2 = 268435456,
    /**
    * Denotes mods that are Common.Enums.Ruleset.ManiaOther key modifiers
    *
    * See https://osu.ppy.sh/wiki/en/Gameplay/Game_modifier/xK
    */
    KeyMod = 521109504,
    /** Denotes mods that are available to use during Free Mod settings */
    FreeModAllowed = 522171579,
    /** Denotes mods that directly impose a modifier on score */
    ScoreV2 = 536870912,
    /** Denotes mods that are ineligible for ratings */
    Mirror = 1073741824
}
/** Represents an OAuth client */
export interface OAuthClientDTO {
    /** Client id of the client */
    clientId: number;
    /** List of permissions granted to the client */
    scopes: string[];
    /** Possible rate limit override for the client */
    rateLimitOverride?: number | undefined;
}
/** Represents a created OAuth client (The only time the client secret is available is when a new client is created) */
export interface OAuthClientCreatedDTO extends OAuthClientDTO {
    /** Client secret of the client */
    clientSecret?: string;
}
export interface OperationBase {
    readonly operationType: OperationType;
    path?: string | undefined;
    op?: string | undefined;
    from?: string | undefined;
}
export interface Operation extends OperationBase {
    value?: any | undefined;
}
export declare enum OperationType {
    /**  */
    Add = 0,
    /**  */
    Remove = 1,
    /**  */
    Replace = 2,
    /**  */
    Move = 3,
    /**  */
    Copy = 4,
    /**  */
    Test = 5,
    /**  */
    Invalid = 6
}
export interface Operation_1 extends Operation {
}
/** Represents platform-wide statistics */
export interface PlatformStatsDTO {
    /** Platform-wide tournament stats */
    tournamentStats: TournamentPlatformStatsDTO;
    /** Platform-wide rating stats */
    ratingStats: RatingPlatformStatsDTO;
    /** Platform-wide user stats */
    userStats: UserPlatformStatsDTO;
}
/** Represents player information */
export interface PlayerCompactDTO {
    /** Id */
    id: number;
    /** osu! id */
    osuId: number;
    /** osu! username */
    username: string;
    /** osu! country code */
    country: string;
    /** The player's primary osu! ruleset */
    defaultRuleset: Ruleset;
    /** Id of the associated user, if available */
    userId?: number | undefined;
}
/** Represents a collection of statistics for a player in a ruleset */
export interface PlayerDashboardStatsDTO {
    /** Player info */
    playerInfo: PlayerCompactDTO;
    /** Ruleset the statistics were calculated for */
    ruleset: Ruleset;
    /** Base stats for the player (If filtered by time, all fields in this class will change.) */
    rating?: PlayerRatingStatsDTO | undefined;
    /** Match stats for the player */
    matchStats?: AggregatePlayerMatchStatsDTO | undefined;
    /** Mod stats for the player */
    modStats?: PlayerModStatsDTO[] | undefined;
    /** Tournament participation and performance stats for the player */
    tournamentPerformanceStats?: PlayerTournamentPerformanceDTO | undefined;
    /** List of frequencies of the player's teammates */
    frequentTeammates?: PlayerFrequencyDTO[] | undefined;
    /** List of frequencies of the player's opponents */
    frequentOpponents?: PlayerFrequencyDTO[] | undefined;
}
/** Represents one player's filtering result */
export interface PlayerFilteringResultDTO {
    /** The id of the player, if found */
    playerId?: number | undefined;
    /** The username of the player, if found */
    username?: string | undefined;
    /** The osu! id of the player */
    osuId: number;
    /** Whether the player successfully passes all conditions of the filter */
    readonly isSuccess: boolean;
    /** If the player failed filtering, the fail reason */
    failureReason?: FilteringFailReason | undefined;
    /** The player's current rating for the requested ruleset */
    currentRating?: number | undefined;
    /** The number of tournaments the player has participated in */
    tournamentsPlayed?: number | undefined;
    /** The number of matches the player has played */
    matchesPlayed?: number | undefined;
    /** The player's all-time peak rating for the requested ruleset */
    peakRating?: number | undefined;
}
/** Represents a player in the context of a teammate or opponent of another player */
export interface PlayerFrequencyDTO {
    /** The player */
    player: PlayerCompactDTO;
    /** Number of times this teammate or opponent has played with the player */
    frequency: number;
}
/** Represents a player's match stats */
export interface PlayerMatchStatsDTO {
    /** The id of the player */
    playerId: number;
    /** The id of the match */
    matchId: number;
    /** Whether the player (or their team) won this match */
    won: boolean;
    /** The player's average score in this match */
    averageScore: number;
    /** The player's average misses in this match */
    averageMisses: number;
    /** The player's average accuracy in this match */
    averageAccuracy: number;
    /** The player's average placement in this match */
    averagePlacement: number;
    /** The number of games the player (or their team) won in the match. (The player must have participated in the game for this to count.
If they were on the same team as the winner, but not in the lobby,
this will not count towards the total.) */
    gamesWon: number;
    /** The number of games the player (or their team) lost in the match. (The player must have participated in the game for this to count.
If they were on the same team as the loser, but not in the lobby,
this will not count towards the total.) */
    gamesLost: number;
    /** The total number of games the player participated in during this match */
    gamesPlayed: number;
    teammateIds: number[];
    /** A unique list of player ids that were on the opposing team as the player in this match. (In a 1v1, this would only contain the opponent's id.) */
    opponentIds: number[];
}
/** Represents counts of participation in games of differing mod combinations */
export interface PlayerModStatsDTO {
    /** The combination of mods used */
    mods: Mods;
    /** The number of times the player participated with this mod combination */
    count: number;
    /** The average score achieved by the player with this mod combination. */
    averageScore: number;
}
/** Describes tournament rating based information for a player in a ruleset that are current and not time specific */
export interface PlayerRatingDTO {
    /** Ruleset */
    ruleset: Ruleset;
    /** Rating */
    rating: number;
    /** Rating volatility */
    volatility: number;
    /** Global rating percentile */
    percentile: number;
    /** Global rank */
    globalRank: number;
    /** Country rank */
    countryRank: number;
    /** The player */
    player: PlayerCompactDTO;
}
/** Describes tournament rating based information for a player in a ruleset with additional statistics (If filtered by time, all fields in this class will change.) */
export interface PlayerRatingStatsDTO extends PlayerRatingDTO {
    /** Total number of tournaments played */
    tournamentsPlayed?: number;
    /** Total number of matches played */
    matchesPlayed?: number;
    /** Match win rate */
    winRate?: number;
    /** Rating tier progress information */
    tierProgress: TierProgressDTO;
    /** A collection of adjustments that describe the changes resulting in the final rating */
    adjustments?: RatingAdjustmentDTO[];
    /** Denotes the current rating as being provisional */
    readonly isProvisional?: boolean;
}
/** Represents a search result for a player for a given ruleset */
export interface PlayerSearchResultDTO {
    /** Id of the player */
    id: number;
    /** osu! id of the player */
    osuId: number;
    /** Rating of the player for the given ruleset */
    rating?: number | undefined;
    /** Ruleset of the player's rating */
    ruleset?: Ruleset | undefined;
    /** Current global rank of the player for the given ruleset */
    globalRank?: number | undefined;
    /** Current rating tier of the player for the given ruleset */
    readonly tierProgress?: TierProgressDTO | undefined;
    /** osu! username of the player */
    username?: string | undefined;
    /** Link to an osu! thumbnail for the player */
    thumbnail: string;
    /** Denotes the player is a friend of the requesting user */
    isFriend: boolean;
}
/** Represents counts of participation in tournaments of differing team sizes */
export interface PlayerTournamentLobbySizeCountDTO {
    /** Number of 1v1 tournaments played */
    count1v1?: number | undefined;
    /** Number of 2v2 tournaments played */
    count2v2?: number | undefined;
    /** Number of 3v3 tournaments played */
    count3v3?: number | undefined;
    /** Number of 4v4 tournaments played */
    count4v4?: number | undefined;
    /** Number of tournaments played outside of standard team sizes */
    countOther?: number | undefined;
}
/** Represents statistics for a player regarding tournament participation and performance */
export interface PlayerTournamentPerformanceDTO {
    /** Counts of participation in tournaments of differing team sizes for the player */
    lobbySizeCounts: PlayerTournamentLobbySizeCountDTO;
    /** List of best tournament performances for the player */
    bestPerformances: PlayerTournamentStatsDTO[];
    /** List of recent tournament performances for the player */
    recentPerformances: PlayerTournamentStatsDTO[];
}
export interface PlayerTournamentStatsBaseDTO {
    /** Average change in rating */
    averageRatingDelta: number;
    /** Average match cost */
    averageMatchCost: number;
    /** Average score */
    averageScore: number;
    /** Average placement */
    averagePlacement: number;
    /** Average accuracy */
    averageAccuracy: number;
    /** Total number of Database.Entities.Matches played */
    matchesPlayed: number;
    /** Total number of Database.Entities.Matches won */
    matchesWon: number;
    /** Total number of Database.Entities.Matches lost */
    matchesLost: number;
    /** Total number of Database.Entities.Games played */
    gamesPlayed: number;
    /** Total number of Database.Entities.Games won */
    gamesWon: number;
    /** Total number of Database.Entities.Games lost */
    gamesLost: number;
    /** The player who owns these stats */
    player: PlayerCompactDTO;
}
export interface PlayerTournamentStatsDTO extends PlayerTournamentStatsBaseDTO {
    /** The tournament that these stats are for */
    tournament?: TournamentCompactDTO;
}
/** Describes a single change to a PlayerRating */
export interface RatingAdjustmentDTO {
    /** The type of event that caused the adjustment */
    adjustmentType: RatingAdjustmentType;
    /** Timestamp of when the adjustment was applied */
    timestamp: Date;
    /** Rating before the adjustment */
    ratingBefore: number;
    /** Rating after the adjustment */
    ratingAfter: number;
    /** Total change in rating */
    ratingDelta: number;
    /** Rating volatility before the adjustment */
    volatilityBefore: number;
    /** Rating volatility after the adjustment */
    volatilityAfter: number;
    /** Total change in rating volatility */
    volatilityDelta: number;
    /** Id of the match the adjustment was created for if available */
    match?: MatchCompactDTO | undefined;
}
export declare enum RatingAdjustmentType {
    /** The !:Database.Entities.Processor.RatingAdjustment is the initial rating */
    Initial = 0,
    /** The !:Database.Entities.Processor.RatingAdjustment is the result of a period of inactivity (decay) */
    Decay = 1,
    /** The !:Database.Entities.Processor.RatingAdjustment is the result of participation in a System.Text.RegularExpressions.Match */
    Match = 2
}
/** Represents platform-wide Database.Entities.Processor.PlayerRating stats */
export interface RatingPlatformStatsDTO {
    /** For each ruleset, a map of rating 'buckets' (i.e. 100, 125, 150, etc. rating)s
to the number of Database.Entities.Players in that 'bucket' */
    ratingsByRuleset: RatingsByRuleset;
}
/** The possible roles assignable to a user or client */
export declare enum Roles {
    /** Role granted to all users. */
    User = "user",
    /** Role granted to all clients. */
    Client = "client",
    /** Role granted to privileged users. */
    Admin = "admin",
    /** Role granted to users with permission to verify submission data. */
    Verifier = "verifier",
    /** Role granted to users with permission to submit tournament data. */
    Submit = "submit",
    /** Role granted to users and clients to allow access during times of restricted use. */
    Whitelist = "whitelist"
}
export declare enum Ruleset {
    /** osu! (standard) */
    Osu = 0,
    /** osu! Taiko */
    Taiko = 1,
    /** osu! Catch (aka Fruits) */
    Catch = 2,
    /**
    * osu! Mania
    *
    * Encompasses all of the osu!mania ruleset and represents a ruleset that has
    * not yet been identified as either Common.Enums.Ruleset.Mania4k or Common.Enums.Ruleset.Mania7k
    */
    ManiaOther = 3,
    /** osu! Mania 4k variant */
    Mania4k = 4,
    /** osu! Mania 7k variant */
    Mania7k = 5
}
export declare enum ScoreGrade {
    /** 100% accuracy with Common.Enums.Mods.Hidden and/or Common.Enums.Mods.Flashlight */
    SSH = 0,
    /** Over 90% 300s, less than 1% 50s and no misses with Common.Enums.Mods.Hidden and/or Common.Enums.Mods.Flashlight */
    SH = 1,
    /** 100% accuracy */
    SS = 2,
    /** Over 90% 300s, less than 1% 50s and no misses */
    S = 3,
    /** Over 80% 300s and no misses OR over 90% 300s */
    A = 4,
    /** Over 70% 300s and no misses OR over 80% 300s */
    B = 5,
    /** Over 60% 300s */
    C = 6,
    /** Anything else */
    D = 7
}
export declare enum ScoreProcessingStatus {
    /** The !:Database.Entities.GameScore needs automation checks */
    NeedsAutomationChecks = 0,
    /**
    * The !:Database.Entities.GameScore is awaiting verification from a
    * !:Database.Entities.User with verifier permission
    */
    NeedsVerification = 1,
    /** The !:Database.Entities.GameScore has completed all processing steps */
    Done = 2
}
export declare enum ScoreRejectionReason {
    /** The !:Database.Entities.GameScore is not rejected */
    None = 0,
    /** The !:Database.Entities.GameScore's !:Database.Entities.GameScore.Score is below the minimum threshold */
    ScoreBelowMinimum = 1,
    /** The !:Database.Entities.GameScore was set with any Common.Enums.Mods.InvalidMods */
    InvalidMods = 2,
    /** The !:Database.Entities.GameScore's Common.Enums.Ruleset does not match that of the parent !:Database.Entities.Tournament */
    RulesetMismatch = 4,
    /** The !:Database.Entities.Game the !:Database.Entities.GameScore was set in was rejected */
    RejectedGame = 8
}
export declare enum ScoringType {
    /** Scoring based on Score v1 */
    Score = 0,
    /** Scoring based on accuracy */
    Accuracy = 1,
    /** Scoring based on combo */
    Combo = 2,
    /** Scoring based on Score v2 */
    ScoreV2 = 3
}
/** Represents a collection of search results */
export interface SearchResponseCollectionDTO {
    /** A collection of search results for tournaments matching the search query */
    tournaments: TournamentSearchResultDTO[];
    /** A collection of search results for matches matching the search query */
    matches: MatchSearchResultDTO[];
    /** A collection of search results for players matching the search query */
    players: PlayerSearchResultDTO[];
}
export declare enum Team {
    /** No team */
    NoTeam = 0,
    /** Team blue */
    Blue = 1,
    /** Team red */
    Red = 2
}
export declare enum TeamType {
    /** Free for all */
    HeadToHead = 0,
    /**
    * Free for all (Tag format)
    *
    * All players play tag on the same beatmap
    */
    TagCoop = 1,
    /** Team red vs team blue */
    TeamVs = 2,
    /** Team red vs team blue (Tag format) */
    TagTeamVs = 3
}
/** Represents rating tier progress data */
export interface TierProgressDTO {
    /** Current tier */
    currentTier: string;
    /** Current sub tier */
    currentSubTier?: number | undefined;
    /** Name of the next major tier (Null if there is no next major tier, e.g. when the rating value is within the maximum tier) */
    nextTier?: string | undefined;
    /** Next sub tier */
    nextSubTier?: number | undefined;
    /** Rating required to reach next sub tier */
    ratingForNextTier: number;
    /** Rating required to reach next major tier */
    ratingForNextMajorTier: number;
    /** Major tier following current major tier */
    nextMajorTier?: string | undefined;
    /** Progress to the next sub tier as a percentage */
    subTierFillPercentage?: number | undefined;
    /** Progress to the next major tier as a percentage */
    majorTierFillPercentage?: number | undefined;
}
/** Represents a tournament with minimal data */
export interface TournamentCompactDTO {
    /** Id */
    id: number;
    /** The timestamp of submission */
    created: Date;
    /** Full name */
    name: string;
    abbreviation: string;
    /** The osu! forum post or wiki page this tournament is featured by (If both are present, the osu! forum post should be used) */
    forumUrl: string;
    /** Lowest rank a player can be to participate */
    rankRangeLowerBound: number;
    /** Ruleset in which all matches are played */
    ruleset: Ruleset;
    /** Expected in-match team size */
    lobbySize: number;
    /** The start date of the first match */
    startTime: Date;
    /** The end date of the last match */
    endTime: Date;
    /** The state of verification */
    verificationStatus: VerificationStatus;
    /** The state of processing */
    processingStatus: TournamentProcessingStatus;
    /** The rejection reason */
    rejectionReason: TournamentRejectionReason;
    /** The user that submitted the tournament */
    submittedByUser?: UserCompactDTO | undefined;
    /** The user that verified the tournament */
    verifiedByUser?: UserCompactDTO | undefined;
}
/** Represents a created tournament */
export interface TournamentCreatedResultDTO extends CreatedResultBaseDTO {
    /** The name of the tournament */
    name: string;
    /** Acronym / shortened name of the tournament
<example>For osu! World Cup 2023, this value would be "OWC23"</example> */
    abbreviation: string;
    /** List of created matches */
    matches?: MatchCreatedResultDTO[];
}
/** Represents a tournament including optional data */
export interface TournamentDTO extends TournamentCompactDTO {
    /** All associated match data (Will be empty for bulk requests such as List) */
    matches?: MatchCompactDTO[];
    /** All admin notes associated with the tournament */
    adminNotes?: AdminNoteDTO[];
    /** All player tournament stats associated with the tournament */
    playerTournamentStats?: PlayerTournamentStatsBaseDTO[];
    /** All beatmaps pooled for this tournament */
    pooledBeatmaps?: BeatmapDTO[];
}
/** Represents platform-wide Database.Entities.Tournament stats */
export interface TournamentPlatformStatsDTO {
    /** Total number of Database.Entities.Tournaments */
    totalCount: number;
    /** Map of Common.Enums.Verification.VerificationStatuses to the number of Database.Entities.Tournaments with the status */
    countByVerificationStatus: CountByVerificationStatus;
    /** Map of years to the number of verified Database.Entities.Tournaments in that year */
    verifiedByYear: {
        [key: string]: number;
    };
    /** Map of Common.Enums.Rulesets to the number of verified Database.Entities.Tournaments in that ruleset */
    verifiedByRuleset: VerifiedByRuleset;
    /** Map of lobby sizes to the number of verified Database.Entities.Tournaments with that lobby size */
    verifiedByLobbySize: {
        [key: string]: number;
    };
}
export declare enum TournamentProcessingStatus {
    /**
    * The !:Database.Entities.Tournament is awaiting approval from a
    * !:Database.Entities.User with verifier permission
    *
    * Functions as the entry point to the processing flow. No entities owned by a !:Database.Entities.Tournament
    * will advance through the processing flow until approved.
    */
    NeedsApproval = 0,
    /**
    * The !:Database.Entities.Tournament has System.Text.RegularExpressions.Matches with a
    * Common.Enums.Verification.MatchProcessingStatus of Common.Enums.Verification.MatchProcessingStatus.NeedsData
    */
    NeedsMatchData = 1,
    /** The !:Database.Entities.Tournament needs automation checks */
    NeedsAutomationChecks = 2,
    /**
    * The !:Database.Entities.Tournament is awaiting verification from a
    * !:Database.Entities.User with verifier permission
    */
    NeedsVerification = 3,
    /** The !:Database.Entities.Tournament needs stat calculation */
    NeedsStatCalculation = 4,
    /** The tournament has completed all processing steps */
    Done = 5
}
export declare enum TournamentQuerySortType {
    /** Sort by primary key */
    Id = 0,
    /** Sort by start date */
    StartTime = 1,
    /** Sort by end date */
    EndTime = 2,
    /** Sort by name */
    SearchQueryRelevance = 3,
    /** Sort by submission date */
    SubmissionDate = 4,
    /** Sort by lobby size */
    LobbySize = 5
}
export declare enum TournamentRejectionReason {
    /** The !:Database.Entities.Tournament is not rejected */
    None = 0,
    /**
    * The !:Database.Entities.Tournament has no !:Database.Entities.Tournament.Matches with a
    * Common.Enums.Verification.VerificationStatus of Common.Enums.Verification.VerificationStatus.Verified or Common.Enums.Verification.VerificationStatus.PreVerified
    */
    NoVerifiedMatches = 1,
    /**
    * The !:Database.Entities.Tournament's number of !:Database.Entities.Tournament.Matches with a
    * Common.Enums.Verification.VerificationStatus of Common.Enums.Verification.VerificationStatus.Verified or
    * Common.Enums.Verification.VerificationStatus.PreVerified is below 80% of the total
    */
    NotEnoughVerifiedMatches = 2,
    /**
    * The !:Database.Entities.Tournament's win condition is not Common.Enums.ScoringType.ScoreV2
    *
    * Only assigned via a "rejected submission".
    *
    * Covers cases such as gimmicky win conditions, mixed win conditions, etc
    */
    AbnormalWinCondition = 4,
    /**
    * The !:Database.Entities.Tournament's format is not suitable for ratings
    *
    * Only assigned via a "rejected submission".
    *
    * Covers cases such as excessive gimmicks, relax, multiple modes, etc
    */
    AbnormalFormat = 8,
    /**
    * The !:Database.Entities.Tournament's lobby sizes are not consistent.
    *
    * Only assigned via a "rejected submission".
    *
    * Covers cases such as > 2 teams in lobby at once, async lobbies, team size gimmicks, varying team sizes, etc
    */
    VaryingLobbySize = 16,
    /**
    * The !:Database.Entities.Tournament's data is incomplete or not recoverable
    * Covers cases where match links are lost to time, private,
    * main sheet is deleted, missing rounds, etc.
    *
    * Only assigned via a "rejected submission".
    *
    * Covers cases where match links are lost to time / dead / private, main sheet is deleted, missing rounds, etc
    */
    IncompleteData = 32
}
/** Represents a search result for a tournament */
export interface TournamentSearchResultDTO {
    /** Id of the tournament */
    id: number;
    /** Ruleset of the tournament */
    ruleset: Ruleset;
    /** Verification status of the tournament */
    verificationStatus: VerificationStatus;
    /** Rejection reason of the tournament */
    rejectionReason: TournamentRejectionReason;
    /** Abbreviation of the tournament */
    abbreviation?: string | undefined;
    /** Expected in-match team size */
    lobbySize: number;
    /** Name of the tournament */
    name: string;
}
/** An incoming tournament submission */
export interface TournamentSubmissionDTO {
    /** The name of the tournament */
    name: string;
    /** Acronym / shortened name of the tournament */
    abbreviation: string;
    /** The osu! forum post advertising this tournament */
    forumUrl: string;
    /** Lowest rank a player can be to participate in the tournament */
    rankRangeLowerBound: number;
    /** Expected in-match team size */
    lobbySize: number;
    /** osu! ruleset */
    ruleset: Ruleset;
    /** Optional rejection reason. If set, the created tournament and all matches will be rejected
for this reason and go through no additional processing (Submissions with a rejection reason will only be accepted from admin users) */
    rejectionReason?: TournamentRejectionReason | undefined;
    /** List of osu! match ids */
    ids: number[];
    /** A collection of pooled osu! beatmap ids */
    beatmapIds: number[];
}
/** Represents user information */
export interface UserCompactDTO {
    /** Id */
    id: number;
    /** Timestamp of the user's last login to the o!TR website */
    lastLogin?: Date | undefined;
    /** The associated player */
    player: PlayerCompactDTO;
}
/** Represents user information including optional data */
export interface UserDTO extends UserCompactDTO {
    /** List of permissions granted to the user */
    scopes?: string[];
    /** Settings of the user */
    settings?: UserSettingsDTO;
}
/** Represents platform-wide Database.Entities.User stats */
export interface UserPlatformStatsDTO {
    /** Map of dates to the total number of registered Database.Entities.Users as of that time (One entry per day beginning from the date of the first registered user) */
    sumByDate: {
        [key: string]: number;
    };
}
/** Represents user controlled settings for otr-web */
export interface UserSettingsDTO {
    /** Preferred ruleset of the associated user */
    ruleset: Ruleset;
    /** Denotes whether the associated user has overwritten their default ruleset (If false, the default ruleset is always the same as the user's default ruleset on the osu! website) */
    rulesetIsControlled: boolean;
}
export declare enum VerificationStatus {
    /** Verification status has not yet been assigned */
    None = 0,
    /** The Data Worker has identified an issue during processing */
    PreRejected = 1,
    /** The Data Worker has not identified any issues during processing */
    PreVerified = 2,
    /** Determined to be unfit for ratings by manual review */
    Rejected = 3,
    /** Determined to be fit for ratings by manual review */
    Verified = 4
}
export interface RatingsByRuleset {
    Osu: {
        [key: string]: number;
    };
    Taiko: {
        [key: string]: number;
    };
    Catch: {
        [key: string]: number;
    };
    ManiaOther: {
        [key: string]: number;
    };
    Mania4k: {
        [key: string]: number;
    };
    Mania7k: {
        [key: string]: number;
    };
}
export interface CountByVerificationStatus {
    None: number;
    PreRejected: number;
    PreVerified: number;
    Rejected: number;
    Verified: number;
}
export interface VerifiedByRuleset {
    Osu: number;
    Taiko: number;
    Catch: number;
    ManiaOther: number;
    Mania4k: number;
    Mania7k: number;
}
export declare class OtrApiResponse<TResult> {
    status: number;
    headers: {
        [key: string]: any;
    };
    result: TResult;
    constructor(status: number, headers: {
        [key: string]: any;
    }, result: TResult);
}
export declare class OtrApiError extends Error {
    message: string;
    status: number;
    response: string;
    headers: {
        [key: string]: any;
    };
    result: any;
    constructor(message: string, status: number, response: string, headers: {
        [key: string]: any;
    }, result: any);
    protected isOtrApiError: boolean;
    static isOtrApiError(obj: any): obj is OtrApiError;
}
declare module 'axios' {
    interface AxiosRequestConfig {
        /**
         * Denotes if the route requires authorization to access
         */
        requiresAuthorization?: boolean;
    }
}
/** Configuration required for o!TR API Wrappers */
export interface IOtrApiWrapperConfiguration {
    /** The base URL of the API */
    baseUrl: string;
    /** Defaults used to created the inner axios client */
    clientConfiguration?: CreateAxiosDefaults;
    /** Function to configure the inner axios client after creation . Called during creation of the wrapper */
    postConfigureClientMethod?: (instance: AxiosInstance) => void;
}
/** Default configuration used to create wrapper instances */
export declare const defaults: IOtrApiWrapperConfiguration;