TTAR.API

User's internal operations. Need to think about union with Players kind of operations.

Minimum length enforced for new passwords (set or reset).

Whether a password-reset link may go to the account's address. For a password-less account (SSO, merged) the link sets the first credential and confirms the address, so only a verified address gets it.

Issues a fresh password-reset token for (voiding the outstanding ones) and emails the link to the account address. No-op within the cooldown window.

Stamps (and, when the client reported a newer app , ) in its own committed statement, separate from the token rotation. It must NOT share the rotation transaction: that txn INSERTs a child token row which takes a shared lock on the parent Players row, and an X-lock UPDATE of the same row then deadlocks concurrent same-player rotations (InnoDB S->X upgrade, error 1213). Done as a standalone keyed ExecuteUpdate on a fresh context, it only ever X-locks the single Players row by PK (no child-FK shared lock in scope, and both fields in one statement so the refresh path touches that row once), so it cannot form that cycle. LastTokenDate is a soft "has this account ever minted a token" marker (read only via HasValue), so the exact value — and a rare lost write — does not matter.

Issues a fresh confirmation token (invalidating prior ones of the same kind) and sends the email.

Database context used for token persistence. The player for whom the confirmation token is issued. Target address for a change-email token, or null for a registration token. Address the email is sent to. Factory that builds the confirmation URL from a raw token string. Language from the request; falls back to the user's stored preference. Token to observe for cancellation requests.

Marks unused confirmation tokens for the player as used, so only the newest link works.

true to target change-email tokens; false for registration tokens. Token id to keep untouched (the one just created/used), if any.

Role-based authorization policies. Each policy passes when the caller holds the policy's own role OR — so an admin satisfies every role-gated endpoint without being granted the other roles explicitly (the "Admin implies all" rule lives here, in one place, not scattered across [Authorize] lists or duplicated in the JWT claims). Names are referenced from [Authorize(Policy = ...)] — keep them here.

Read admin statistics — or .

Moderate any venue — or .

Moderate our chat surface — or .

Registers all role policies. Adds one policy per privileged role, each admitting Admin as well.

The single definition of the "Admin implies every role" rule: the role names that satisfy a check for — the role itself plus . Both the policies above and TtarControllerBase.IsInRole resolve through here, so the super-role rule lives in exactly one place.

Builds the client callback URLs of the redirect-based external sign-ins (Google, Telegram). The result travels in the fragment so it never reaches a server log.

Callback URL reporting a failed sign-in.

Allowlisted client callback URI. The failure reason. The callback URL with the error in its fragment.

Keeps the OIDC server-side and puts only a random key into state. Telegram rejects a state longer than 256 characters ("state too long"), while the default data-protected properties (callback URL, PKCE verifier, correlation id) take ~700.

In-process cache: every instance of the API must handle both legs of a sign-in (single-instance hosting).

The client a session is issued to, one fact per field (persisted on ): which TTAR app, its version, the device the app described, the HTTP User-Agent and the IP address.

Request header naming the TTAR app, a member name (e.g. Web).

Request header carrying the client app version (e.g. 3.1.5.0).

The TTAR app, null when the client did not identify itself.

Normalized app version ( format).

Device description reported by the mobile app, without the owner-chosen device name.

User-Agent header of the current request.

Client IP address.

Describes the caller of . Explicit values (body / query) win over the / headers; may still be in a pre-header format, which is unpacked into the matching fields.

Describes the caller of an external sign-in callback: the app, version and device come from what saved at the challenge, the User-Agent and IP from the callback request itself.

Saves the app, version and device into the round-trip properties of an external sign-in challenge, to be read back by .

The client of a rotated session: every field the current request reported, the rest carried over from the session being replaced (the same device).

Drops the owner-chosen device name from the app's device JSON; any other value is returned unchanged.

For the callback of an external sign-in, which is a top-level browser navigation: an unexpected failure returns the user to the client with instead of a bare 500 on the API host, and is still logged and reported to the admin like any unhandled exception. Expected outcomes (e.g. a removed account) stay in the action.

Creates the filter for the callback of .

The external authentication scheme whose callback the action completes.

User's internal operations. Need to think about union with Players kind of operations.

Authenticates a user by email/password

Authentication request The client, recorded on the session when one is created Cancellation token Claims and tokens Exception thrown when an account has been removed and cannot be authenticated

Verifies email/password and account state (removed, email-confirmed) WITHOUT minting any token, for the interactive OIDC login page which establishes only a cookie — so it does not orphan an unused refresh token.

Account email. Account password. Cancellation token. The player when the credentials are valid; otherwise null. Thrown when the account has been removed. Thrown when the email is not confirmed.

Authenticates a user by already validated (by SSO) email Creates new record if not exists.

Email User name, will be specified on creating new user Whether to issue a long-lived session token The client for the session record (when is true) Cancellation token Claims and tokens, session token included when is true Exception thrown when an account has been removed and cannot be authenticated

Authenticates a user, nothing verified

Already authenticated user Cancellation token Claims and tokens

Authenticates a user, nothing verified. Optionally creates a long-lived session token.

Already authenticated user Whether to issue a long-lived session token The client for the session record Cancellation token Claims and tokens, session token included when is true

Authenticates a user with Refresh Token

Refresh token Session token value Latest client app version, folded into the same post-rotation Players write when newer The current client, recorded on the rotated session; fields it lacks are kept from the old session Cancellation token Claims and tokens Exception thrown when an account has been removed and cannot be authenticated

Revokes Refresh Token

Refresh token Cancellation token Revocation result

Revokes all user's Refresh tokens

Target user Cancellation token

Requests removal of a user account.

The email address of the user. The reason for account removal. Cancellation token. Status of the account removal request.

Changes a profile of the user

User id User name, if specified Password, if specified Indicates whether private messages should be copied to Telegram Preferred language code, if specified Whether the displayed name follows the RTTF profile; ignored unless the link is confirmed The player's physical main hand. Storing a value sets the profile label (never moves ratings between axes) and dismisses the "please confirm" prompt. It is a ONE-TIME, IRREVERSIBLE choice: once set, re-sending the same value is an idempotent no-op, but a different value throws . null leaves it untouched (it is NOT a way to clear the hand back to "not set"). The player's gender — a one-time choice like : re-sending the same value is a no-op, a different one throws . null leaves it untouched. The "Contacts and about" block, replaced as a whole (a null field inside clears it, including the other-rating links). null leaves the whole block untouched. Cancellation token Updated player's profile The login email cannot be changed here; use instead. Thrown if either the sender or recipient is not found in the database Thrown when changing an already-set main hand to a different value. Thrown when is not a defined . Thrown when changing an already-set gender to a different value. Thrown when a field of is invalid.

Authenticates a user by custom Telegram token

Custom Telegram token Whether to issue a long-lived session token The client for the session record (when is true) Cancellation token Claims and tokens, session token included when is true Thrown if either the sender or recipient is not found in the database

Authenticates a user signed in through Telegram OpenID Connect, creating the player on first sign-in.

The Telegram user asserted by the validated ID token Whether to issue a long-lived session token The client for the session record (when is true) Cancellation token Claims and tokens, session token included when is true Thrown if the player's account has been removed

Issues a server-generated custom Telegram token for the player behind a Telegram OpenID Connect sign-in (creating the player on first sign-in). The token proves Telegram ownership to the existing merge flow.

The Telegram user asserted by the validated ID token Cancellation token The custom Telegram token accepted by POST /Account/Telegram and PUT /Players/merge Thrown if the player's account has been removed

Mints a one-time, short-lived code for the web-delegated OIDC login handoff. Bound to the given player; redeemed once at /connect/login-callback to establish the IdP cookie.

The authenticated player the code is minted for. Cancellation token. The opaque code value.

Redeems a one-time login-exchange code (single-use) and returns the associated player id.

The code to redeem. Cancellation token. The player id if the code was valid and is now consumed; otherwise null.

Returns whether the account is currently removed (an outstanding AccountRemovals record simulates deletion until it is manually cleared), so the OIDC endpoints can deny access the same way native auth does.

The account email to check. Cancellation token. true when a removal record exists for the email.

Initiates a password reset: generates a single-use token and sends a reset link by email. Does nothing (no error) when the email is unknown, or the account has no password credential and its address is not verified (the link would set its first credential), so callers must not reveal account existence to the client.

The account email. Builds the reset link from the generated token (e.g. a deep link). Preferred language for the reset email; falls back to the user's stored preference. Cancellation token Thrown when the account has been removed.

Completes a password reset using a previously issued token. On success, sets the new password and revokes all refresh tokens and sessions.

The reset token received by email. The new password to set. Cancellation token true if the password was reset; false if the token is invalid, expired, already used, or the password is too short. Thrown when the account has been removed.

Registers a new account with an email and password and sends an email-confirmation link. The account is created unverified and cannot be authenticated until the email is confirmed. If the email already belongs to a password-less account (created via SSO), no password is set: the address owner is emailed a set-password (reset) link instead — only to a verified address, as by — so knowing an address never yields its account.

The account email. The password to set on a new account (hashed before storage). Optional display name for a newly created account. Builds the confirmation link from the generated token. Builds the set-password link for an existing password-less account. Preferred language for the email; falls back to English when omitted. Cancellation token Thrown when the account has been removed. Thrown when an account with this email and a password already exists.

Confirms an account email using a token from the confirmation email and logs the user in.

The confirmation token received by email. The client, recorded on the session when one is created. Whether to issue a long-lived session token. Cancellation token Claims and tokens on success; null if the token is invalid, expired or already used. Thrown when the account has been removed.

Re-sends the email-confirmation link for an unverified account. Does nothing (no error) when the email is unknown, already verified, or the account has no password, so callers must not reveal account existence to the client.

The account email. Builds the confirmation link from the generated token. Preferred language for the confirmation email; falls back to the user's stored preference. Cancellation token Thrown when the account has been removed.

Sends the signed-in player a link confirming their current address, password or not — notification emails go only to a confirmed one. The link is an email change to the same address (), which signs nobody in. Does nothing when the player has no address, it is already confirmed or a change of it is pending; throttled like .

The signed-in player. Builds the email-change confirmation link from the generated token. Preferred language for the email; falls back to the user's stored preference. Cancellation token

Changes the password of an authenticated user. Verifies the current password first (unless the account has no password yet — e.g. SSO-only — in which case it sets the initial password). On success, revokes all existing refresh tokens and sessions (logging the account out everywhere) and issues a fresh set of tokens for the current device, so the caller stays signed in without re-authenticating.

User id. The current password; ignored when the account has no password yet. The new password to set. Whether the re-issued tokens include a long-lived session token for the current device. The client for the re-issued session (when is true); its User-Agent and IP also go to the security audit log. Cancellation token A fresh (new JWT, refresh token, and session token when is true) on success; null if the current password is wrong or the new password is too short. Thrown when the user is not found.

Starts the change-email flow: stores the new address as pending and sends a confirmation link to it. The login email is only switched once the new address is confirmed (see ). Requires the account to already have a password and verifies the supplied current password first; a password-less (SSO/Telegram) account is refused with and must set a password before changing its login email.

User id. The new email address to switch to. The current password; required. The request fails with if it is null/empty or incorrect. Builds the confirmation link from the generated token. Preferred language for the confirmation email; falls back to the user's stored preference. Cancellation token The outcome of the request: , , , or for a password-less account. Thrown when the user is not found.

Completes the change-email flow using a token from the confirmation email. Sets the login email to the previously pending address and marks it confirmed.

The confirmation token received by email at the new address. Cancellation token true on success; false if the token is invalid, expired, already used, or the address became taken.

Re-sends the email-change confirmation link to the pending address for an authenticated user. Does nothing (no error) when no email change is pending, so callers must not reveal internal state to the client. Subject to the same rate-limiting as the initial request.

The authenticated user's id. Builds the confirmation link from the generated token. Preferred language for the confirmation email; falls back to the user's stored preference. Cancellation token Thrown when the user is not found.

Cancels a pending email change initiated by the user: clears PendingEmail and invalidates any outstanding change-email confirmation tokens. Does nothing when no change is pending.

The authenticated user's id. Cancellation token Thrown when the user is not found.

Updates version information

User id Version of the mobile application Cancellation token Updated Thrown if either the sender or recipient is not found in the database

Updates user geographical information

User id User's location Cancellation token Updated or null if not set Thrown if either the sender or recipient is not found in the database

Re-issues JWT and refresh tokens using a long-lived session token. Rotates the session token on success (sliding session).

Session token value The current client, recorded on the rotated session; fields it lacks are kept from the old session Latest client app version, folded into the same post-rotation Players write when newer Cancellation token New claims and tokens, or null if the session token is invalid/expired Thrown when the account has been removed

Revokes a single session token (e.g. logout on one device).

Session token value Cancellation token true if revoked; false if not found or already inactive

Revokes all active session tokens for the given player (e.g. account deletion).

Target player Cancellation token

Single source of truth for the privileged roles a player holds. Centralised so every profile-returning endpoint (login, profile read, profile edit, RTTF reload) exposes the same roles for the same player.

Resolves the roles the given player holds.

The player to resolve roles for. The roles held; empty for an ordinary user.

Operates with different tokens, including SSO

Generates Refresh token

Refresh token

Generates a long-lived session token for "remember me" functionality

Player id to associate the session with The client the session is issued to, null when unknown Session token model

Creates Bearer token

User settings Bearer token

Performs Google web authentication

Original HTTP request List of claims if authenticated; null otherwise

Builds the absolute avatar URL for the OIDC picture claim. The app otherwise serves avatars via the relative Images/avatar/{name} path (see ImagesController); partners need an absolute URL, so it is prefixed with the issuer.

Returns the absolute avatar URL for the player, or null when the player has no avatar image.

The player whose avatar is resolved (Images must be loaded). Absolute issuer base URL (e.g. https://ttar.app).

The "Login with TTAR" IdP session: the principal kept in the default cookie scheme by the sign-in points (Razor login page, web-delegated login callback) and read back by /connect/authorize.

Builds the cookie principal for a player who has just signed in interactively.

The signed-in player. The moment of the interactive sign-in (becomes the OIDC auth_time). Additional claims to keep in the cookie.

Reads the interactive sign-in time from a cookie (or authorization/refresh token) principal.

The sign-in time, or null for a session established before auth_time was stamped.

Creates the OIDC auth_time claim (Unix seconds) destined for the identity token.

Maps a to the OpenID Connect claims granted by a set of scopes, and assigns each claim its token destinations (id_token and/or access_token).

Builds the claims identity for the given player and granted scopes. The sub claim (player id) is always present; other claims are added only when their scope is granted and the underlying value exists.

The authenticated player (Hands and Images should be loaded for full claims). The scopes granted to the client for this authorization. A list of claims with per-claim destinations set.

Custom claim names surfaced by the "Login with TTAR" provider, in addition to the standard OIDC claims. Distinct from the scope names in (the scope gates the claim; the claim is the payload key). Underscore form (not the colon'd scope name) so the key is a plain JWT/JSON identifier.

Per-hand rating data as a JSON array string. Gated by the scope; surfaced in /userinfo (access-token destination), kept out of the id_token.

Custom OpenIddict scope names exposed by the "Login with TTAR" provider, in addition to the standard openid/profile/email/offline_access.

Grants the player's rating data (per-hand rating, games, qualification) in /userinfo.

Grants the player's aggregate game statistics in /userinfo.

The single place player roles are resolved. Roles come from the persisted (the PlayerRoles table), unioned with a hard-wired safety net: the configured super administrator is always an , so a bad/empty/unreadable role table can never lock the operator out of the admin surface. The "Admin implies every other role" rule is NOT applied here (it would bloat the JWT with all roles) — it lives in the authorization policies, which OR Admin into each role check.

Composed-host constructor: the persisted store is required, so a mis-wired host fails fast.

Test-only constructor: super-admin-by-id behaviour with no database.

A Telegram user as asserted by a validated Telegram OpenID Connect ID token.

Numeric Telegram user id (the same id the bot sees). Display name from the Telegram profile. Telegram @username without the @; null when the user has none. Profile photo URL, if any. Telegram-verified phone number in E.164 (+<digits>), if the user shared it. Whether the user allowed the bot to message them (telegram:bot_access).

A Telegram user as asserted by a validated Telegram OpenID Connect ID token.

Numeric Telegram user id (the same id the bot sees).

Display name from the Telegram profile.

Telegram @username without the @; null when the user has none.

Profile photo URL, if any.

Telegram-verified phone number in E.164 (+<digits>), if the user shared it.

Whether the user allowed the bot to message them (telegram:bot_access).

Claim added to the sign-in principal when the token endpoint reported telegram:bot_access as granted.

Builds the identity from the claims of a Telegram OIDC sign-in (raw JWT claim names, no inbound mapping).

The principal produced by the Telegram OIDC handler. The identity, or null when no numeric Telegram user id is present.

Normalizes a phone number to E.164 (+ followed by 7–15 digits); Telegram sends digits without +.

Raw phone number. The normalized number, or null when absent or not a plausible phone number.

Constants of the Telegram OpenID Connect sign-in (Telegram Login in OIDC mode, configured in BotFather).

Authentication scheme name of the Telegram OIDC handler.

Short-lived cookie scheme holding the Telegram result between the OIDC callback and the response endpoint.

OIDC issuer / discovery authority.

Redirect URI registered in BotFather ("Allowed URLs") for every API environment.

Scope that lets the bot message the user after sign-in.

Authentication-properties item carrying the client's (already allowlisted) redirect URI through the round trip, so a failed or cancelled sign-in can still be reported back to the client.

Authentication-properties item carrying a short random id of one sign-in attempt, so its log lines (started, returned, failed, abandoned) can be joined.

What a Telegram OIDC sign-in is used for.

Prove Telegram ownership and return a custom Telegram token for merging into the current account.

Operates with different tokens, including SSO

Creates Bearer token

List of user's claims Bearer token

The application settings

Telegram bot name

Mobile application scheme name for organizing callbacks

Base web URL used to build the password reset link sent by email (e.g. https://ttar.app). The link opens the mobile app via Universal/App Links when installed, otherwise the web reset page.

The emailed link confirming the account's address by its .

The emailed link confirming an address change (or the current address) by its .

The emailed link setting a new password by its : an https link that opens the mobile app via Universal/App Links when installed, otherwise the web reset page.

Gets or sets the list of allowed CORS origins for the application.

Each origin should be specified as a valid URI. Use "*" to allow all origins, but be cautious as this may expose the application to security risks. If the array is empty, no origins will be allowed.

Web callback URIs (e.g. https://ttar.app/auth) that an external sign-in (Google, Telegram) may return its tokens to. The mobile default {MobileAppScheme}://auth is always allowed and need not be listed.

Default callback of an external sign-in when the client passes no redirectUri.

Checks whether an external sign-in may hand its tokens to : null (the mobile default) or an exact scheme + host + port + path match against the allowlist, with no query or fragment.

The client-supplied redirect URI. true when the URI is allowed.

Options to configure Bearer token

The token issuer

The token consumer

Secret key for token encoding

Bearer token expiration time in minutes

Refresh Token expiration time in days

Grace period in seconds during which a recently revoked refresh or session token can be reused. Protects against connection drops during token refresh. Set to 0 to disable.

Longer window (seconds since revocation) during which a rotated refresh or session token can still be replayed while its replacement has never been used. Covers a response lost after the rotation (e.g. the web's server-side refresh whose page never reached the browser). Set to 0 to disable.

Session token (remember me) expiration time in days.

Password reset token expiration time in minutes.

Email confirmation token expiration time in minutes (registration and change-email flows).

One-time login-exchange code lifetime in seconds (web-delegated OIDC login handoff). Kept very short — the code only needs to survive the single callback hop from the web client to the API.

Security keys for signing credentials

Security keys

Project expenses and support (section Donations).

Operating expenses of the running month, US dollars. When a month is over, the value of that moment is fixed as its expenses for good. 0 switches the section off: the endpoints return 204 and nothing is fixed.

The payment methods of the support sheet, in the order shown (those meant for the caller's country first).

The value fits DonationMonths.Expenses, decimal(10, 2): a closed month keeps it exactly.

Every method has a unique id; an external one has an address, a transfer a phone, an address or a card. An address is absolute https, a phone E.164, a card 13–19 digits passing Luhn, a holder Latin letters, a country a known upper-case ISO alpha-2 code; a method lists either its countries or its excepted ones.

Pattern:
^\\+[1-9][0-9]{7,14}\\z
Explanation:


            ○ Match if at the beginning of the string.

            ○ Match '+'.

            ○ Match a character in the set [1-9].

            ○ Match a character in the set [0-9] atomically at least 7 and at most 14 times.

            ○ Match if at the end of the string.

Pattern:
^[0-9]{13,19}\\z
Explanation:


            ○ Match if at the beginning of the string.

            ○ Match a character in the set [0-9] atomically at least 13 and at most 19 times.

            ○ Match if at the end of the string.

Pattern:
^[A-Za-z][A-Za-z .'-]*\\z
Explanation:


            ○ Match if at the beginning of the string.

            ○ Match an ASCII letter.

            ○ Match a character in the set [ '\-.A-Za-z] atomically any number of times.

            ○ Match if at the end of the string.

Pattern:
^[A-Z]{2}\\z
Explanation:


            ○ Match if at the beginning of the string.

            ○ Match a character in the set [A-Z] exactly 2 times.

            ○ Match if at the end of the string.

A payment method of the support sheet.

The client's key of the method: boosty, flitt, bog, gpay, erip-phone, erip-qr, card-belkart, card-belkart-by, card-mastercard, card-visa.

How the method is paid.

The page an method opens, or the payment link (shown as a QR code) of a . A fixed address: nothing about the player is ever added to it (payments are anonymous).

The recipient's phone of a , E.164 (+375291234567).

The recipient's bank of a , as the payer finds it in their bank app.

The recipient's card number of a , digits only.

The cardholder's name in Latin letters as on the card: a cross-border card transfer is declined without it.

ISO 3166-1 alpha-2 codes, upper case: the method is offered only to callers in these countries, ahead of the methods for everyone. Empty — offered to everyone. Never sent to the client.

ISO 3166-1 alpha-2 codes, upper case: a method for everyone withheld from callers in these countries (still offered when the caller's country is unknown). Not combined with . Never sent to the client.

How a payment method is paid.

An external site that chooses the amount and the frequency itself (Boosty).

Card acquiring; the amount and the frequency are chosen in the sheet.

A wallet (Google Pay); the amount and the frequency are chosen in the sheet.

A transfer the payer makes in their own bank app (ЕРИП in Belarus, a card-to-card transfer): the sheet shows the recipient's phone and bank, a QR code of the payment link or a card and its holder; the amount is entered in the app.

Idempotency-Key support of the API writes (section Idempotency).

Master switch. When false, the key is ignored and Idempotency-Supported is not sent, so clients stop retrying writes.

How long a key is remembered. Clients rely on at least a day.

How long a running request holds its key. A duplicate gets 409 in-progress meanwhile; afterwards the attempt is presumed dead (process killed mid-request) and a retry runs the request again.

Largest response body that is remembered. A larger response is not stored, so its retry runs again.

How often expired keys are deleted.

Options for the "Login with TTAR" OpenID Connect provider (OpenIddict server). Kept separate from , whose HS256 secret drives the internal mobile/SPA JWT — a different mechanism.

Absolute issuer URL of this IdP (the API origin, e.g. https://api.ttar.app). Also used to build absolute URLs (avatar picture claim) and must match what partners configure. Required.

Base URL of the web client's dedicated OIDC-handoff login page (e.g. https://ttar.app/oidc/login). When set, an unauthenticated /connect/authorize redirects here (carrying returnUrl) instead of the built-in Razor login page. When empty (local dev / tests), the Razor login page is used.

The client_id the web client sends to /connect/logout. A first-party, end-session-only client: it has no redirect URIs and no grants, so it can end the IdP session but never obtain tokens.

Web pages the browser may return to after the web client's own logout ends the IdP session (e.g. https://ttar.app/login). Registered as the post-logout redirect URIs of , matched exactly. When empty, that client is not registered (and removed if it exists), so the web cannot end the session.

Access-token lifetime in minutes.

Refresh-token lifetime in days (issued to partners that request offline_access).

Filesystem path where Data Protection keys are persisted (must survive restarts so the interactive authorize/consent flow's cookie stays valid). Required in non-Development environments.

Path to the X.509 PFX used to sign tokens (production). When null, a development signing certificate is used.

Password for .

Path to the X.509 PFX used to encrypt tokens (production). When null, a development encryption certificate is used.

Password for .

Trusted partner clients seeded on startup. Self-service registration is out of scope; these are entered by hand.

A single trusted OAuth2/OIDC client (partner site) seeded from configuration.

The client identifier the partner uses in the authorize/token requests. Required.

Client secret for a confidential client. Leave empty for a public (PKCE-only) client.

Human-readable name shown on the consent screen.

Allowed redirect URIs (exact match). At least one is required for the authorization-code flow.

Allowed post-logout redirect URIs.

Centralized rate-limiting configuration. Values are intentionally tunable from configuration (appsettings) so limits can be adjusted from production logs without a code change.

Master switch. When false, no rate limiting is applied at all (useful for local development / load testing).

Global per-client token-bucket policy applied to all "normal" (DB-cheap) endpoints. Partitioned by authenticated player id when available, otherwise by client IP.

Stricter per-client policy applied to DB-heavy endpoints (search, top) via the heavy-db named policy.

Very lenient per-client policy for the avatar image endpoint, applied via the avatars named policy. This endpoint just streams a cached PNG (a static-file emulator), so it must not share the normal budget — a profile page can fan out to many avatar requests at once.

Per-client policy for the map-link import (places named policy). Each request makes outbound calls to map services from the server's IP, so it is budgeted on its own and kept out of the DB concurrency ceiling.

Per-client policy for the announce-topic check (announce-topic named policy). Every miss of its result cache posts (and deletes) a real message in the chat, so the budget is a few taps a minute.

Per-client policy for the menu badge counts (badges named policy). The client re-reads them on resume, on related pushes (debounced) and after its own actions, and polls every few minutes; a guest gets 401 anyway.

Per-client policy for the new-language request (language-requests named policy). Every call messages the admin and the endpoint is open to anonymous callers, so the budget is a few requests an hour.

Per-client policy for the photo upload (photo-uploads named policy). Each upload decodes and re-encodes an image of up to tens of megapixels, so a client gets a few uploads per ten minutes.

Global concurrency ceiling for DB-heavy endpoints. Protects the MySQL connection pool from being exhausted even by a distributed flood across many IPs: only this many heavy requests run against the DB at once, the rest queue (and then get rejected).

Telegram-report throttling for rate-limit rejections. A report is sent to the super-admin when a client first gets throttled, then suppressed per client for a cooldown — and never more than a global ceiling per window — so a flood can't turn the alerting into its own flood against the bot.

Optional list of trusted reverse-proxy IP addresses (e.g. the Apache front-end) whose X-Forwarded-For header is honored when resolving the real client IP. Loopback is always trusted. If the proxy is not on loopback this MUST be set, otherwise every request shares the proxy IP and per-IP limits collapse into a single global bucket.

Token-bucket settings expressed per fixed window. The bucket is refilled with / tokens every seconds. The bucket capacity (the largest momentary spike a client may make) is the per-window amount, raised to when that is larger.

Length of the refill window, in seconds.

Tokens granted per window to anonymous (unauthenticated) clients.

Tokens granted per window to authenticated clients (more lenient).

Bucket capacity (burst). Defaults to the anonymous per-window amount when 0, so that short spikes are absorbed but sustained flooding is throttled to the refill rate. It only ever raises the capacity: a value below the caller's per-window amount has no effect, since the bucket never holds less than one refill.

Number of requests allowed to wait in queue once the bucket is empty.

Throttling for the Telegram alert sent to the super-admin when a client is rate-limited.

Master switch for sending rate-limit rejection alerts to Telegram.

Per-client cooldown, in seconds. After a client (player id or IP) triggers an alert, further rejections from the same client are silent for this long.

Absolute ceiling of alerts sent within across all clients, so a distributed flood can't spawn one alert per attacker.

Length of the window over which is counted, in seconds.

Concurrency-limiter settings: how many requests may execute simultaneously and how many may wait in queue before being rejected with 429.

Maximum number of concurrently executing requests.

Maximum number of requests allowed to wait in queue.

Authentication methods

Authenticates a user by email and password.

Authentication request containing email and password. Cancellation token. Returns with claims and tokens if authentication is successful. Returns with status 400 if the request is invalid. Returns with status 403 if credentials are invalid or the account has been deleted. If the account has been removed, the response will have status code 403 and a message indicating the account is deleted.

Registers a new account with email and password and sends a confirmation link. The account cannot be used to sign in until the email is confirmed.

Registration request with email, password and optional name. Cancellation token. 200 if the account was created and a confirmation email was sent (for an existing password-less account — a set-password link instead). with status 409 if an account with this email is already registered. with status 403 if the account has been removed.

Confirms an account email using a token from the confirmation email and signs the user in.

Request containing the confirmation token. Cancellation token. 200 with on success. with status 400 if the token is invalid, expired or already used.

Re-sends the email-confirmation link for an unverified account.

Request containing the account email. Cancellation token. Always (204) for any well-formed request, so account existence is never revealed.

Changes the password of the authenticated user. Requires the current password unless the account has no password yet (e.g. SSO-only). On success, all existing sessions and refresh tokens are revoked (every device is logged out) and a fresh set of tokens is returned for the current device, so the caller stays signed in.

Request with the current and new password. Cancellation token. 200 with a fresh (new JWT, refresh token, and session token when rememberMe is set) on success. with status 400 if the current password is wrong or the new password is too short.

Starts changing the authenticated user's email. A confirmation link is sent to the new address; the login email is switched only after that link is followed. Requires the current password; an account with no password yet (SSO/Telegram) must set one first.

Request with the new email and current password. Cancellation token. 200 if a confirmation email was sent to the new address. with status 400 if the current password is wrong. with status 409 () if the new email is already used by another account. with status 409 () if the account has no password yet and must set one before changing its email.

Completes the change-email flow using a token from the confirmation email sent to the new address.

Request containing the confirmation token. Cancellation token. 200 on success. with status 400 if the token is invalid, expired, already used, or the address became taken.

Re-sends the email-change confirmation link to the pending address of the authenticated user. Returns 204 regardless of whether a change was pending, so the response never reveals internal state.

Optional language preference for the confirmation email. Cancellation token. Always (204) for any well-formed request.

Cancels a pending email change: clears the stored pending address and invalidates any outstanding confirmation tokens. Returns 204 even when no change was pending.

Cancellation token. (204).

Starts the password reset flow: sends an email with a reset link if the account exists.

Request containing the account email. Cancellation token. Always (204) for any well-formed request, so account existence is never revealed.

Completes the password reset flow using a token from the reset email.

Request containing the reset token and the new password. Cancellation token. 200 if the password was reset. with status 400 if the token is invalid, expired, already used, or the password is too short.

Authenticates a user with a refresh token.

Refresh token. Session token value. Latest mobile application version. Cancellation token. Returns with claims and tokens if refresh is successful. Returns with status 401 if the token is invalid. Returns with status 403 if the account has been deleted. If the account has been removed, the response will have status code 403 and a message indicating the account is deleted.

Revokes Refresh Token, and optionally the long-lived session token issued alongside it.

Refresh token Optional session token to revoke together with the refresh token (logout on the current device). Cancellation token Revocation result Succeeds when at least one of the supplied tokens is revoked. Returns 404 only when neither the refresh token nor the session token could be revoked (already inactive or not found).

Re-issues JWT and refresh tokens using a long-lived session token (remember me). Rotates the session token on success.

Session token. Optional device description (mobile app). The web omits it: it is identified by the User-Agent header. Latest mobile application version. Cancellation token. Returns with claims and tokens if the session is valid. Returns with status 401 if the session token is invalid or expired. Returns with status 403 if the account has been deleted.

Requests removal of a user account

The reason for account removal Cancellation token Status of the account removal request

Authenticates though Google

Custom redirect URI (optional) When true, a long-lived session token is issued alongside the refresh token (default true) The TTAR app starting the sign-in ( name) — the full-page navigation cannot send the X-Client-App header Version of that app — in place of the X-Client-Version header Device description (mobile app only) Redirects to callback

Handles the response after Google authentication

Optional custom redirect URI to return to after authentication If true, returns the authentication response as JSON instead of redirecting When true, a long-lived session token is issued and included in the response (default true) If is true, returns with the authentication response. Otherwise, redirects to the specified or default URI with authentication information. Returns if no email is detected. Returns with status 400 if is not allowlisted.

Starts a Telegram sign-in (Telegram Login in OpenID Connect mode).

Client callback URI (optional, must be allowlisted); defaults to the mobile app callback When true, a long-lived session token is issued alongside the refresh token (default true) returns TTAR tokens; returns a custom Telegram token for PUT /Players/merge The TTAR app starting the sign-in ( name) — the full-page navigation cannot send the X-Client-App header Version of that app — in place of the X-Client-Version header Device description (mobile app only) Redirects to Telegram, which returns to

Completes a Telegram sign-in started at and redirects back to the client.

Client callback URI (optional, must be allowlisted); defaults to the mobile app callback When true, a long-lived session token is issued and included in the response (default true) Sign-in purpose, see Cancellation token Redirect to with PlayerId/Token/RefreshToken/SessionToken (login) or TelegramToken (link) in the fragment, or with ErrorCode on failure. Returns with status 400 if is not allowlisted.

Downloads and stores the player's avatar. Runs as a fire-and-forget background task from and , so it owns its own DI scope (the request scope is gone by then) and observes its own exceptions instead of surfacing them as unobserved task exceptions.

Authenticates a user by custom Telegram token

Custom Telegram token When true, a long-lived session token is issued and included in the response (default true) Optional device description (mobile app). Cancellation token Legacy "sign in via the bot" flow, kept only for app versions released before Telegram OIDC. Use GET /Account/TelegramOidc to sign in and GET /Players/merge to preview a link token.

Mints a one-time exchange code for the web-delegated "Login with TTAR" OIDC handoff. The caller must be an authenticated player (Bearer JWT); the code is bound to that player and redeemed once at /connect/login-callback to establish the IdP session. This lets the web client (ttar.app) own the login UI while the API (the OIDC provider) owns the session.

Cancellation token. 200 with the one-time .

SSO authentications for the mobile application

e.g.: Microsoft, Facebook, Apple, etc Cancellation token Redirect back to the mobile application with auth information

Updates version information for current user

Version of the mobile application Cancellation token

Updates geographical information for current user

Geographical point containing longitude and latitude Cancellation token

Admin page "Поддержка проекта": support payments entered by hand (each adds to the month's sum, a mistake is deleted) and the anonymous counters of the "Expenses and support" page. Admin only. Sums are US dollars with cents; only the running month (UTC) takes new payments and deletions.

Visits and taps of the support page per day or per month (UTC), within [from, to]. Days without events are left out — the client fills them with zeros.

First day, YYYY-MM-DD. Last day, YYYY-MM-DD. day (default) or month (dated by the month's first day). Cancellation token.

The payments of a month, newest first, with its support and expenses.

Adds one payment to the running month: net of the payment service's fee, another currency converted at the rate of the day. A retry with the same Idempotency-Key adds nothing.

Deletes a payment of the running month (kept in the database for the audit, counted nowhere).

Admin registration statistics (page "Статистика регистраций"). All data is precomputed by a nightly job; these endpoints only read snapshots. Access is gated by the policy — a caller with the StatsViewer role (or Admin) passes; anyone else gets a framework 403 before the action runs. A not-yet-computed snapshot returns 204 so the client can show the "статистика появится после ночного пересчёта" empty state (distinct from a 403 no-access).

Registration funnel over a range (nested series registered ⊇ played ⊇ qualified), with on-date and cohort points and the play-mix split. See REGSTATS.md §4.

3m | 12m | all (default 12m).

Per-country registration counts and growth over a range, plus the "other" tail and the "country not determined" row. See REGSTATS.md §4.

3m | 12m | all (default 12m).

Forces an immediate recalculation of all snapshots (admin only), bypassing the nightly timer's once-per-day guard. Returns the new "as of" stamp. Heavy — intended for manual use after data fixes.

OpenID Connect provider endpoints for "Login with TTAR" (authorize / token / userinfo / logout). Not an [ApiController]: these use redirects and form-posts driven by OpenIddict passthrough, not JSON model binding.

Authorization endpoint: authenticates the resource owner via the IdP cookie (challenging the login page when absent, or when prompt=login / prompt=select_account / max_age demand a fresh sign-in), then issues an authorization code for the granted scopes.

Web-delegated login handoff: the web client, after signing the user in, redirects here with a one-time exchange code. Redeems the code (single-use), establishes the IdP cookie, and returns to the original authorize URL so the OAuth code can be issued.

The one-time login-exchange code minted at /Account/login-exchange. The original relative /connect/authorize URL to resume. The anti-CSRF state echoed back by the web login; must match the cookie set at authorize. Cancellation token. Redirect to on success; back to the web login on an invalid code; 400 on a bad returnUrl/state.

Token endpoint: exchanges an authorization code or a refresh token for fresh tokens. On refresh, the player's claims are re-read from the database so rating/profile changes propagate.

UserInfo endpoint: returns the player profile claims allowed by the access token's scopes.

End-session (logout) endpoint: clears the IdP cookie and completes the OpenIddict sign-out.

Personal blocks. A blocked player's geo chat messages, mentions and private messages do not reach the caller, the caller cannot write to them either, and neither side sees the other's contacts (PlayerResponse.isBlockedByMe / hasBlockedMe). Blocking is one-way and takes effect at once.

The players the caller blocked, newest first.

The list

Blocks a player. Idempotent.

Blocked No such player The caller themselves

Lifts a block. Idempotent.

Not blocked any more

Reports to the moderators. The report keeps a snapshot of what the reporter saw.

Files a report about a player: a geo chat message (the quote is attached) or a private conversation (the last 20 messages of the pair are attached). With alsoBlock the player is blocked in the same call.

Filed No such player or message The caller themselves, or no comment for the reason "Other"

Booking-scoped actions addressed by booking id (DATA_API §4): the player cancels their own booking; the venue confirms / declines / marks a booking played. Venue-scoped booking creation and listing live in .

The authenticated caller's active bookings across all venues (Requested + Confirmed, ending now or later), ordered by start. Each row carries its venue name for the cross-venue "my bookings" banner/screen (SCREENS §1).

Cancellation token.

Cancels a booking (the whole group). Cancelling before the start releases the hold; after the start it captures per the venue's late-cancel policy. The booking player may cancel their own; the venue any.

Booking id. Cancellation token.

Confirms a pending booking (venue manager).

Booking id. Cancellation token.

Declines a booking (venue manager): releases the hold and cancels it.

Booking id. Cancellation token.

Marks a booking played (venue manager): captures the held funds.

Booking id. Cancellation token.

Home-page dashboard data for the authenticated player. Kept as a dedicated controller (rather than a member of ) so the dashboard can grow independent, separately-loadable modules later without bloating the player CRUD surface.

Returns the aggregated home-dashboard data for the authenticated player.

Everything the dashboard widgets need is collected server-side in a single request: rating and rank progress, per-period deltas/sparkline, all-time W/L/D and streaks, head-to-head, recent games, yearly activity heatmap and the nearest upcoming tournament. Achievements are not yet sourced and come back empty. The player's id. Must be the caller unless the caller is an admin. The hand to build the dashboard for (Main by default). True — the client supports ladders. Omitted, the nearest tournament is the nearest non-ladder one: apps released before ladders cannot read a ladder. Cancellation token. The dashboard data.

Project expenses and the players' support covering them (the "Expenses and support" page and its menu banner). Sums are US dollars; the client computes the coverage. Open to guests. While the section is switched off in the configuration every endpoint returns 204, and the client shows no banner.

Expenses and support of the running month — the menu banner.

The coverage of the running month, the running year and the whole history, with the start of the history and today's date.

The months of a year within the history (before its start and after the running month there are none).

The year; the running one by default. Cancellation token.

Every year of the history.

The payment methods of the "Support TTAR" sheet offered in the caller's country, those meant for it first, and that country. It comes from the signed-in player's declared country of residence, else their stored location, else the request's IP address — a guest's only source. The address is not kept.

Counts an opening of the page (View) or a tap on "Support the project" (Click) in today's counters (UTC). Anonymous: only the day's numbers are kept, never who sent the event. Always 204.

Email preferences through the link every notification email carries, without signing in: the RFC 8058 one-click unsubscribe a mail client calls itself, and what the preferences page reads and changes. The signed-in player has me/email-preferences.

Turns the topic off — the RFC 8058 one-click unsubscribe a mail client calls from the email's List-Unsubscribe header, with the fixed body List-Unsubscribe=One-Click (any body is ignored).

The token of the email's links. The email's topic. Cancellation token The topic is off; the new preferences, with the address masked The link is not valid anymore (InvalidEmailPreferencesToken), or the topic is missing, unknown or can't be turned off

The unsubscribe link opened as a page (a mail client without RFC 8058, a link preview): redirects to the preferences page offering to turn the topic off, in the player's language, and changes nothing itself.

The token of the email's links. The email's topic. Cancellation token To the preferences page

The preferences of the player the emailed link is for, with the address masked.

The token of the email's links. Cancellation token The preferences The link is not valid anymore (InvalidEmailPreferencesToken): the player has to sign in

Turns topics on or off through the emailed link: only the listed ones change, the rest keep their state.

The link's token and the topics to change Cancellation token The new preferences, with the address masked The link is not valid anymore (InvalidEmailPreferencesToken), or a topic is unknown or can't be turned off

Search within database

Returns list of all confirmed games for specified user

Player's Id Player's hand type A page to be returned Amount of items per page. Default value is Optional opponent id. When provided, only joint games between the player's hand and all hands of the opponent are returned (same as the filtered history in the Telegram bot). When omitted, the full history of the hand is returned. Cancellation token List of games; External rating importing information, if exists

Registers new unconfirmed game(s)

Game parameters Cancellation token

Forecasts the caller's rating change after a game against the opponent, as if the game were confirmed now. Read-only: nothing is persisted and a missing hand is not created (it is forecast from its starting values).

The opponent player id. The caller's rating axis. The opponent's rating axis (may differ from ). Optional sets won by the caller; with fills . Optional sets won by the opponent. Cancellation token The caller's rating deltas for the reference win/loss and, optionally, for the exact score.

Returns list of unconfirmed games corresponding to specified

Player id to filter, the logged user by default. Only admins can get someone else's unconfirmed games Cancellation token The list of unconfirmed games

Accepts a confirmation from one of the player. Updates ConfirmationDate if both players confirmed the game

A game id to confirm A player id (not TelegramId) who confirming the game. Only admins can confirm someone else's game Cancellation token Returns updated game record, or null if not found

Discards unconfirmed game

A game id to discard Cancellation token Returns updated game record, or null if not found

The players-nearby chat ("Geo chat" tab of Messages). The feed is served from memory and filtered per reader: own messages always, a blocked author's never, anyone else's when it mentions the reader or was sent within the reader's radius. Positions are kept as ~500 m cells and never returned.

A page of the caller's feed, oldest first. Pass the first shown message's id as before to load the previous page while hasMore is true. Live updates come through the chat hub (GeoChatMessage).

The page

Sends a message from the caller's position. Mentions (@[playerId] tokens) reach the mentioned players whatever their radius, except across a block. Limits: one message per 15 s, 20 per hour, no repeat of the previous text, links only with games on the record.

The message as the sender sees it No position, the chat is off, links are not allowed yet, or a moderator restricted the caller's chat (GeoChatBanned) Empty or too long text, or too many mentions Sent too often, or the same text again

The caller's radius and the marks of the tab (unread mention, new messages).

The settings

Sets the caller's radius (0 turns the chat off; mentions still arrive; -1 = "all", chat moderators only).

The settings The "all" radius (-1) without the chat moderator role (ChatModerationRequired) The radius is not one of the allowed values

The tab was opened (or new messages arrived while it is open): moves the read marker to upToId (the newest visible message when omitted) and gives the others' messages their first "seen" tick.

The settings after the read

The guest teaser: how many messages and authors the last day had within 10 km of the point (global counts without a point). No content is returned to anyone here.

The counts

Serves player avatars and manages the photo a player uploads.

Returns avatar image: the preview of the player's photo (JPEG) or the provider avatar (PNG)

Avatar id Requested image

Returns the full-size avatar image: the player's photo (JPEG, longer side up to 640 px), or the provider avatar (PNG), which has a single size

Avatar id Requested image

Uploads the player's photo. It replaces the avatar from Telegram/Google, which is no longer synced while the photo exists. Stored as a JPEG without metadata, aspect ratio kept.

Uploaded image: JPEG, PNG or WebP, up to 10 MB Target player id, logged used by default. Only admins can set someone else's avatars. The avatar centre in fractions (0…1) of the photo width, clamped; centre by default The avatar centre in fractions (0…1) of the photo height, clamped; centre by default Cancellation token Generated file id. Its preview is the square around the focus, up to 256 px.

Moves the avatar centre of the player's photo: the preview is re-cut from the stored photo, nothing is uploaded.

The new avatar centre Target player id, logged used by default. Only admins can change someone else's photo. Cancellation token The new avatar id (avatars are cached as immutable); its /full is the same photo

Removes the player's photo. The avatar from Telegram is fetched again right away; the one from Google comes with the next Google sign-in. Succeeds when there is no photo (or no such player) too.

Target player id, logged used by default. Only admins can remove someone else's photo. Cancellation token

Fetches the Telegram avatar of a player who has just removed their photo. Removing the photo reset the last avatar check, so the update interval does not hold it back.

Internal-only endpoints called by the bot/timer worker (which has no SignalR hub) to reach the API's real hub-backed broadcaster. Guarded by loopback + a shared secret, NOT by user auth — the caller is a co-hosted process, not a signed-in user. Never expose this route through the reverse proxy.

Broadcast a live-refresh signal to the tournament's SignalR group. Called by the worker after a timer/bot-originated change (auto-confirm, auto-call, Telegram confirm) so open web pages refresh at once instead of waiting out the silent-poll fallback.

Interface languages.

Asks for a new interface language: the request goes to the administrator by Telegram and email. Open to anonymous callers (the language menu is on the login screen too); an authenticated caller is named in it.

The requested language and optional details. Cancellation token.

The caller's own state that is not part of the profile

The caller's email switches by topic, with their address in full (null without one: the switches are kept for when they add it).

Cancellation token The preferences Not authenticated The caller's profile is gone

Turns the caller's email topics on or off: only the listed ones change, the rest keep their state.

The topics to change Cancellation token The new preferences A topic is unknown or can't be turned off Not authenticated The caller's profile is gone

Emails the caller a link confirming their current address — notification emails go only to a confirmed one. The link is the email-change one (confirm-email-change?token=, to the same address): it signs nobody in. Sends nothing without an address, for a confirmed one, while a change of it is pending, or within the cooldown.

Cancellation token Done (whether or not an email went out) Not authenticated

Returns the menu badge counts: how many items in each menu section wait for the caller's answer, and whether the geo chat has something new (messagesNew, the "Geo chat" tab's dot). Not cached — the counts change right after the caller's own actions; the client polls it and re-reads it on the related pushes.

Cancellation token The counts Not authenticated (a guest has no badges) Polled too often

Private messages. Live updates come through the chat hub (/hubs/chat): PrivateMessage to the recipient, PrivateRead to the author.

The thread page size when take is omitted.

The largest thread page a client may ask for.

Retrieves conversations list of private messages grouped by senders. A blocked player's conversation stays listed (sender.isBlockedByMe); the client shows "you blocked this player" instead of the preview.

List of top messages from each conversation

Retrieves a page of the private messages with a player, oldest first. Pass the first shown message's id as before to load the previous page. pageInfo.totalItems is the whole thread's size on the first page only (no before); a scroll-back page leaves it 0 rather than recount the thread.

Sender id (from) Only messages older than this id; omitted = the newest page Page size, at most 200; omitted = 50 Cancellation token The page If the player with the specified ID is not found List of messages

Sends private message

Recipient id (to) Request model containing geoPoint and content Cancellation token Message sent successfully A block stands between the two players (PlayerBlocked: by the caller; BlockedByPlayer: by the recipient) If the player with the specified ID is not found Invalid message content

Marks the unread messages from to the caller as read, up to . The client calls it when the conversation is opened. Idempotent: a repeated call (or an unknown sender) changes nothing.

Sender id (from) The newest message id the client has shown; a message that arrived later stays unread. Omitted: all of them. Cancellation token The conversation is read

Chat moderation (ChatModerator or Admin): the queue of reported players, the decisions and their journal, the bans in force, the moderator's own settings. A decision from the geo chat's author menu lands here too.

The open reports grouped by player: threats first, then more reporters, then newer.

The queue

Decides on a player: every open report on them is closed; a ban is set (BanChat for the term, or until lifted; BanAll ends their sessions) and the messages asked for are deleted. "No violation" gives an auto-hidden message back; a ban hides the player's chat messages from everyone while it lasts.

The journal row No such player, or the message is not theirs Decided already by another moderator, or an equal or wider ban in force (the body says which) A ban without a reason, "Other" without a comment, a term outside a chat ban, a purge that does not fit

Undoes a decision: its ban is lifted, its deleted messages return, its reports are open again.

Reverted No such decision Reverted already, or a lifted ban (nothing to undo)

The journal, newest first; pass the last row's id as before for the next page.

The page

The bans in force, newest first.

The bans

Lifts the player's ban of that scope by hand; the reports it closed stay closed.

Lifted No active ban of that scope

The caller's moderation settings.

The settings

Sets the caller's moderation settings.

The settings

Places on public maps as a source of venue fields: the "the club is already on the map" step of creating a venue.

Reads a map link (Google Maps, Yandex Maps, 2GIS, OpenStreetMap, Apple Maps; short links and "share" text included) and suggests venue fields from the place's card. The response is a hint for the form and is not stored. Rating and reviews are never suggested.

The link and, optionally, the card HTML the client loaded itself. Cancellation token.

Players profiles and settings

Returns a player record with ratings

Player's Id When provided, the amount of games played between and this player is calculated and exposed via . When omitted, no joint games are computed (the field stays null). Cancellation token The player record with games

Counts joint games between and the player identified by .

The player (with hands loaded) the games are counted for. The other player id, or null to skip the calculation. Cancellation token The joint games breakdown, or null when no other player is requested or it is the player itself.

Returns the tournaments a player took part in, newest first (by held date).

Public (player card is anonymous). Includes both native tournaments the player is a participant of and external (imported) tournaments they played in; each entry counts toward one rating axis. An unknown player simply yields an empty list — the card itself 404s via . Player's Id Cancellation token The player's tournament participations, newest first.

Returns player profile

Target player id, logged used by default. Only admins can get someone else's profile. Cancellation token The player profile

Returns player associated chats

Player's Id Cancellation token Collection of chats with the player's activity

Returns the accessible Telegram chats both the caller and the opponent are active in — the chats a game with the opponent can be registered in. Unlike , the rest of the opponent's chats stay hidden.

The opponent player id. Cancellation token The common accessible chats; empty when there are none.

Returns the caller's latest distinct opponents, newest first — from the caller's games, both confirmed and still pending (discarded ones are skipped). Each row carries the same and as the player search.

Maximum amount of opponents (1–20). Cancellation token The recent opponents, the most recent first.

Returns the profile of the player behind a custom Telegram token, so the client can preview a merge (see ) without the token being redeemed as a login.

Custom Telegram token issued by the Telegram sign-in in link mode Cancellation token The profile of the player to be merged into the current one

Merges player profiles

Custom Telegram token, identifies a profile to merge Cancellation token The player record with games If player id was changed, need to do refresh token action

Changes a user profile

User id To change profile fields, set the field value to null if you wish to leave it unchanged Cancellation token false if user not found (todo: or is admin)

Changes a user profile

User id Top-level fields: null leaves the field unchanged. The personal block is the exception: when present it is replaced AS A WHOLE (an omitted or null field inside clears the stored value, an omitted flag is false, otherRatings replaces the whole list); null leaves the block unchanged. Cancellation token Updated player's profile A field is invalid (ValidationFailed, the message names the field). The main hand or the gender is already set to another value (MainHandAlreadySet / GenderAlreadySet).

Adds FCM token to the user

User id FCM token The client platform the token was registered from. Web tokens receive data-only pushes (no browser auto-banner); Android/iOS keep the native notification block. Omitted/Unknown preserves the legacy visible-banner behaviour. Cancellation token

Removes the specified Firebase Cloud Messaging (FCM) token for the given player

Only administrators can remove FCM tokens for other players. Non-admin users can only remove their own tokens. The unique identifier of the player whose FCM token is to be removed The FCM token to be removed. This value cannot be null or empty A token to monitor for cancellation requests

Returns the rating history for a player

The unique identifier of the player The type of hand for which to retrieve the rating history Cancellation token A response containing the player's rating history

Manages push notifications on mobile clients.

Test method to send push notification to Emulator

Notification title Notification text Type of push message, can be parsed by mobile app Target device FCM token. If not provided, a default emulator token is used Returns the message ID string if the push notification was sent successfully, otherwise null

RTTF profile operations: preview a profile, link/unlink it to a player, and run the ownership confirmation. Linking may be done by the player themselves, an admin, or an organizer/co-organizer of a tournament the player takes part in; the link is created unconfirmed until the player proves ownership by posting the code on rttf.ru.

Loads a preview of an RTTF profile by id (used by the organizer dialog before linking).

RTTF profile id. Cancellation token. The scraped profile preview, or an error if it cannot be loaded.

Links an RTTF profile to a player as unconfirmed. Allowed for the player themselves, an admin, or an organizer/co-organizer of a tournament the player takes part in — for the organizer path the participant must have confirmed their participation (unless ).

The player to link the profile to. The RTTF profile id to link. Cancellation token. The updated player profile.

Fans out the "an organizer linked your RTTF profile" notice across all channels without blocking or failing the request. Detached task on — the request token is cancelled once the response returns and would abort in-flight sends. Each channel self-gates.

Unlinks the RTTF profile from a player. A confirmed link can only be removed by the player themselves; an unconfirmed link can be removed by the player or by whoever created it.

The player to unlink. Cancellation token. The updated player profile.

Runs the ownership confirmation check for the caller's own RTTF link (reads the code posted on rttf.ru).

The player confirming their own link. Cancellation token. The updated player profile (check ).

Checks whether the requester may link an RTTF profile on the target player's behalf: self, admin, or an organizer/co-organizer of a tournament the player takes part in. For the organizer path the participant must have confirmed their participation, unless waives the confirmation gate (as it does for starting a tournament).

null if linking is allowed; otherwise the 403 error naming the reason.

Reloads the player profile after a mutation. The owner and admins get the full profile (the confirmation code only for the owner); anyone else allowed to link/unlink (an organizer, the link's creator) gets only the RTTF view, never the player's contacts or private profile fields.

Maps an RTTF load failure to an appropriate error response.

rttf.ru limits our requests: 503 with Retry-After (seconds) left in its window.

Search within database

Search a player though name, login, etc.

Search parameters including pattern, page, and optional location Cancellation token Search results, 50 results by default

Searches for Telegram chats based on the specified request parameters.

The search parameters including page, page size, and optional location. A token to monitor for cancellation requests. A paged response containing the list of Telegram chats.

The web app's sitemap: its public tournaments and venues

Returns the public tournaments and venues worth indexing. Built for everyone at once, so a new page shows up in it up to an hour late.

The pages

Provides endpoints for system-related operations, including retrieving the current system status

Retrieves the current system status

A object

Logs an exception and sends the details to the SuperAdmin via Telegram

The exception log request containing details about the exception A task representing the asynchronous operation

Retrieves the mapping between and their corresponding rating values

The bot settings containing the rank-rating mapping A dictionary mapping each to its rating value

Test controller

Test useless controller to verify DB connection

Just a bot name

Returns the request's URL

URL

Always 401

Top players

Returns top of players

A page to be returned Display position of specified player in returned results Amount of items per page. Default value is Cancellation token Top of players with position of specified player

Returns top of players

Search data Cancellation token Top of players with position of specified player

Retrieves the active top players for a specified chat and interval

The interval over which to calculate the top players The unique identifier of the chat for which to retrieve the active top players The current page number of the results to retrieve. Defaults to 1. An optional player ID to include specific player position of specified player in returned results The number of players to include per page. If null, a default page size is used. A token to monitor for cancellation requests. A containing the list of active top players for the specified chat and interval

Guest link: merging a tournament guest (a profile-less participant) into a TTAR profile. Only the organizer merges (co-organizers do not), on their own pick or a player's "this guest is me" request, until the finish and 7 more days. Irreversible. The requests and the window come with GET /tournaments/{id} (guestLinkRequests, guestLinkWindow), the trace with each participant (linkedFrom). See Docs/Tournaments/guest-link.md.

What merging the guest into a player would do — the "Что произойдёт" card of both sheets. Without — for the caller (the player's "Это вы?" sheet); another player's preview is the organizer's (or an admin's) only.

Players the organizer may merge the guest into (organizer / admin only). An empty gives the players with a name like the guest's, then the latest registered; a query searches the names in both scripts (Cyrillic finds Latin and back), the look-alikes first and the tournament's participants last (inTournament, not pickable). Neither the organizer nor guests are listed.

The caller's "this guest is me" request; the organizer is notified. One Pending request per player in a tournament; a rejected one cannot be repeated for the same guest. 400 — the window is closed, the caller takes part under their own profile, already has a request, or was rejected.

The author withdraws their Pending request.

The organizer (or an admin) rejects a Pending request; the player is notified and may not repeat it.

The organizer (or an admin) merges the guest into a player — irreversible. Before the guest's games are rated the player takes its seat (Replace); after, a player without games takes the guest's games and rating (Transfer), any other gets the games without a recalculation (Append). With requestId it approves that request; the player's other requests and the guest's other ones close. The player is notified. Returns the participant row, now the player's (linkedFrom set). 409 — the window is closed, the player takes part, the guest was already merged, or the request was decided.

Ladder tournaments: the players record their games — the score of a match, or of several at once — and confirm each other's; at the finish what was confirmed goes to the rating, and what still waits becomes ordinary games waiting for confirmation. Every endpoint answers 400 TournamentTypeMismatch for an ordinary tournament. See Docs/Tournaments/ladder.md.

Sign the caller up for a ladder — in Registration or while it runs (joining a running ladder from the bottom table). An ordinary or a running ladder seats the caller like POST /register. An even-only ladder before its start decides atomically: the caller either gets into the roster together with the player who waited for a pair (pairedWithPlayerId), completes an odd roster, or waits in the waitlist for a pair (WaitingPair; a repeated call updates the hand and phone and keeps the place). 400 TournamentFull — no seat is left: offer POST /waitlist (Registration only). The other errors are those of POST /register.

Start a ladder now (organizer / co-organizer / admin; Draft or Registration) instead of waiting for its start time, when it starts by itself. Like an ordinary start, needs minParticipants and every participant confirmed (400 UnconfirmedParticipants, waived on Staging). No schedule or tables.

Turn the ladder's auto-start on or off (organizer / co-organizer / admin; Draft or Registration, else 400 InvalidTournamentStatus). With it on, the ladder starts by itself at its start time — or, short of participants or confirmations then, as soon as the roster is complete (the managers are told once that it did not start). Starting earlier by hand still works. Either way, a ladder is closed 12 hours after its scheduled start: cancelled if not started, finished if running.

Finish a running ladder (organizer, admin, or a co-organizer with the finish right). Closes the records — no new games — and registers them all for rating by regMode. The confirmed ones are rated now: Total (default) — one game per pair with the sum of its confirmed games; Each — every confirmed game on its own. What still waits becomes ordinary games waiting for the opponent's confirmation (GET /games/unconfirmed, the bot's confirmation cards, the ladder's chat): Each — every Pending game on its own; Total — one game per author with the sum of their Pending games against that opponent. With autoConfirmDays (1 or 3) the waiting games count automatically that many days later; without it they expire like ordinary games. The body may be omitted — Total, no auto-confirm.

Change the auto-confirm period of a running or finished ladder (organizer / co-organizer / admin; before the start it is part of PUT /tournaments/{id}). The waiting games of a finished ladder whose new deadline has already passed count right away, in this call.

Change the game rules of a running ladder (organizer / co-organizer / admin): sets in a game (1–5), the balance at 10:10, the draw rule (an even number of sets only, stored false otherwise), the seating of the draw at the tables (the draw is not reshuffled). A null field stays as it is. The recorded games are not touched; the announcement is redrawn. Before the start the rules are part of PUT /tournaments/{id}; the roster rule, date, venue and admission do not change while the ladder runs.

Record a game of the caller (an active, confirmed participant) against another participant while the ladder runs: the score of one match or, entered as a free score, of several at once. By the rules every set is played (setsMine + setsOpponent = the ladder's setsInMatch, or a multiple of it), but a score off the rules is accepted too: the client warns and asks, the opponent confirms what was really played. 400 LadderScoreInvalid only for no sets at all or more than 99 a side. The opponent is asked to confirm it; it goes to the rating at the finish. Every record is decided on its own: no duplicate check (the client offers to confirm the opponent's Pending record against the caller instead), the opponent rejects a duplicate.

Record several games of the caller at once, atomically — the same rules as POST …/games for each. Any invalid item fails the whole call.

The opponent confirms a Pending game. While the ladder runs it goes to the rating at the finish; after the finish this confirms (and rates) the ordinary game it waits as — in a Total ladder the game of all the author's waiting records against the caller. 409 LadderGameNotPending — already decided: reload, show no error.

Confirm every Pending game waiting for the caller ("Подтвердить все"); after the finish — every game of the ladder waiting for the caller. Returns the games this call confirmed (possibly none).

The opponent rejects a Pending game (not played / a different score / a duplicate); its author is notified. A rejected game never counts. After the finish this discards the ordinary game it waits as (in a Total ladder all the author's waiting records against the caller go with it). Same errors as confirm.

The author withdraws their undecided record (Pending, or Expired) — also after the finish, when the ordinary game it waits as is discarded (in a Total ladder with all the author's waiting records against that opponent); it is deleted.

Native tournaments management

Whether may run the tournament — the organizer, any co-organizer, or an admin. This is the broadened "organizer" check every organizer endpoint authorizes against (finishing is stricter: it also needs the co-organizer's CanFinish flag, enforced in the service). Returns false for a null tournament. Requires the tournament to have been loaded via GetTournamentAsync, which always includes the co-organizer roster.

Whether may see this tournament's participant RTTF PII: a manager (organizer / co-organizer / admin) or a confirmed participant of the same tournament. Others (outside viewers, anonymous callerId 0, unconfirmed participants) may not. Requires the tournament to have been loaded with its participants. This only decides the caller's eligibility — each row still ANDs it with its own Confirmed flag inside .

Whether the requested status filter can yield an Active tournament: no status filter at all (mixed feed), or one that explicitly includes . Drives whether the list query pays to load matches (see ).

Returns a paginated list of tournaments. All filters are optional and combine with AND; and combine with each other as a union.

Single status filter. Status set filter (repeatable query param, e.g. statuses=Finished&statuses=Cancelled). Unioned with . Tournament format filter. Access-mode filter: Open or Invite. Omitted returns both ("any"). The spec's default-hide-others'-closed rule is part of the (out-of-scope) list-filters work. Linked Telegram chat id filter. When true and the caller is authenticated, returns only tournaments the caller organizes, co-organizes, actively participates in or waits in the waitlist of (including their own drafts). Ignored for anonymous callers. When true, hides tournaments without a free seat (active participants + waitlist ≥ limit: seats held for the queue are not free) — except those the caller organizes, co-organizes, participates in or waits in the waitlist of. Uncapped tournaments always pass. When true, hides registrations whose start date is already in the past. When true, hides Cancelled tournaments that never had any participant (HadParticipants=false). Keeps the Past feed pagination even. True — the client supports ladders. Omitted, ladders are hidden: apps released before ladders cannot read such a response. Optional longitude for distance calculation. Optional latitude for distance calculation. 1-based page number. Page size, clamped to 1..100. Cancellation token.

Returns full tournament details including participants and schedule

Tournament id Optional longitude for distance calculation Optional latitude for distance calculation Fold the live table board + call queue into TournamentResponse.Queue so an open page loads it in one request instead of a second GET /queue. Populated only for an Active tournament; ignored otherwise. Fold the current/final standings into TournamentResponse.Standings so an open page loads them in one request instead of a second GET /standings. Populated only for Active / Finished / cancelled-with-matches; ignored otherwise. True — the client supports ladders. Omitted, a ladder answers 404 TournamentNotFound: apps released before ladders cannot read such a response. Cancellation token

Returns list of matches for a tournament

Returns the live table board and waiting call queue for a tournament: which live match sits on each table, which pair to call onto a free table, and the ordered queue of waiting pairs. The order is the call priority — clients render it as-is and must not re-sort. Available to everyone (same as the tournament details): organizer and spectator get the same, non-personalized response.

Tournament id. Cancellation token.

Returns list of active participants for a tournament

Returns current or final tournament standings

Exports a finished tournament as a TournamentManager .rttf file (XML) with every played game. The organizer opens it in TM, checks the players' RTTF links there, and pushes the results to rttf.ru. Restricted to the organizer, a co-organizer, or an admin; only for a Finished tournament.

The tournament as an event of the caller's calendar: time span (duration from the schema calculator), place, localized description and the Google / Outlook "add event" links. Only for a tournament open for registration with a start date, and only for a player of its roster (not the waitlist) or its organizers.

Tournament ID. Language of the texts (the client's UI language, e.g. pt-BR); falls back to Accept-Language, then the player's language, then the default. Cancellation token.

The same event as as an iCalendar (.ics) file, with one reminder per value of .

Tournament ID. Reminder lead times in minutes, comma-separated (30,45): up to 3 values, 0–1440 each. Empty — no reminders. Language of the texts, as in . Cancellation token.

The caller's event of cancelled, as an iCalendar (.ics) file (same UID, METHOD:CANCEL, STATUS:CANCELLED): imported, it removes the added event or marks it cancelled. Only once the event no longer stands for the caller — the tournament is cancelled, or the caller is out of its roster (removed, left, on the waitlist, or never in it) and does not run it; the tournament must have a start date.

Tournament ID. Language of the texts, as in . Cancellation token.

Calculates tournament duration and table recommendations (legacy flat format). Kept for backward compatibility; values now follow the schema engine (§8-C). Prefer the POST variant for the configurable schema and the per-stage breakdown.

Calculates tournament duration, per-stage breakdown, table recommendation and warnings for a configurable schema. Formulas match the client's calcSchema 1:1 (ТЗ §5).

Cancel registration for current player. A running ladder may be left too, open or closed, whatever its even-only rule: the player leaves the roster, while the games they recorded or were recorded against stay — they can still be decided (by the player too) and are registered at the finish. Signing up again is possible.

Join the waitlist ("запас") of a full open tournament. Only while registration is open and no seat is free for the caller — free seats are held for those already queued, so a tournament with a queue is full for a newcomer even below the limit. With a seat free for the caller the call is refused (409 WaitlistNotFull) and the client should offer the ordinary registration. Same body as POST /register: the hand is carried over to the participant, the phone goes to the managers. When the caller's turn comes, the server moves them into the roster itself (confirmed). A repeated call updates the hand/phone and keeps the place in the queue. 409 AlreadyRegistered also when a seat freed at that very moment and this call moved the caller straight into the roster — reload the tournament instead of showing an error.

Leave the waitlist (the current player).

Take a player off the waitlist (organizer / co-organizer / admin).

Who saving the edit form with these values would move from the roster to the waitlist now (organizer / co-organizer / admin) — the same rule as PUT /tournaments/{id}: only when the edit takes seats away (an even-only ladder's odd limit counts as the even one below it) in an open tournament before its start; the unconfirmed first, then the latest to register; guests stay. Otherwise an empty answer.

Tournament id. The limit in the form. A ladder's even-roster rule in the form; the stored one when omitted. Ignored for other tournaments. The access in the form; the stored one when omitted. Cancellation token.

Move a waiting player into the roster out of the queue order (organizer / co-organizer / admin, before start) — free seats already go to the queue head automatically. The participant is confirmed right away — the player queued up themselves. When no seat is left for this player (the roster is full, or the free seats are held for those queued ahead of them), overLimit: false is refused with 409 ParticipantLimitReached: the client shows the "over the limit" warning and repeats the call with overLimit: true.

Submit match score

Edit the score of an already-completed match — an organizer / co-organizer correction of a past result. Allowed while the tournament is Active or Finished. Active: one-day formats register games for rating only at finish, so the corrected score simply overwrites the stored result without a rating recalculation; a match already rated (multi-day/League — a game was registered) returns 409 until the tournament finishes. When the correction flips the winner: if the tournament had already moved on the score is saved but nothing is replayed and the response warns that the edit no longer affects the tournament (); if the downstream was still merely queued, the stale advancement is rolled back and the correct winner/loser advanced. Finished: the linked game is re-rated in place (real Elo for the new score) for the two players only; the registered results (places, other players' deltas) stay frozen and the two players + the registration chat are notified. A finished match with no rated game (a walkover) returns 400 (match-not-rated); a game previously cancelled here is re-registered fresh. A non-admin correction is allowed only within of the finish, else 403 (edit-window-expired).

Cancel the rated game of a match — the equivalent of /revert for a single tournament game. Rolls the game's rating fully back off both players, marks the game discarded and detaches it from the match so it reads as unplayed (for rating) and cannot be cancelled again. The match's own status and recorded score are left untouched, and the tournament's registered results (places, other players' deltas) never move — only the two players' rating is rolled back. Organizer / co-organizer only, and — for a non-admin — only within of the finish (else 403, edit-window-expired). The two players and the registration chat are notified. A match with no rated game (a walkover) returns 400.

Confirm opponent's submitted score

Whether the caller may link a tournament to the chat: an admin, or a player active in it (the chats the client offers, GET players/chats/{id}).

The chat an edit newly points the announcement at — another chat, or another own topic of the linked one; null when it points nowhere new (unchanged, unlinked, or back to the chat's settings).

Checks the bot can post into the topic of the chat — the check a save runs on announceTopicId, so the form can tell the user before saving. The save checks again: the bot's rights may change in between.

The check posts a silent message into the topic and deletes it at once; a success is remembered for two minutes, for this endpoint and the save alike. Only a player active in the chat or an admin may check it. The bot can post into the topic (or there is nothing to check: General, an inaccessible chat). AnnounceTopicUnavailable — the bot cannot post there; ValidationFailed — bad ids. ChatLinkForbidden — the caller is not active in the chat. Too many checks.

Create a new tournament

Update tournament settings (only before start). Changing critical fields (start date/time, place, entry fee) resets participant confirmations for everyone but the organizer and notifies them.

Maps an announce-topic error of the create / update form to a 400, or null when the error is not one.

Maps a ladder-rule error of the create / update form to a 400, or null when the error is not one of them.

Maps a co-organizer validation error raised while accepting the roster inline in the create / update form to a 400 with the same as the CRUD co-organizer endpoints, so the client handles both paths identically.

Start the tournament: generate schedule and assign tables

Cancel the tournament. By default the tournament is marked "not held" and no rating is affected. When is true (only meaningful for a running tournament), the matches already played out (Completed — walkovers never count) are registered as games and fed into the Elo recalculation before the tournament moves to Cancelled.

Tournament id. When true, register the games already played for a rating recalculation. Default false (backward compatible: plain cancel, no games). Cancellation token.

Finish the tournament (organizer confirms after reviewing results)

Call players to a specific table for a match. The organizer chooses the table via the request body (required on the first call; optional on a recall to keep the current table). A recall bumps the call counter and re-notifies the players.

Move a called match to another table. If the target table hosts another live match, the two matches swap tables. Organizer only.

Release a called match from its table: the pair returns to the queue as Scheduled with no table. Organizer only.

Change the number of tables of a running tournament. Growing always succeeds. Shrinking removes tables from the top of the list: it is rejected when the new count is below the number of tables currently in use (free some tables first), and any live pair sitting on a table above the new count is renumbered down onto a freed low table so no pair is left out of range. Organizer, co-organizer or admin only.

Manually seat the next ready pairs onto the free tables — the "call now" action — independent of the tournament's auto-call flag. Runs the same fairness-ordered fill the automatic auto-call uses across every currently-free table; each seated pair is called and both players notified. Idempotent: with no free table or no ready pair nothing changes and the tournament is returned unchanged. Organizer, co-organizer or admin only, Active only.

Change the sets-to-win of one stage of a running tournament (e.g. bump the bracket to best-of-5 mid-event). Applies to that stage's unplayed matches only — matches already completed, forfeited or awaiting score confirmation keep the value they were played under; the stored schema for the stage is updated so a not-yet-generated second stage inherits the new value. Organizer, co-organizer or admin only, Active only.

Replace the format of a RUNNING tournament with what its played matches still allow — see TournamentResponse.FormatEditScope. Nothing played (Full): the whole format (type, stages, sets) is replaced and the schedule regenerated over the roster; pairs already called to a table are released. Group matches played (SecondStage): only the second stage (the finals) is replaced — rebuilt at once if the groups are complete, else when they finish. Second-stage or single-stage matches played (None): only the sets-to-win apply, to unplayed matches. The body is the start request's pair (type + schema, no tables); a request that alters a locked part is refused with 409 FormatLocked and nothing is touched. Organizer, co-organizer or admin only, Active only. Bumps the version so open clients reload.

Set (or clear) the organizer's finish recap — the free-text summary shown on a finished tournament's page. Organizer or any co-organizer (no finish right required); allowed only while the tournament is Finished. An empty or whitespace-only body clears the recap. Bumps the tournament version so open clients refresh.

Adds a co-organizer to the tournament, or updates the finish right of an existing one (idempotent on the player). The target must be an existing, non-guest player other than the organizer; the roster is capped at 5. Allowed while the tournament is Draft / Registration / Active, by the organizer, any co-organizer, or an admin. Notifies the assignee. Does not reset participant confirmations.

Changes a co-organizer's finish right. Same authorization and status rules as . Notifies the co-organizer.

Removes a co-organizer. Same authorization and status rules as . Notifies the removed co-organizer.

Maps the shared result shape of the three co-organizer endpoints (add / set-right / remove) to an HTTP response. On success returns the updated tournament so the client re-renders the roster in one round-trip.

Confirm match start (optional — records StartedAt for statistics)

Record match end time (optional — can be called before score submission)

Manually add a participant (organizer only)

Add a one-off tournament guest (organizer only): creates a profile-less, name-only player that cannot log in and adds it as an already-confirmed participant. The guest is rated as an ordinary newcomer (starts at 1000, no qualification points) and exists only for this tournament — it never appears in search or tops.

Confirm participation for a manually added participant. Callable by the participant themselves, the organizer or an admin.

Confirm participation using the one-time token from an invitation email. Anonymous: the token itself authorizes the confirmation (mirrors the password-reset flow), so it does not rely on the caller's session.

Change a participant's rating hand (organizer/admin only, before start).

Set a participant's seeding rating (organizer/admin only, before start). Used only for group split / bracket placement — it does not affect the rating delta. Null clears the override.

Set a participant's "entry fee received" mark (organizer/co-organizer/admin). Public bookkeeping mark only — no cashier, no amounts. Allowed at any status except cancelled (after the finish too) and, unlike confirmation, never reset when critical tournament fields change.

Remove a participant (before start). Behaviour depends on who calls: An invited player removing THEIR OWN row in a closed (Invite) tournament declines the invitation: the row moves to the manager-only "Отказались" list (kept, re-invitable) and the response carries { declined: true } so the client shows the decline group. Otherwise (organizer removing someone / a self-cancel in an open tournament) it removes the participant: self-removal hard-deletes (the player may re-register freely), an organizer removing someone else soft-deletes (that player cannot rejoin on their own). Returns 204. A running ladder: the organizer may take off anyone — the soft removal keeps the games played (they are still decided and registered at the finish), like a disqualification. Any participant (but an invited one who has not accepted yet — that is the decline above) taking off themselves leaves it as DELETE /register does. 400 once the ladder is over.

Remove a player from the closed tournament's declined list (the "убрать из списка отказов" ✕). The (tournamentId, playerId) declined row is hard-deleted so the slot is free to be invited fresh later. Organizer / co-organizer / admin only, before start.

Record walkover (forfeit) for a match

Tournament templates: the create form's settings saved under a name (Docs/Tournaments/templates.md). A personal template is its author's only; a club one is shared by the venue's owner and representatives on equal terms. Applying a template is client-side — the server stores, normalizes and counts applications.

The caller's personal templates and the club templates of every venue the caller owns or represents.

Cancellation token.

Saves a new template — personal, or for a club the caller owns or represents.

The template's name, scope, kind and create-form settings. Cancellation token.

Renames a template and/or replaces its settings.

Template id. The fields to change; omitted ones stay. Cancellation token.

Deletes a template — a club one for every representative. Tournaments created from it do not change.

Template id. Cancellation token.

Counts an application of the template to the create form (uses + 1).

Template id. Cancellation token.

Base controllers' methods

Checks administrator permissions of logged user

by default, if not set true if the user has admin role

Checks whether the caller holds the given role. Admin is a super-role: an admin satisfies every role. Use this for mixed endpoints where a role changes behaviour (not access) — for pure access gating prefer a [Authorize(Policy = ...)] from , which applies the same rule.

The role required. by default, if not set.

The caller's strongest venue-relevant global role (Admin over VenueModerator), or null for neither. Venue writes use it both for access checks and as the role snapshot in the venue history.

by default, if not set.

Returns Player id of authenticated user

by default, if not set Player id, 0 if not authenticated

Returns the email address of the authenticated user.

by default, if not set Email address of the user, or null if not found

Creates an representing an error response with the specified details.

The error code representing the type of error. A detailed description of the error. The HTTP status code to associate with the error response. An optional title for the error. If not provided, the display name of is used. An containing the error response, including the specified error code, detail, status, and title. For code outside a controller action, e.g. a filter.

Maps a venue-service business error to its ErrorCode + HTTP status via . Shared by the venue and booking controllers so both return the same payload for the same error.

Maps a refused change of email preferences to its ErrorCode + HTTP status, for both ways to make it.

Venue-claim moderation: the pending-claims queue grouped by venue, a resolve (approve/reject) endpoint, and the append-only moderator note history. Every action requires the policy (a venue moderator or an admin); anyone else gets a framework 403. The claim-submission endpoint stays on ; representative requests on owned venues are the owner's (VenueRepresentativesController).

The moderation queue: claims in the given status grouped by venue, venues ordered by their freshest claim.

Claim status to list (default Pending). Origin chip: users | import | dispute | all (default all). Cancellation token.

Resolves a claim (approve/reject). Approve makes the claimant the owner whatever role they named, verifies the venue and drops its representatives (a dispute takes the live owner's rights); reject requires a valid reasonCode and changes nothing on the venue. An internalNote is appended to the claim's note history. The claimant, the previous owner (on a transfer) and the dropped representatives are notified. A request to become a representative of an owned venue is the owner's decision and returns 409 VenueClaimOwnerDecision.

Claim id. Approve flag, reason, claimant message and optional internal note. Cancellation token.

The claim's moderator-only note history, oldest first.

Claim id. Cancellation token.

Appends a moderator note to a claim.

Claim id. The note text. Cancellation token.

A venue's representatives, managed by its OWNER: the list with extra rights, add / change rights / remove, and the owner's decision on requests to become a representative (those never reach moderation). A representative may also remove themselves. Admins get no override here.

The venue's representatives with their extra rights. Owner only.

Venue id. Cancellation token.

Adds a player as a representative, optionally with extra rights. Owner only.

Venue id. The player and the extra rights. Cancellation token.

Replaces a representative's extra rights. Owner only.

Venue id. Representative player id. The full new set of extra rights. Cancellation token.

Removes a representative. The owner may remove anyone; a representative may remove themselves.

Venue id. Representative player id. Cancellation token.

Pending requests to become a representative of the venue, newest first. Owner only.

Venue id. Cancellation token.

The owner's decision on a request to become a representative: approve adds the claimant as a representative (no extra rights), reject leaves the venue as is. The claimant is notified.

Venue id. Claim id. Approve flag and an optional message to the claimant. Cancellation token.

Venues (clubs): the club directory, a public venue page, creation, ownership claims, availability, per-venue wallet, availability blocks, announcements and chat linking. Booking-scoped actions (confirm/decline/ complete/cancel a specific booking) live in . Management actions authorize against the venue's owner/representative (or an admin) via the service.

Returns a paginated list of venues. All filters are optional and combine with AND.

Free-text match on name / place. When true, only venues the authenticated caller owns or represents. When true, only venues with booking enabled (owner + price + pool). Optional longitude for distance sorting/exposure. Without coordinates the list is ordered from the city of the client's IP when it is known (no distances then), else by name. Optional latitude for distance sorting/exposure. 1-based page number. Page size, clamped to 1..100. Cancellation token.

The venues the caller owns or represents (the mine=true list, by name, unpaged), each with what awaits the caller's decision there — the "my venues" strip in one request. Empty for a player who runs no venue.

Cancellation token.

Returns up to ~3 venues that look like duplicates of the given name/point (same-ish name OR within ~300 m), for the create-time "a similar venue already exists" warning (DATA_API §6). Empty list = no duplicates.

Candidate venue name (a blank name yields an empty result). Optional longitude of the candidate point. Optional latitude of the candidate point. Cancellation token.

Returns full venue details (public). Tables and announcements are included by default.

Venue id. Optional longitude for distance exposure. Optional latitude for distance exposure. Cancellation token.

Tournaments held at this venue (linked via the structured VenueId), newest first — for the venue page's tournaments tab (SCREENS §2). Reuses the tournament list item.

Venue id. Optional single status filter (e.g. Registration / Finished). True — the client supports ladders. Omitted, ladders are hidden: apps released before ladders cannot read such a response. 1-based page number. Page size, clamped to 1..100. Cancellation token.

Creates a venue. Only a name and a location (a point or a place) are required. Optionally submits an ownership claim in the same step; creating never auto-grants ownership.

Venue fields. Cancellation token.

Edits a venue. Only the owner/representative (or an admin) may edit.

Venue id. Fields to change (null = unchanged). Cancellation token.

Submits an ownership/representation claim for a venue; it shows as pending until resolved. A request to become a representative of an OWNED venue goes to its owner (who is notified); any other claim goes to moderation.

Venue id. Claim role and optional contact. Cancellation token.

Per-hour availability for the venue over a date (in the venue's time zone).

Venue id. Local calendar date; defaults to today (UTC) when omitted. Cancellation token.

Creates a booking of one or more pool seats over an interval. Money is held immediately (DATA_API §2).

Venue id. Interval and quantity. Cancellation token.

The authenticated caller's own bookings at this venue.

Venue id. Cancellation token.

The venue's player bookings for its console, not over yet: Requested ones awaiting the venue's decision and Confirmed ones, ordered by start (Cancelled and Completed are left out); each row carries the booking . The clubs menu badge counts the Requested rows of other players — the caller's own request is one they wait for. Owner, representative or admin only.

Venue id. Cancellation token.

The authenticated caller's wallet at this venue: folded balance plus the append-only journal.

Venue id. Cancellation token.

Credits a player's balance at this venue (venue admin only — no online payments yet).

Venue id. Target player and amount. Cancellation token.

Closes an interval for booking (owner block / отпуск-ремонт), cancelling and refunding any hit bookings, optionally publishing a closing announcement.

Venue id. Interval, reason and whether to publish an announcement. Cancellation token.

Removes an availability block.

Venue id. Block (booking row) id. Cancellation token.

The venue's announcements (pinned first, then newest).

Venue id. Cancellation token.

Publishes a venue announcement. A closing announcement also blocks bookings for its interval.

Venue id. Announcement fields. Cancellation token.

Removes a venue announcement.

Venue id. Announcement id. Cancellation token.

Links a chat to the venue. The link is instant when the caller is a bot-admin of the chat, otherwise it awaits confirmation (§8.1 anti-hijack).

Venue id. Chat id and optional thread id. Cancellation token.

Unlinks the venue's chat.

Venue id. Cancellation token.

Dedicated EF Core context that holds only the OpenIddict entity sets (applications, authorizations, scopes, tokens). It is registered through via AddDbContext because OpenIddict resolves its stores from a DI-managed context — unlike the business TTRatingDB, which is created by hand (SqlServicesBase.GetContext()). It targets the same MySQL schema; the link to Players is logical only (sub = player id), so there is no FK to the business tables and no reason to mix these sets into TTRatingDB.

Makes automatic model-validation failures (HTTP 400 from [ApiController]) return the same shape as every other error, so clients can always read a numeric errorCode instead of falling back to a bare .

Registers the Telegram Login (OpenID Connect mode) handler with its own short-lived external cookie.

Idempotency-Key support of the API writes: the key store, its cleanup and the two pipeline pieces.

Adds to every response, errors and 429s included: until a client sees it, the client sends each write once.

Handles the of controller writes ().

Keeps search engines off every host except Production (stage.api.ttar.app), on its own in case the IP restriction in front of it is lifted or fails. Production is left untouched.

Outside Production adds to every response (static files, Swagger's 403 and errors included) and answers . Must precede anything that can end the request.

Idempotently seeds the custom scopes (ttar:rating, ttar:games), the trusted partner clients listed in and the first-party web logout client () on startup. Self-service client registration is out of scope; partners are entered by hand in configuration.

Builds the end-session-only descriptor of the first-party web client ().

Centralized protection against repetitive / abusive requests that would otherwise overload the database (the application's main bottleneck). Combines a per-client token-bucket limiter on all endpoints with a stricter named policy () plus a global concurrency cap on DB-heavy endpoints (search, top).

Name of the stricter policy applied to DB-heavy endpoints via [EnableRateLimiting(RateLimitConfiguration.HeavyPolicy)].

Name of the very lenient policy applied to the avatar image endpoint (a static-file emulator) via [EnableRateLimiting(RateLimitConfiguration.AvatarsPolicy)].

Name of the policy applied to the map-link import (outbound requests to map services) via [EnableRateLimiting(RateLimitConfiguration.PlacesPolicy)].

Name of the policy applied to the announce-topic check (each call may post a probe message into a chat) via [EnableRateLimiting(RateLimitConfiguration.AnnounceTopicPolicy)].

Name of the policy applied to the menu badge counts (polled by the client while it is open) via [EnableRateLimiting(RateLimitConfiguration.BadgesPolicy)].

Name of the policy applied to the new-language request (each call notifies the admin by Telegram and email) via [EnableRateLimiting(RateLimitConfiguration.LanguageRequestsPolicy)].

Name of the policy applied to the photo upload (an image decode and re-encode per call) via [EnableRateLimiting(RateLimitConfiguration.PhotoUploadsPolicy)].

Configures so the real client IP is resolved from X-Forwarded-For set by the trusted reverse proxy (Apache). Without this, per-IP partitioning collapses because every request appears to come from the proxy.

Returns true and the player id when the request carries a valid authenticated PlayerId claim (matching TtarControllerBase.GetUserId semantics, where 0 = anonymous).

Detects whether the endpoint matched for this request carries the named policy. Used by the chained global limiter to decide which sub-limiter applies, so the global token bucket and the heavy policy never double-count the same client.

Whether the matched endpoint carries any named rate-limiting policy. Such endpoints opt out of the global token bucket so they aren't double-counted.

Propagates C# nullable reference type annotations to OpenAPI parameter schemas. SupportNonNullableReferenceTypes/NonNullableReferenceTypesAsRequired only affect request body schemas — not individual query/route/header parameters.

Overrides the OpenAPI schema for enums that go on the wire as their numeric value (via a per-property JsonNumberEnumConverter) rather than the member name. The global JsonStringEnumConverter otherwise makes Swashbuckle describe every enum as a string, which for is a lie: the response carries "errorCode": 21, not "TournamentNotFound". This emits an integer enum plus x-enum-varnames (the NSwag / openapi-generator convention) so a client can map the number back to a stable name.

Wires up Swagger with an IP allow-list so non-production environments (e.g. Staging) expose the endpoint catalog only to whitelisted developer networks, not to everyone who guesses the URL. Production keeps Swagger fully off; Development uses a broad range to admit all.

Enables Swagger and its UI, guarded by the CIDR ranges in the Swagger:AllowedNetworks config section. Fail-closed: an empty/missing list means no one is allowed. Requests to /swagger* from an address outside every configured range get a 403 before the docs render.

extensions

Converts collection to list

collection list

Converts games waiting for confirmation to list, with their and what happens then.

Unconfirmed, not discarded games, loaded with their . The confirmation period of an ordinary game.

Makes request-supplied text safe to put into a log entry.

Escapes control characters (a CR/LF in a request value would otherwise forge a separate log entry) and cuts the value to characters.

Text taken from the request (query, body, a decoded URL part). Maximum number of source characters kept. The loggable text, or null for null.

The Retry-After header of the API's "come back later" responses.

Sets Retry-After to in whole seconds, rounded up and at least one: a zero would invite an immediate retry.

Real-time channel of the Messages section. Every authenticated connection is addressed by its player id (), so a private message, a read receipt or a "seen" tick needs no group: the broadcaster sends to Clients.User(playerId). The geo chat fan-out goes only to the connections that called (the tab is open), each checked against its reader's radius and blocks. Client methods: PrivateMessage(PrivateMessageResponse), PrivateRead(otherPlayerId, upToId?), GeoChatMessage(GeoChatMessageResponse), GeoChatSeen(int[] messageIds), GeoChatMessagesHidden(int[] messageIds) (the reader's feed lost them), GeoChatBan(ChatBanResponse?) (the reader's own ban was set or lifted).

The geo chat tab opened: this connection receives its reader's feed updates.

The geo chat tab closed.

SignalR user id = the PlayerId claim, so Clients.User("123") reaches every device of player 123.

The connections watching the geo chat feed. Singleton: hub instances are per call, and the broadcaster needs the set outside any call.

The connection opened the geo chat tab as this player.

The connection closed the tab or dropped.

Distinct players with at least one watching connection.

API-side over . A geo chat message is resolved per watching player from the in-memory caches (no MySQL for a primed reader) and sent with that reader's own distance; players whose feed hides it get nothing, so the content never reaches a reader who blocked the author.

Client method: a new private message (PrivateMessageResponse).

Client method: the other player read the thread (otherPlayerId, upToId?).

Client method: a geo chat message the reader's feed shows (GeoChatMessageResponse).

Client method: the author's messages got their first "seen" tick (int[]).

Client method: messages the reader's feed lost (int[]); the client drops them by id.

Client method: the reader's own ban was set or lifted (ChatBanResponse?).

API-side : pushes the change to the tournament's SignalR group via . The client method name is TournamentChanged; the arguments are the member NAME (matching the ttar.change string the push carried) and the tournament's current monotonic version, so the client parses it exactly as it already parses the push payload and can discard a signal older than what it already renders.

Real-time channel that live-refreshes an OPEN tournament detail/projector page. A client that opens a tournament calls to subscribe to that tournament's group; the server pushes a TournamentChanged message to the group whenever the tournament's live state changes (score submitted/confirmed, tournament started/finished/cancelled, roster changed). This replaces the silent TournamentDataChanged FCM push for the open-page case, which a browser can throttle/drop (Firefox's silent web-push quota) — the exact reason a confirm/finish refresh went missing. Open to anonymous connections so the web-only projector screen (opened by an unauthenticated guest via a shared link) can receive push, not just the 45s silent-poll fallback. The push carries NO data — only a change-name + monotonic version; the guest fetches the actual data from the already-[AllowAnonymous] GET endpoints. Because there is no [Authorize] gate any more, is the sole guard against abuse and MUST validate its input (see below).

Max distinct tournament groups a single connection may join. The projector/detail page holds exactly one group at a time (the client leaves before it joins another), so a small cap has ample headroom while stopping an anonymous connection from stuffing the lifetime manager with arbitrary ids.

Per-connection set of joined tournament ids, used to enforce . Static because Hub instances are created per method invocation, not per connection — the state must outlive a single call. Cleaned up in .

Subscribe this connection to a tournament's live updates (called when its page opens).

Unsubscribe (called when the page closes). Disconnect also cleans groups automatically.

Deletes the idempotency keys past every . Expired keys are ignored on lookup anyway; this only keeps the table small.

The Idempotency-Key contract with the clients (HTTP headers only, not part of swagger).

Request header: one key per logical user action, the same on every retry of it.

Response header on every response while the key is honoured; clients retry writes only after it.

Response header of a 409: while the same key is still running.

The value of a duplicate that arrived while the first request runs.

Response header of a stored response replayed to a retry.

Runs a controller write (POST/PUT/PATCH/DELETE) sent with an at most once per caller and key: a retry of the same request gets the stored response, a duplicate arriving while the first runs gets 409 in-progress, the key reused for another request gets 422. 5xx and 429 are not stored. The contract is in Docs/API/idempotency.md.

Handles the request under its idempotency key, or passes it through when it has none or is not covered.

Excludes a controller or action from Idempotency-Key handling: the key is ignored and the request runs as sent. For endpoints the API client does not call (OIDC, server-to-server), whose responses carry cookies or protocol headers a replay would not restore.

A support payment entered by an administrator.

Net US dollars after the payment service's fee: more than 0, at most 99 999.99, cents at most.

An event of the "Expenses and support" page. Carries nothing about the visitor.

View — the page was opened; Click — "Support the project" was tapped.

The bucket of the page statistics.

One row per day.

One row per month, dated by its first day.

Expenses of a period and the support collected in it, US dollars (support is net of the payment service's fee). The client computes the coverage from the two sums.

Operating expenses.

Support collected.

One month of the history.

The year.

The month, 1–12.

One year of the history: its months from the start of the history up to the running one.

The year.

A calendar month.

The year.

The month, 1–12.

Today, UTC: the running month and how much of it is left.

Day of the month, 1-based.

Number of days in the running month.

The three coverage scales: the running month, the running year and the whole history.

The first month of the history (the month of the first game).

Today.

The running month.

The running year, its months of the history up to the running one.

The whole history up to the running month.

What the support sheet offers the caller.

The caller's country, ISO 3166-1 alpha-2 (GE): from the profile or the stored location, for a guest from the IP address; null when unknown.

The methods offered in the caller's country, in the order to show: those meant for that country first, then those for everyone, each in the configured order.

A payment method of the support sheet.

The client's key of the method: boosty, flitt, bog, gpay, erip-phone, erip-qr, card-belkart, card-belkart-by, card-mastercard, card-visa.

External opens , which chooses the amount and the frequency itself; Acquiring and Wallet take them from the sheet; Transfer is paid in the payer's bank app to at , by the QR code of or to of , with no amount or frequency in the sheet.

The page of an external method or the payment link of a transfer (to draw as a QR code and open on a phone), as is: nothing about the player is added to it.

The recipient's phone of a transfer, E.164 (+375291234567).

The recipient's bank of a transfer, as the payer finds it in their bank app.

The recipient's card number of a transfer, 13–19 digits with no separators.

The cardholder's name in Latin letters as on the card, which a cross-border card transfer asks for.

A month in the admin page "Поддержка проекта": its support payments and the sums.

The year.

The month, 1–12.

Support collected: the sum of the payments, with cents. The banner and the page show the same.

Operating expenses of the month (0 while the section is switched off).

The payments, newest first.

One support payment entered by an administrator.

Payment id.

Net US dollars, with cents.

When it was entered, UTC.

The administrator who entered it; null for a payment not entered by hand.

An administrator in the payment log.

Player id.

Display name.

A payment just added and the new support of its month.

The payment.

Support collected in the month now.

The support of a month after a payment was deleted.

Support collected in the month now.

Anonymous counters of the "Expenses and support" page for a day or a month (UTC).

The day; for a month, its first day.

Openings of the page.

Taps on "Support the project".

Represents a geographic point defined by its longitude and latitude

Longitude Latitude

Represents a geographic point defined by its longitude and latitude

Longitude Latitude

Longitude

Latitude

Converts the current geographic coordinates into a NetTopologySuite .

A representing the geographic location defined by the current longitude and latitude.

Player hand rating (e.g. rating for Main hand, or for Weak hand)

Player profile id

Player name, or Telegram login with "@" prefix when the player profile has no name yet (e.g. a game registered by Telegram login, not confirmed yet).

Avatar URL

Hand type (Main, Weak)

Elo rating value

Amount of games (not sets)

Amount of qualification points

Qualification points a hand needs to be qualified; the same for every hand.

Indicated whether a player was rated once. Due to inactivity the player may have to get qualification points again, but it is displayed in a top anyway.

True for a rated hand whose were reset below for inactivity; it is active again once the points reach the target.

True when this hand belongs to a one-off tournament guest (no TTAR profile, no login). A guest is rated as a normal newcomer; the game history shows it with a silhouette avatar and a "guest" marker and does not link its name to a profile page. Distinct from IsExternal (RTTF import).

True when this hand belongs to an RTTF-imported player (an RTTF profile only, no TTAR login). Unlike a guest, an external player carries a real imported rating (shown normally); the history/dashboard mark it with an "RTTF" pill + globe badge and do not link its name to a TTAR profile page.

The owning player's physical main hand (Left/Right). Lets the client render the "left hand" badge for this record from + this side. null when never set (treated as Right) or for a tournament guest (no profile hand).

A map link to read venue fields from.

Link to a place on Google Maps, Yandex Maps, 2GIS, OpenStreetMap or Apple Maps — short links included. The whole text of a "share" action is accepted too: the first place link in it is used (else the first short link, else the first map link).

Optional HTML of the card page as the client loaded it (a mobile WebView on the user's own connection), for when the server's own request is refused. Read for Yandex, 2GIS and Apple; for Google only its preview link is taken (the server fetches the preview itself); ignored for OpenStreetMap.

Venue fields suggested from a map card, named and shaped as in POST /venues so the chosen ones can be put into the form as they are. A hint only: nothing is stored until the venue itself is created.

The card — pass it as source of POST /venues.

True when the card itself was read. False = only the link could be read (the service refused or changed its page): the fields below are then limited to what the link carries, and a missing one is unknown rather than absent from the card.

Place name.

Address as one line, "city, street".

Latitude of the place's point.

Longitude of the place's point.

Phone number as the card shows it.

Web site.

Telegram handle (@name).

Opening hours (7 pipe-separated day strings, Mon..Sun; empty segment = closed).

IANA time zone of the place, when the card states one.

Player's images

Relative path to the image

The image type. A photo the player uploaded comes as (it is the avatar shown); whether it is one is PlayerProfileResponse.HasPhoto.

Represents a mapping between a and its associated rating value

Gets the rank

Gets the rating value associated with the rank

When true, a long-lived session token is issued alongside the refresh token. Omit or set to false for regular (non-persistent) sessions.

Optional device description (mobile app). The app and its version go in the X-Client-App / X-Client-Version headers; the web omits this field and is identified by the User-Agent header.

The new avatar centre of the player's photo.

The avatar centre in fractions (0…1) of the photo width; clamped to the range

The avatar centre in fractions (0…1) of the photo height; clamped to the range

Request to start changing the email address of the authenticated user. A confirmation link is sent to the new address; the login email is switched only after confirmation.

The new email address. Must be a valid email format and is required.

The current password. Required: the email can only be changed on an account that has a password. A password-less (SSO/Telegram) account must set a password first; otherwise the request is rejected with ErrorCode.PasswordRequired.

Preferred language code for the confirmation email (e.g. "en", "ru", "pl"). Falls back to the user's stored language preference when omitted.

Request to change the password of the authenticated user.

The current password. Required for accounts that already have a password; may be omitted for password-less (SSO/Telegram) accounts setting their first password.

The new password. Must be at least 8 characters long and is required.

When true, the fresh tokens returned for the current device include a long-lived session token ("remember me"). Pass the same value the current session was created with so the device keeps its persistence after the password change. Omit or set to false for non-persistent sessions.

Optional device description (mobile app) for the re-issued session. The app and its version go in the X-Client-App / X-Client-Version headers; the web omits this field.

Request model for ChangeProfile method

Displayed user name

User password

Indicates whether private messages should be copied to Telegram

User-defined language code override. Set to empty string to reset to Telegram language.

Whether the displayed name follows the linked RTTF profile (true) or the account name (false). Ignored unless the player has a confirmed RTTF link. null means "don't touch".

The player's physical main hand (Left/Right). Setting it changes only the profile label — ratings, history and qualification never move between axes. Sending an explicit value (including the default Right) is itself the confirmation that dismisses the soft "please confirm" prompt. null means "don't touch".

The player's gender ("Male" / "Female"). A one-time choice: once set, re-sending the same value is a no-op and a different one is refused with 409 GenderAlreadySet. null means "don't touch" (it never clears).

The "Contacts and about" block with its visibility flags and the other-rating links. Unlike the fields above it is replaced AS A WHOLE: when present, an omitted or null field inside clears the stored value and an omitted flag is false. null means "don't touch the block".

Request to complete the change-email flow using a token from the confirmation email.

The token from the confirmation email. Must be provided and is required.

Request to confirm an account email using a token from the confirmation email.

The token from the confirmation email. Must be provided and is required.

When true, a long-lived session token is issued alongside the refresh token.

Optional device description (mobile app). The app and its version go in the X-Client-App / X-Client-Version headers; the web omits this field.

Turns email topics on or off: only the listed ones change, the rest keep their state.

The topics to change; one at a time is the usual case.

made through the emailed link, without signing in.

The token of the emailed preferences link.

One topic to turn on or off.

The topic.

Whether its emails are to be sent.

Represents a request to log an exception

Gets or sets the exception message

Gets or sets the application version where the exception occurred

Gets or sets device information, if available

Gets or sets the stack trace of the exception, if available

Gets or sets additional information related to the exception (e.g. page, API call, arguments)

String values on purpose: an object? value type is emitted by Swagger as an empty enum, which makes the NSwag-generated client unable to send anything.

A page of the geo chat feed.

Only messages older than this id (the first message of the page shown); omitted = the newest.

Page size, at most 100.

The reader's current position; refreshes their stored position when it moved to another ~500 m cell.

A geo chat message.

Text with @[playerId] mention tokens, at most 3 distinct, 400 characters in all.

The sender's position (the message is stored with its ~500 m cell); without it the send is refused with 403 GeoChatLocationRequired.

The reader's geo chat settings.

One of 0 (off), 5, 10, 50, 100, 500, 1000, or -1 ("all", chat moderators only).

The guest teaser's point.

The viewer's position; omitted = global counts.

A report about a player.

The reported player.

Where the report is filed from.

The reported geo chat message ( only).

The reason.

Free text, at most 1000 characters; required for .

Also block the reported player.

A decision about a player: closes all their open reports, bans or deletes as asked.

The player decided on.

None (no violation), DeleteMessages, BanChat, BanAll.

Required for a ban; Other needs a comment.

The moderator's comment; the player sees it with the reason.

A chat ban's length: 1d, 7d or 30d; null = until lifted. Only for BanChat.

Which messages to delete: None, Message (needs messageId), Reported, All. DeleteMessages defaults to Reported.

The geo chat message the decision was opened from.

Where the decision is made: Admin (the "Reports" page) or Chat (the author menu).

The term as a span, or null for none; false when the text is not a term.

A moderator's own settings.

New reports come to the moderator's Telegram, with the decision buttons.

Template to create new unconfirmed game

Temporary identifier for the game, used for callbacks

Player 1 id

Player 1 hand type

Player 2 id

Player 2 hand type

Player 1 score

Player 2 score

Telegram chat for notifications

A user's request for a new interface language, sent from the language menu.

The requested language, free text as the user typed it (e.g. Polski, Vietnamese).

Optional comment.

Optional address to reply to, mainly for anonymous users; an authenticated caller's account email is used when omitted. Send null rather than an empty string, which fails the email check.

Whether the user offers to help with or proofread the translation.

The current interface language code (e.g. ru, pt-BR), for context.

Request to complete the password reset flow using a token from the reset email.

Request to start the password reset flow by email.

Email address of the user requesting password reset. Must be a valid email format and is required.

Preferred language code for the reset email (e.g. "en", "ru", "pl"). Falls back to the default (English) when omitted.

The "Contacts and about" profile block, sent as a whole (see ). Every field is optional. Each visibility flag governs what OTHER users get; the owner always sees everything.

Contact phone: digits, '+', '-', spaces and brackets, 5–15 digits. Never shown to anonymous viewers.

Pass to the managers of tournaments the player registers for themselves.

Show to other authenticated players on the player card (never to anonymous viewers; a minor's phone stays hidden from others regardless). Implies .

Country of residence, ISO 3166-1 alpha-2 (the name is localized on the client).

City of residence, free text up to 60 characters.

Show the residence country/city to everyone.

Country of birth, ISO 3166-1 alpha-2.

City of birth, free text up to 60 characters.

Show the birth country/city to everyone.

Birth year (only the year is asked), from 1900 to the current year.

Show the birth year to everyone (a minor's year stays hidden from others regardless).

Show the Telegram username to other authenticated players (never to anonymous viewers).

Show the RTTF link to everyone on the player card. Managers and confirmed participants of a tournament the player confirmed participation in see the link regardless.

Show to everyone.

Links to the player's profiles in other rating systems, in display order (at most 10).

A link to the player's profile in another rating system.

The rating system ("Ittf", "Fntr", "Ttw", "Other").

System name, required for "Other" (up to 50 characters); ignored for a listed system.

Profile link shaped like host.tld/...; the https:// scheme is optional.

Request to register a new account with an email and password.

The email address used to identify and authenticate the account.

The password used to authenticate the account. Must be at least 8 characters long.

Optional display name for the new account.

Preferred language code for the confirmation email (e.g. "en", "ru", "pl"). Falls back to the default (English) when omitted.

Request to re-send the email-confirmation link for an unverified account.

The email address used to identify and authenticate the account.

Preferred language code for the confirmation email (e.g. "en", "ru", "pl"). Falls back to the default (English) when omitted.

Request to re-send the email-change confirmation link for an authenticated user with a pending email change.

Preferred language code for the confirmation email (e.g. "en", "ru", "pl"). Falls back to the user's stored language preference when omitted.

Request model for searching players

Pattern to search, wild-cards allowed

Should include players without any rating, just registered

Page of returned results

Returning results' page size.

Geographical point containing longitude and latitude

Request model for searching Telegram chats

Page of returned results

Returning results' page size.

Geographical point containing longitude and latitude

Request model for sending a private message

The message content

Geographical point containing longitude and latitude

Request model for retrieving top players with optional filtering and pagination

Gets or sets the current page number for pagination

Display position of specified player in returned results

Gets or sets the page size for pagination

Gets or sets the optional geographic location for proximity filtering

Gets or sets the optional distance in kilometers for location-based filtering

Long-lived session token for "remember me" functionality. Present only when the client requested session persistence.

Telegram chat model

Chat id (not Telegram id!)

Chat name

Chat invitation link

Chat default language

The supergroup has topics enabled (known once the bot has seen a message there): the client then offers a tournament its own announce topic.

The bot's default topic for the chat — where it posts games and, unless a tournament has its own topic, tournament announcements and results. Null — General.

True — an admin pinned in the bot's chat settings; false — the bot picks the most used topic.

The chat's id in message links t.me/c/<id>/… (a supergroup's Telegram id without the -100 prefix), to tell a link to another chat's message; null for a basic group.

What happens to a game still waiting for confirmation at its .

The confirmation expires: the game never counts.

The game counts by itself, as if confirmed (a finished ladder's waiting game with auto-confirm on).

Conversation header information

Sender information (ever if there is no any message from the sender) Latest message information

Conversation header information

Sender information (ever if there is no any message from the sender) Latest message information

Sender information (ever if there is no any message from the sender)

Latest message information

Aggregated home-dashboard payload for the authenticated player and a single hand. Widgets build their charts and messages from these numbers (design handoff "Главная / Dashboard"). Guest landing needs no data.

Rating widget: current rating, rank progress and all-time record.

Per-period rating delta, games and normalized sparkline (week/month/year).

All-time win/loss/draw, winrate and win streaks.

Head-to-head: most-beaten opponent (favorite) and worst matchup (nemesis). Each side may be null.

Up to four most recent games, newest first.

Yearly activity heatmap (52×7 daily levels 0..4) and totals.

Nearest upcoming tournament open for registration, or null (widget hidden).

Achievements badges. Empty in this iteration — there is no achievements source yet (see handoff §9); the client renders the locked-only state until a rules/storage contract is added.

Server-computed inputs for the client-side "humorous fact" widget. The client owns the phrase templates; the server supplies only the numbers the client cannot derive from the rest of the payload.

Builds the response from the aggregated dashboard data.

The dashboard data produced by the dashboard service.

Server-computed inputs for the client-side humorous facts. Each field is nullable: null means the server has no data for that quip and the client skips it. Quips derivable on the client (period delta, streak, points-to-next-rank) are intentionally absent — the client already has those numbers.

The source quip inputs.

The weekday the player plays most (last year), or null when there are no games. Feeds the "most games on {weekday}" quip.

Rating widget data.

Current rating for the hand.

The hand the dashboard is built for.

Whether the hand has been rated (passed qualification).

Current qualification points.

Qualification points a hand needs to be qualified.

Total games for the hand.

Current rank and its starting rating threshold.

Next rank and its threshold, or null when at the top rank.

Peak rating reached (from the rating history).

Date the record rating was reached, or null when no history.

Builds the rating widget data from the aggregated dashboard data.

The dashboard data.

A rank plus its starting rating threshold.

The source rank data.

A rank plus its starting rating threshold.

The source rank data.

The rank.

The lowest rating that maps to this rank.

Per-period rating stats.

Last 7 days.

Last 30 days.

Last 365 days.

Builds the per-period stats from the aggregated period map.

The per-period aggregates keyed by period kind.

Rating stats for one period.

The source period aggregate.

Rating stats for one period.

The source period aggregate.

Rating change over the period.

Games played within the period.

Rating series normalized to 0..1 for the sparkline.

All-time statistics and streaks.

The source statistics.

All-time statistics and streaks.

The source statistics.

Total games for the hand.

All-time wins.

All-time losses.

All-time draws.

All-time winrate, whole percent.

Current trailing win streak (last year).

Best win streak (last year).

Favorite/nemesis head-to-head records; each side may be null when nobody qualifies.

The most-beaten opponent, or null.

The worst matchup, or null.

Builds the head-to-head widget from the favorite and nemesis records.

The most-beaten opponent, or null. The worst matchup, or null.

A single head-to-head record against an opponent.

The source head-to-head record.

A single head-to-head record against an opponent.

The source head-to-head record.

The opponent (name, avatar, player id).

Wins against the opponent.

Losses against the opponent.

A single recent game from the current player's point of view.

The source recent game.

A single recent game from the current player's point of view.

The source recent game.

The opponent (name, avatar, player id).

The current player's score.

The opponent's score.

Outcome for the current player.

The current player's rating change in this game.

Confirmation date of the game.

Yearly activity heatmap.

The source activity data.

Yearly activity heatmap.

The source activity data.

364 daily buckets (52 weeks × 7 days), intensity level 0..4 each (heatmap colour).

364 daily buckets aligned with , each the actual (uncapped) number of games that day.

Total games played over the year.

Number of weeks with at least one game.

The player's email switches by topic.

The address emails go to; null without one. Masked (v***@gmail.com) when read through the emailed link, which anyone the email reached may open; in full for the signed-in player.

Whether the address is confirmed: notification emails go only to a confirmed one.

Every topic, in a stable order. A client ignores the topics it does not know.

The address with all of its local part but the first letter hidden.

One topic's switch.

The topic.

Whether its emails are sent; always true for a locked topic.

The player may not turn it off: account emails they asked for, or the news of a tournament they joined (leaving the tournament is the way out).

Whether any email belongs to the topic today; a switch without emails changes nothing yet.

Represents the result of a game registration attempt

Temporary identifier for the game, used for callbacks New game model if registration was successful; otherwise null Game registration status

Represents the result of a game registration attempt

Temporary identifier for the game, used for callbacks New game model if registration was successful; otherwise null Game registration status

Temporary identifier for the game, used for callbacks

New game model if registration was successful; otherwise null

Game registration status

Initializes a new instance of the record from a .

The to convert.

What the caller's rating would do after a game against the opponent if it were confirmed now (nothing is persisted). Computed by the same pipeline as a real confirmation: K-factor by games count, the "rule 400" and the qualification rules.

The opponent the forecast is made against.

The caller's rating axis.

The opponent's rating axis.

The caller's rating delta for the reference win WinsDivider:0 (currently 2:0) — one full Elo step, K·(1−E). Positive or 0.

The caller's rating delta for the reference loss 0:WinsDivider (currently 0:2) — one full Elo step, −K·E. Negative or 0.

The caller's rating delta for the exact score1:score2, when both were passed; null otherwise.

The qualification multiplier (EloQualificationCoefficient) would apply to this game: exactly one side is still qualifying and the multiplier was not applied to this pair of hands within QualificationTimeout.

Game information

DB Game model to convert

Game information

DB Game model to convert

Game id

Score of Player 1

Score of player 2

Game submit date

Game confirm date

Player 1 rating modification in this game

Player 2 rating modification in this game

Player 1 rating before the game

Player 2 rating before the game

Player 1's side belongs to a tournament guest later merged into a player with a rating of their own: the game did not move that player's rating — show "без пересчёта" instead of the delta and keep it off the rating chart.

Player 2's side, see .

Is the game qualified

Rating calculation rules

Player 1 confirmation

External (imported) tournament id, if the game was imported in scope of one.

Native in-app tournament id, if the game belongs to one.

Who discarded the game

Player 1 id

Player 2 id

Player 1

Player 2

When the game stops waiting for confirmation (UTC); what happens then is . Filled only by GET /games/unconfirmed, null elsewhere.

What happens at : the confirmation expires, or the game counts by itself. Null with it.

Paged list of collection

Collection of games Page details

Paged list of collection

Collection of games Page details

Collection of games

Page details

A mentioned player: the client renders @Name for the @[playerId] token of the text.

The mentioned player.

Their current display name.

Every token of the text whose player is known, in order of appearance (the moderators' view, blocks ignored).

A geo chat message as one reader sees it. The author's position is never exposed: only the rounded distance to the reader.

Message id (the paging cursor).

The author; an author who blocked the reader is shown without contacts (hasBlockedMe).

Text with @[playerId] mention tokens.

When it was sent (UTC).

The players the message reaches by mention; render the @[id] tokens from here.

Distance from the author's position at send time to the reader, in km, a 0.5 km step (0.5 = "< 1 km"); null for own messages or an unknown reader position.

Whether the message mentions the reader.

Whether this is the reader's own message.

Own messages only: whether at least one reader has seen it (the double tick); null for others' messages.

The moderator's marks (open reports, hidden from the players, the author's ban); null for a player.

A page of the reader's geo chat feed.

Oldest first, as the thread reads.

Whether older messages exist: pass the first message's id as before to load them.

The reader's radius; 0 = the chat is off (only own messages and mentions are listed); -1 = "all" (moderators only).

The reader's read marker: messages after it are "new" (the divider).

Whether the reader's position is known; without it nothing but own messages and mentions is listed.

The reader's ban in force (the banner replaces the composer); null without one.

Maps a service page for the viewer.

The reader's geo chat settings and the marks of the "Geo chat" tab.

Radius in km; 0 = off; -1 = "all" (moderators only; a player who lost the role reads 1000).

The read marker.

A mention of the reader newer than the marker: the red "@" on the tab (and +1 on the envelope).

A visible message newer than the marker: the dot on the tab.

The reader's ban in force (the banner replaces the composer); null without one.

Maps the service status.

The guest teaser: the chat's activity around a point over the last day, no content.

Messages of the last 24 hours.

Distinct authors of those messages.

When the newest of them was sent (UTC), or null.

The radius the counts cover; null when no point was given (then the counts are global).

Maps the service result.

A player the caller blocked.

The blocked player (contacts hidden).

When the block was set (UTC).

The filed report.

The report id.

Whether the reported player is blocked by the caller now.

Amount of confirmed games played between a player and an opponent, broken down by the player's hands. Mirrors the "joint games" note shown in the Telegram player profile (history) view: for a given hand of the player, it counts games against all hands of the opponent.

The opponent the joint games are counted against.

Total amount of joint games across all of the player's hands.

Head-to-head wins of the viewer (the requesting jointGamesWithPlayerId player) against the viewed player. The left side of the "личные встречи" score X:Y. Draws count for neither side (see ).

Head-to-head wins of the viewed player (this profile's playerId). The right side of the score X:Y.

Joint games that ended in a draw (equal score). + + equals .

Per-hand breakdown. Hands without joint games are included with a zero count.

Builds the response for against .

The viewed player (this profile) whose hands are listed. Hands must be included. The viewer (requesting) player id the games are counted against. Map of player hand id to joint games count (e.g. from ). Head-to-head win split with as side 1 (from ). Player1Wins is the viewed player's wins (); Player2Wins is the viewer's (). The populated joint games response.

Joint games count for a single hand type.

Hand type (Main, Weak).

Amount of confirmed games for this hand against the opponent (all opponent hands).

Response of POST /Account/login-exchange: the one-time code the web client hands to /connect/login-callback to establish the OIDC IdP session.

The opaque, single-use, short-lived login-exchange code.

A moderator's ban in force: where, why, until when.

Chat: no writing or mentioning in the geo chat; All: no sign-in at all.

The reason the player is shown.

The moderator's comment (always present for Other).

The end (UTC); null = until lifted.

The marks under a geo chat message a moderator sees (null for everyone else).

Open reports on the message ("⚑ N reports · review").

Hidden from the players by its reports until a decision.

The author's ban in force, or null.

A message as it was when the report was filed.

The players the card's tokens point at; null for a private message (no tokens there).

A message as it was when the report was filed.

The players the card's tokens point at; null for a private message (no tokens there).

The players the @[id] tokens of a geo chat quote name (blocks ignored); null for a private message.

One report as the queue shows it: the reporter, the reason, the evidence taken at filing time.

The reported geo chat message (geo reports only).

The quoted geo chat message as it was (geo reports only).

The last messages of the pair, oldest first (private reports only; the rest of the thread is never shown).

Whether the reporter blocked the player along with the report.

A reported geo chat message on the queue card.

The players the @[id] tokens of the text name, blocks ignored (unlike the feed's stored mentions).

Deleted by a decision (shown with the "deleted" pill).

Hidden from the players by its reports.

A journal row: who decided what about whom, and whether it was undone.

A chat ban's end (UTC); null = until lifted.

The geo chat message the decision was opened from.

How many reports the decision closed.

How many messages (geo chat and private) the decision deleted; kept as of the decision after a revert.

When the decision was undone; the row stays in the journal, muted.

One card of the "Reports" queue: a player and all open reports on them.

Younger than a week with no game: the "new account without games" pill and the "ban from TTAR" default.

The open reports, oldest first.

How many reports gave each reason (the reason's name is the key).

When the newest report came (UTC).

The reported geo chat messages, oldest first (one entry however many reports a message has).

The last decisions on the player that stand ("earlier: …"), newest first.

The ban in force, or null.

The player's geo chat messages a purge: All deletes now (not deleted yet).

The private messages the player sent that a purge: All deletes now (not deleted yet).

A ban in force, as the "Bans" tab lists it.

The end (UTC); null = until lifted.

The decision that set it (the journal row to revert).

Where that decision was made: the "Reports" page, the geo chat, or the bot's alert.

A moderator's own settings, and the moderation constants the page explains.

New reports come to the moderator's Telegram, with the decision buttons.

Open reports from this many distinct players hide a geo chat message from the players until a decision (read-only).

Menu badge counts: how many items in each menu section wait for the caller's answer. Each number equals the rows marked inside that section; what the caller waits for themselves (their own game record, booking, draft) is never counted. Numbers are not capped — the client draws "99+".

Conversations with an unread incoming message (one per conversation, however many messages; senders the caller blocked are left out), plus 1 when the geo chat holds an unread mention of the caller (the red "@" of the "Geo chat" tab: one "row", however many mentions).

Whether the geo chat holds a message newer than the caller's read marker that their feed shows: another player's, within the caller's radius of their stored position (or mentioning them), by an author they did not block — the dot of the "Geo chat" tab, GeoChatSettingsResponse.HasNewMessages. The menu draws its dot from it only when is 0. false with the chat off (radius 0) or without a stored position, mentions aside; messages older than the chat's in-memory window never set it.

Games waiting for the caller's side to confirm, not discarded and not expired — the "waiting for you" rows of GET /Games/unconfirmed. A ladder's records are no games until its pairs are registered: they count in only.

Tournaments waiting for the caller, one per tournament: participation to confirm (TournamentListItem.MyParticipationUnconfirmed), a ladder game to confirm, or a match called to a table.

Requests to the venues the caller owns or represents: other players' booking requests awaiting the venue's decision (the Requested rows of GET /venues/{venueId}/venue-bookings not booked by the caller), plus representative requests (owner only). null when the caller runs no venue; 0 when they do but nothing waits.

The venue-claim moderation queue (GET /venue-claims?status=Pending). null without the VenueModerator or Admin role; 0 with it and an empty queue.

The "Reports" moderation queue (GET /Moderation/reports): players with open reports, not reports. null without the ChatModerator or Admin role; 0 with it and an empty queue.

Maps the counts and the geo chat's "new" mark to the response.

A link to the player's profile in another rating system (display-only).

The rating system.

System name typed by the player; set only for .

Profile link (always with a scheme).

The photo the player uploaded: its full size and the avatar centre the preview is cut around.

Width of the full photo ({avatarPath}/full), up to 640 px.

Height of the full photo, up to 640 px.

The avatar centre in fractions (0…1) of the photo width; 0.5 when never chosen.

The avatar centre in fractions (0…1) of the photo height; 0.5 when never chosen.

Player profile info. Should be available only for profile owner or admins!

The player to expose. When true, exposes the RTTF confirmation code. Callers MUST set this only on self-scoped responses (the owner requesting their own profile) — the code is a secret and must never leak to others. The privileged roles this player holds (empty for an ordinary user). Computed by the caller, as role membership is not a property of . The player's other-rating links, or null when the endpoint did not load them. then stays null ("not loaded"), so a client never mistakes an unloaded list for an empty one and wipes it on save.

Player profile info. Should be available only for profile owner or admins!

Displayed name

Own profile only: the moderator's ban in force (the banner replaces the geo chat composer); null without one. Set by the caller from the bans store.

Privileged roles the player holds. Empty for an ordinary user; may contain several at once (a client can be both a chat moderator and a tournament supervisor). Serialized as member names ("Admin", …) by the global JsonStringEnumConverter — a per-property enum [JsonConverter] is rejected on a collection type.

Telegram user id

Telegram username

Telegram display name

Whether the has been confirmed. Accounts created via Google SSO are confirmed automatically.

A new email address awaiting confirmation (change-email flow). null when no change is pending.

Whether the account has a password credential set. false for accounts created via Google SSO or Telegram that have never set a password — the UI can show "Set password" instead of "Change password" and skip asking for the current password.

Indicates whether private messages should be copied to Telegram

The player's physical main hand (Left/Right). A profile label only — it does not move ratings between axes. null means never set (treated as Right, soft "please confirm" prompt) or a tournament guest (no profile hand) — matching the sibling player DTOs.

Declared gender, null = not specified. Once set it is read-only (409 GenderAlreadySet).

Contact phone (owner only). Pre-filled once from the Telegram-verified phone; the client also offers it as the default phone at tournament registration.

Whether is passed to managers of tournaments the player registers for.

Whether is shown to other authenticated players on the player card.

Country of residence, ISO 3166-1 alpha-2.

City of residence.

Whether the residence country/city are shown to everyone.

Country of birth, ISO 3166-1 alpha-2.

City of birth.

Whether the birth country/city are shown to everyone.

Declared birth year.

Whether the birth year is shown to everyone.

Whether the Telegram username is shown to other authenticated players.

Whether the RTTF link is shown to everyone on the player card.

Whether are shown to everyone.

Links to the player's profiles in other rating systems, in display order. null means "not loaded by this endpoint" (e.g. the login payload) — fetch GET /Players/profile before editing them.

RTTF user id

RTTF username

Whether the displayed name follows the linked RTTF profile (vs. the account name). Only takes effect once is true — see GetDisplayName.

RTTF profile confirmation

City cached from the RTTF profile, or null.

Birth year cached from the RTTF profile, or null.

Player who created the still-unconfirmed RTTF link (history once the link is confirmed).

Secret code the owner posts on rttf.ru to confirm the link. Present ONLY on the owner's own profile response (never for other viewers) — see the includeConfirmationCode constructor flag.

Latest location (longitude and latitude)

Latest mobile application version

Language code provided by Telegram

User-defined language override. Null means not set (Telegram language is used).

List of chats with user's activity

Player's rating

Related images: the avatar shown (the uploaded photo, else the provider avatar), at most one

Whether the avatar is a photo the player uploaded (it can be removed), not one synced from Telegram/Google

The size and avatar centre of the photo the player uploaded. null without a photo, and for a photo stored before its size was kept (only before the photo focus came out). The full photo is {avatarPath}/full.

The profile as a non-owner who may manage the player's RTTF link (an organizer, the link's creator) gets it: only the identity, hand, images and RTTF link id/name/state — no contacts, login data, places, birth year (the roster shows the RTTF city/born under its own minor rule), settings or roles. The Roles invariant (Docs/Auth/roles.md) does not apply: roles are deliberately withheld here.

The target player (hands and images loaded).

Player profile info

The player to expose. When true, exposes the RTTF block (id, name, confirmed, and — if — city/born). Only the detailed player card sets this; search/top rows and messages must NOT show RTTF data. When true, additionally exposes the RTTF id, name, city and birth year (PII). Callers MUST pass true only when the viewer is the profile owner or an admin — the card is public, so an arbitrary (even authenticated) viewer must not see another player's PII. The id alone is also exposed when the player opted in (). Current UTC year from the injected , used to decide whether a minor's birth year must be hidden (§7). Null skips the check for the RTTF year, and hides the declared year from others. When true, the caller is the player themselves or an admin: every profile field is exposed regardless of the player's visibility flags, and a minor's birth year stays visible. Whether the request is authenticated. The Telegram username and the contact phone are never exposed to an anonymous viewer, and to an authenticated one only when the player allows it (, ). When true, exposes the "about" facts (places, birth year, gender, other ratings, contact phone) the player made public. Only the detailed player card sets this. The player's rating on the RTTF scale (converted back from the TTAR main-hand rating), exposed together with only. The player's other-rating links (card only); ignored unless they are public or the viewer is self/admin. Whether the viewer blocked this player. Either block flag hides the contacts (Telegram, phone). Whether this player blocked the viewer.

Player profile info

Displayed name

Indicates whether the player is a Telegram user

Username in Telegram. null for an anonymous viewer, and for others unless the player shows it.

Indicates whether the player allows private messages in Telegram

The date and time of the player's last token activity

Avatar URL

Set of a player hand ratings (e.g. rating for Main hand, or for Weak hand)

The player's physical main hand (Left/Right). Only a profile label — the client derives the "left hand" badge from it plus the rating axis. null when never set (treated as Right) or for a tournament guest (no profile, no hand).

Whether the player has a linked RTTF profile (RTTF block only). The bare fact is safe for any viewer; the concrete is gated to the owner / admins unless the player made it public, and the rest of the RTTF PII always is.

RTTF profile id (a link to the external profile); owner / admins, or everyone when the player shows it.

Rating on the RTTF scale, converted back from the TTAR main-hand rating (rttf.ru is not polled). Exposed only alongside .

RTTF display name (full "Фамилия Имя Отчество") — PII, owner / admins only. The visible name a viewer needs is already in (GetDisplayName picks the RTTF name when the player opted in), so gating this raw field does not affect what an ordinary viewer sees.

Whether the RTTF link was confirmed by the player (vs. created by an organizer).

City cached from the RTTF profile (RTTF block, PII, owner / admins only), or null.

Birth year cached from the RTTF profile (RTTF block, PII, owner / admins only), or null. (The minor check in (§7) is now subsumed by that gate but kept for defence.)

Country of residence (ISO 3166-1 alpha-2), if the player shows the residence place (card only).

City of residence, if the player shows the residence place (card only).

Country of birth (ISO 3166-1 alpha-2), if the player shows the birth place (card only).

City of birth, if the player shows the birth place (card only).

Declared birth year, if the player shows it (card only). A minor's year is hidden from others even then (§7); without a known current year it is hidden from others too.

Contact phone (card only): for the owner / admins, and for an authenticated viewer when the player shows it to players and is not a minor. null for an anonymous viewer.

Whether the viewer blocked this player (then the viewer does not write to them and sees no contacts).

Whether this player blocked the viewer: the viewer's messages and mentions do not reach them.

Declared gender, if specified (card only). Public by design: "not specified" is how a player hides it.

Links to the player's profiles in other rating systems, if the player shows them (card only).

Amount of games played between this player and an opponent, broken down by hand. Populated only when an opponent is known (the authenticated caller, or an explicitly requested opponent); null otherwise.

Extracts avatar image: the uploaded photo, else the provider avatar

List of player's images Avatar URL or null

Private message

The message. The viewer's block relations, for the sender's block flags; null = none.

Private message

The message. The viewer's block relations, for the sender's block flags; null = none.

Private message id

Sender id

Sender's profile info

The message content; empty for a message a moderator deleted ().

Deleted by a moderator: the thread and the conversation preview show "Message deleted by a moderator".

The message's sent date

Indicates whether the message was read by recipient

Latest message in the list

Represents a paginated response containing private messages, pagination details, and participant information

The collection of private messages included in the current page The pagination details for the current page, including total pages and current page number The participant associated with the private messages in this response

Represents a paginated response containing private messages, pagination details, and participant information

The collection of private messages included in the current page

The pagination details for the current page, including total pages and current page number

The participant associated with the private messages in this response

Represents a response containing the rating history

Gets or sets the list of rating points representing the rating history

Paged list of collection

Collection of players Page details

Paged list of collection

Collection of players Page details

Collection of players

Page details

Search player results

The search hit. Why the caller's confirmation request would not reach this player, if it would not. Whether the search is authenticated (gates the Telegram username). The caller's block relations, for the block flags (contacts hidden across a block); null = none.

Search player results

Player profile info

Distance to the player

Why the caller's game confirmation request would not reach this player; null when it would (or when the request is anonymous — there is no caller to be relative to).

Paged list of collection

Collection of chats Page details

Paged list of collection

Collection of chats Page details

Collection of chats

Page details

The public pages of the web app worth indexing besides its static sections. The site builds the addresses (/tt/tournaments/{id}, /tt/venues/{id}) and their language versions itself.

Tournaments in registration, running or finished, invite-only ones included, ascending by id. Not listed: drafts (unpublished) and cancelled ones (dead pages).

Every venue (club), ascending by id.

Maps the sitemap to the response.

A page of the sitemap. An object rather than a bare id, so that a field (e.g. the last change) can be added without breaking the client.

Id of the tournament or venue.

Represents top players

A collection of players with their ratings and deltas, ordered by rating and amount of games Available top positions of target player Current page with actual information

Represents top players

A collection of players with their ratings and deltas, ordered by rating and amount of games Available top positions of target player Current page with actual information

A collection of players with their ratings and deltas, ordered by rating and amount of games

Available top positions of target player

Current page with actual information

Initializes a new instance of the class using the specified top-level data

The top-level data containing player positions, page information, and hand details

Initializes a new instance of the class using the specified top active data

The top active data containing player information and ratings

Represents top players

A collection of players with their ratings, ordered by rating and amount of games Available top positions of target player Current page with actual information

Represents top players

A collection of players with their ratings, ordered by rating and amount of games Available top positions of target player Current page with actual information

A collection of players with their ratings, ordered by rating and amount of games

Available top positions of target player

Current page with actual information

Initializes a new instance of the class using the specified top-level data

The top-level data containing player positions, page information, and hand details

Represents the top position in a ranking, including the position number, associated hand, optional rating delta and optional games played for desired period of time

The position number in the ranking, where a lower number indicates a higher rank The player's hand associated with this position The change in rating associated with this position, or if no change is applicable The number of games played within the selected period (chat-scoped when filtered), or for the all-time top where no period applies

Represents the top position in a ranking, including the position number, associated hand, optional rating delta and optional games played for desired period of time

The position number in the ranking, where a lower number indicates a higher rank

The player's hand associated with this position

The change in rating associated with this position, or if no change is applicable

The number of games played within the selected period (chat-scoped when filtered), or for the all-time top where no period applies

Privacy rules for the RTTF PII we cache and re-expose. Shared by the response DTOs so the participant list and the player card apply the same gate. See Docs/privacy-policy-code-followups.md and privacy policy §7.

Age of majority. A player younger than this is a minor whose birth year is hidden from other users (§7). Computed from the birth YEAR only (day/month are not stored), so a player counts as an adult for the whole calendar year in which they turn 18 — the safe direction for a border case.

Whether belongs to a minor as of . Null year is treated as not-a-minor (nothing to hide). must come from the injected , never DateTime.UtcNow.

Whether a minor's birth year must be suppressed for this viewer: hidden from everyone EXCEPT the player themselves (and admins). Adults' birth years are never suppressed by this rule.

Request to link an RTTF profile to a player. The link is created unconfirmed; the player then proves ownership by posting the returned confirmation code on rttf.ru.

The RTTF profile id to link. Must be a positive number.

A scraped RTTF profile preview shown before linking (organizer dialog).

RTTF profile id.

Full name (ФИО) from RTTF.

Main-hand RTTF rating, or null when the profile has no rating yet.

City from RTTF, or null.

Birth year from RTTF, or null.

Maps a scraped external profile to the preview response.

Request to add a co-organizer to a tournament (or update the finish right of an existing one — idempotent).

Player id to make a co-organizer. Must be an existing, non-guest player other than the organizer.

Whether the co-organizer may finish the tournament. Defaults to false.

Request to add a one-off tournament guest: a profile-less, name-only participant the organizer runs the tournament with (rated as a normal newcomer). See .

Guest's display name (required).

Guest's playing hand.

Optional seed rating (100–3000) used only for seeding — a guest has no established rating, so this lets the organizer place them by real strength. Null falls back to the newcomer default.

Request to call a pair to a table. On a recall (match already Called) the table may be omitted to keep the current table.

Table number to call the pair to (1–50). Optional only when recalling a match already on a table.

Request to replace the format of a RUNNING tournament (PUT /tournaments/{id}/format): the same pair the start request carries, without the tables. What of it may differ from the current format is told by TournamentResponse.FormatEditScope; a locked part that differs is refused with 409 FormatLocked.

The engine type of the new format (as at start). Required.

The new battle schema. When null, defaults are derived from ; when its own Type is empty, is used. Validated against the actual participant count.

Request to check that the bot can post into a topic of a chat before the tournament form is saved.

Internal chat id, as .

The topic id, as (the General topic is 1).

Request to confirm tournament participation using the one-time token from an invitation email.

The token embedded in the confirmation deep-link.

One co-organizer entry accepted inline in the create / update tournament form — the same tuple as ({ PlayerId, CanFinish }).

Player id to make a co-organizer. Must be an existing, non-guest player other than the organizer.

Whether the co-organizer may finish the tournament. Defaults to false.

A tournament co-organizer: a player who runs the tournament alongside the organizer, with an optional right to finish it.

Co-organizer player ID.

Display name of the co-organizer.

Whether this co-organizer may finish the tournament (register games + recalculate rating).

Maps a co-organizer model to a response.

The co-organizer to map (its Player should be loaded for the display name).

Request to create a new native tournament

Tournament name.

Optional description of the tournament.

Tournament format type. Optional since v4 — the format may be decided at start ("decide at start"). When a is supplied its type is used for the reference calculation; the binding format is fixed at start.

Reference schema (the plan) chosen at creation: used only by the calculator ("how long will this take with N players and T tables"). Never published to the announcement and may be null. The binding schema is chosen at start.

ConsolationMixed only: the number of trailing pre-final upper rounds that follow long rules (their losers feed the connected lower bracket toward the 3rd-place match). Ignored for other formats (forced to null on create). Clamped to a valid range against the actual field size at start.

Whether the tournament is completed in a single day.

Number of sets per match (1–7).

Scheduled start date. Send an ISO-8601 value with the organizer's offset (e.g. "2026-07-24T11:00:00+04:00"); the instant is stored as UTC and the offset is kept so the local time can be shown in Telegram announcements.

Registration deadline.

Free-text venue address. The place when no structured is linked — changing it later then resets participant confirmations; under a venue it is only an annotation.

Optional link to a structured venue (a hall). When set, the tournament's address, point and distance are taken from the venue; the free-text stays as a fallback. Re-linking to another venue later resets participant confirmations.

Telegram chat ID linked to the tournament: one the caller is active in (GET players/chats/{id}), unless an admin (403 ChatLinkForbidden).

Where the bot posts the announcement and results in : null or 0 — by the chat's settings (the topic the bot posts the chat's games into: pinned by an admin or auto-picked); any other value — the tournament's own topic, a Telegram topic id taken from a message link (the General topic is 1). Games are registered and confirmed by the chat's settings either way. The server checks the bot can post into the own topic (400 AnnounceTopicUnavailable). Ignored without a chat; never changes the chat's settings.

Repost the announcement once this many chat messages followed it; null — no reposts. A repost is silent, replaces the previous announcement and happens only while registration is open.

Also repost the announcement this many hours after it was posted, provided someone wrote after it; null — no time trigger. Read only together with .

Who may join: Open (default — anyone self-registers) or Invite (closed — the organizer builds the roster, self-registration is refused). Invite forces the rating window off (MinRating/MaxRating/OnlyRated cleared).

Minimum player rating required to participate.

Maximum player rating allowed to participate.

Restrict participation to rated players only.

Restrict participation to members of the linked chat only.

Minimum number of participants (2–255).

Maximum number of participants (2–255).

Optional note: participation cost and other conditions. Not a critical field — never resets confirmations; blank is stored as null.

Controls who is allowed to submit match results.

Whether the server auto-calls the next ready pair onto a freed table (and pushes "you're called to table N"). null (field omitted) means the server default of true; the organizer can flip it live via PUT /tournaments/{id}.

Score string assigned for walkovers, e.g. "11:0".

Optional initial co-organizer roster set straight from the form (so the client need not send N separate POST .../co-organizers calls after create). Each element is validated as in the CRUD endpoint (existing non-guest player other than the organizer, no duplicates, at most 5); an invalid element fails the whole create with a 400 and no tournament is persisted. Each assignee is notified. Null or empty means "no co-organizers".

Ladder rules, read only when is Ladder (null — the defaults). A ladder takes its sets from (1–5) and gets no plan, schedule or auto-call; its result mode is Players, which an ordinary tournament may not use.

The tournament whose settings fill this form (the "create the same" button), for analytics only — the copy is not linked to it. The hint never fails the create: null, 0 or a negative value mean no source, and an id of no existing tournament is silently stored as null. The client fills the form from GET /tournaments/{id} itself.

Result of editing an already-completed match's score. Carries the updated match plus the downstream impact of the edit, so the client can surface the right message (a warning when the change no longer affects the tournament, or a note that the queue was rebuilt).

The updated match with its corrected score.

The downstream effect of the edit. — pure correction; — winner flipped but the tournament had already moved on, so nothing was replayed ( is set); — winner flipped and the still-queued bracket/queue was rebuilt for the correct winner/loser.

Whether the corrected result no longer affects the tournament (the downstream was already finalized): true only for . The client shows .

A human-readable warning when the edit does not affect the tournament outcome, else null. The client may localize its own message from instead.

Maps the service result to a response.

When a guest of the tournament may still be linked to a TTAR profile (requested or merged): until the finish and 7 more days. The server's rule — the client shows it as is.

Whether a link request or a merge is possible now. False for a cancelled tournament and a ladder.

The last moment (UTC) of a finished tournament's window — the end of the 7th day after the finish day, in the organizer's time zone. Null while the tournament is not finished (open until the finish).

Maps the window rule.

A player as the guest-link screens show them: name, avatar, rating, games, registration date.

Player id.

Display name.

Relative path to the avatar photo, or null.

Rating of the main hand (1000 when the player has never played).

Games on both hands.

When the profile was registered (UTC) — "профиль создан вчера".

No games and no rated hand (an imported rating counts as rated): would take the guest's games and rating ("новый профиль").

Maps a player loaded with hands and images.

Hints for the organizer that a player is the guest.

The name looks like the guest's (a shared word or its first four letters, in either script).

The profile was registered after the tournament (its finish, else its start).

A player's request "this guest is me".

Request id.

The guest's participant id.

The requester.

Pending, Approved, Rejected, Withdrawn, Superseded (the guest went to someone else) or Expired.

When it was sent (UTC).

When it was decided (UTC), or null while Pending.

Hints for the organizer that the requester is the guest; both false in the requester's own copy.

Maps a request loaded with its player (hands, images). The signals need the tournament and the guest's name; without them they stay false.

The trace of a guest merged into the participant's player — kept on the participant for good.

The guest's name ("ранее — временный «…»").

When the guest was merged (UTC).

Replace — the player took the guest's seat before its games were rated; Transfer — the player had no games and took the guest's games and rating; Append — the games joined the player's history without a recalculation.

The organizer's own pick, or an approved request.

Transfer only: the guest's rating before its games (the 1000 start).

Transfer only: the guest's rating after its games — the player's at the merge.

The trace of a participant, or null when it was no linked guest.

What merging the guest into one player would do — one calculation for the organizer's and the player's sheets.

The mode the merge would take now (see ).

Append only: HasGames — the player has games of their own; ImportedRating — none, but an imported rating.

Transfer only: the guest's rating before its games.

Transfer only: the guest's rating now — the player's after the merge.

Transfer only: − .

Matches the guest played in the tournament (walkovers excluded).

Of , won by the guest.

Of , lost by the guest.

The guest's final place, or null before the finish.

The player's rating by the hand the guest played.

The player's games on both hands.

Transfer only, while the guest is not qualified: its qualification points (of ).

The qualification points that make a hand qualified.

Maps the service preview.

A player the organizer may merge the guest into.

The player.

Same as ; kept for compatibility.

An active participant of the tournament — shown disabled ("уже участник этого турнира").

Hints that the player is the guest.

Maps a service candidate.

Body of POST /tournaments/{id}/participants/{participantId}/link.

The player to merge the guest into.

The player's Pending request this merge approves, if any.

The rules of a ladder tournament, set on create and replaced as a whole by PUT /tournaments/{id} (before the start only). The number of sets is the tournament's setsInMatch (1–5 for a ladder; every set is played).

At 10:10 a set goes on until one side leads by two; false — the 11th point decides.

A draw on sets (an even setsInMatch only) is settled for the table move by one extra point that is not recorded — the game is rated as a draw; false — both keep their tables. Stored as false for an odd number of sets.

Only an even roster at the start: a player without a pair waits in the waitlist (pair: true) until the next one signs up; an odd maxParticipants leaves its last seat empty. Once the ladder runs the rule is over: players join and leave one by one, and whoever waited for a pair is seated at the start.

The games still unconfirmed this many days after the finish count automatically (1 or 3); null — they expire like ordinary games, the ordinary confirmation timeout after the finish.

The ladder starts by itself at its start time — the same switch as PUT …/ladder/auto-start. Null leaves it as it is (on create — off), so a client that does not send the field never turns it off.

How the client seats the draw at the tables (a view choice; the draw is never reordered). Null leaves it as it is (on create — Rating). A running ladder changes it by PATCH …/ladder.

The rules and timeline of a ladder tournament.

At 10:10 a set goes on until one side leads by two; false — the 11th point decides.

A draw on sets is settled for the table move by one extra, unrecorded point (even setsInMatch only).

Only an even roster until the start; players waiting for a pair carry pair: true in the waitlist.

Days after the finish when the unconfirmed games count automatically (1 or 3), or null — never.

When the ladder started (UTC), or null before the start.

When the ladder was finished (UTC), or null while it has not.

+ : when the games still waiting since the finish count automatically, or null.

How the finish registers the games for rating (chosen by the organizer at the finish); null before it.

The ladder starts by itself at its start time (set by PUT …/ladder/auto-start or the form's ladder.autoStart). Either way, it is closed 12 hours after its scheduled start: cancelled if not started, finished if running.

The table draw: participant ids of the confirmed roster, in random order (pairs by two, the first pair at table 1). Drawn once — when the registration deadline comes while the ladder is still in Registration, otherwise at the start — and never changed after (not by the start, nor by ); so it may already be there in Registration. Null before it and for ladders started before the draw existed. Confirmed participants missing from it came in later; an id in it may be of a participant no longer active. A view hint only — it affects no game or rating.

How the client seats at the tables: by rating, in the draw's random order, or freely switched.

The ladder part of a tournament, or null for an ordinary tournament.

A game recorded in a ladder — the score of one match, or of several at once: one participant records it, the other confirms or rejects it.

Ladder game id.

The participant who recorded the game.

The participant who confirms or rejects it.

Sets won by the recorder.

Sets won by the opponent.

When the game was recorded (UTC).

Pending, Confirmed, Rejected, AutoConfirmed or Expired (a finished ladder without auto-confirm: its game was not decided within the ordinary confirmation timeout; it never counts). A game confirmed while the ladder runs goes to the rating at the finish (see ladderPairs); one still Pending then waits as an ordinary game () and follows it.

Why the opponent rejected it; null unless Rejected.

When it was confirmed, rejected, auto-confirmed or expired (UTC); null while Pending.

The game the record was registered with at the finish (the "game history" row): its own (Each), or one shared with the records it was summed with (Total) — the pair's game of its confirmed records, or the game of all the author's waiting records against this opponent. Null before the finish.

The recorder's rating change from ; null until it is rated.

The opponent's rating change from ; null until it is rated.

Maps a ladder game.

Two participants of a ladder with any record against each other. Computed by the server, so the client never works out the registration itself.

The participant with the lower id.

The participant with the higher id.

The pair's score on sets, participant 1's side: the sum of its confirmed games.

The pair's score on sets, participant 2's side.

The pair's games still waiting for a decision. After the finish they wait as ordinary games and are decided as such.

The pair went to the rating — once, at the finish: its confirmed games were rated, those still waiting became games waiting for confirmation ().

Participant 1's rating change from the pair's rated games; null when none was rated.

Participant 2's rating change from the pair's rated games; null when none was rated.

The pairs of a ladder, in the order of their first record.

The records of a ladder for its card in the tournament list.

All recorded games (rejected ones included).

Games in the rating (after the finish; ladders that ran before rated each game on confirmation). A reverted one does not count.

Confirmed records: games confirmed or auto-confirmed.

Records waiting for a decision: Pending games.

Waiting records the caller is to decide ("ждут вас") while the ladder runs; 0 for anonymous callers and after the finish, when they wait as ordinary games (GET /games/unconfirmed).

The caller's games, rejected and expired ones excluded ("ваших игр: N"); 0 for anonymous callers.

The summary of a ladder, or null for an ordinary tournament.

Records a ladder game of the caller against another participant: the score of one match or — a free score — of several at once.

The opponent — an active participant of this ladder other than the caller.

Sets the caller won.

Sets the opponent won. By the rules the two add up to the ladder's setsInMatch (a multiple of it for several matches), but a score off the rules is accepted too; at least one set in total.

Records several ladder games of the caller at once.

The games, each against its opponent; several against one opponent are allowed.

What a write of ladder records produced.

The Pending games recorded.

Rejects a ladder game.

Why: not played, a different score, a duplicate.

The auto-confirm period of a ladder, changed after the start.

Days after the finish when the unconfirmed games count automatically (1 or 3); null — never.

Turns a ladder's auto-start on or off.

True — the ladder starts by itself at its start time; false — only the organizer starts it.

How to finish a ladder.

Days after the finish when the unconfirmed games count automatically (1 or 3); null — never.

How the games go to the rating: Total (one game per pair with their sum, the default) or Each (as entered).

The game rules of a running ladder; a null field stays as it is.

Sets in a game, 1–5. The recorded games are not touched; new ones are checked against it.

At 10:10 a set goes on until one side leads by two; false — the 11th point decides.

A draw on sets is settled by one extra point (an even number of sets only; stored false otherwise).

How the client seats the draw at the tables. The draw itself is not reshuffled.

Outcome of signing up for a ladder.

In the roster, or (even-only ladder) waiting in the waitlist for a pair.

The caller's participant row when is Participant.

The caller's waitlist entry (pair: true) when is WaitingPair.

The player who waited for a pair and got into the roster together with the caller, or null.

Who saving the edit form with a lower limit would move from the roster to the waitlist (GET /tournaments/{id}/limit-cut) — computed by the same rule the save applies.

Active participants minus the seats the new limit leaves; 0 when the edit would move nobody.

The participants to be moved, in the order they would queue up. Fewer than when only tournament guests are left to cut — guests are never moved.

Request to move a called match to another table. If the target table hosts another live match the two matches swap tables.

Target table number (1–50).

Tournament participant info

Participant record ID.

ID of the tournament this participant belongs to.

Player ID.

Display name of the player.

Player's playing hand.

Seeding number, if assigned.

Organizer-set seed rating (used only for seeding), or null to use the live rating.

Whether the player confirmed participation. Self-registered players are confirmed on sign-up; players added manually by the organizer must confirm before they take part.

Organizer's "entry fee received" mark (no cashier in TTAR — no amounts). Public: everyone who sees the roster sees it. Shown by the client only for tournaments that actually charge a fee.

Date and time when the participant registered.

Whether the participant is still active: not removed, not declined, and has not left the running ladder. An inactive row ( / ) stays in participants so the ladder games it played in keep their names; the roster shows only active ones.

When the invited player declined the invitation (closed tournaments), or null. Only ever populated on rows in TournamentResponse.DeclinedParticipants (a manager-only list). Drives the "Отказался · 10 июля" line.

Ladder: when the player left the running ladder themselves while having games in it (they may sign up again), or null.

When the organizer took the participant off the roster (they cannot rejoin on their own), or null. In a running ladder the games played stay, like after a disqualification.

Net TTAR change over the tournament (by the played hand), snapshotted at finish. Null before finish; 0 for a no-show. A frozen snapshot — a later score edit does not recompute it for anyone but the two players of the edited game. The finish table shows "до → после Δ" from the current hand rating and this delta.

Final place (1-based), snapshotted at finish per the bracket/standings rule. Null before finish. Frozen — not recomputed by a later score edit. Drives the finish page's podium and standings order.

Relative path to the player's avatar photo, or null (no photo / a guest). Rendered as the round avatar.

Rating stats for the registered hand. Null when hand data is not loaded.

The player's physical main hand (Left/Right), so the client can render the "left hand" badge next to the participant from + this side. Null when never set (treated as Right) or for a guest.

True when the participant is a one-off tournament guest (no TTAR profile, no login). Guests start at 1000 TTAR and their games are scored by qualification rules.

Whether the player has a linked RTTF profile. The bare "a link exists" fact is exposed to everyone; the RTTF details (id + name/city/born) are gated on confirmation and the caller's relationship — see .

RTTF profile id — gated like the rest of the RTTF PII (confirmed participant, privileged caller).

RTTF display name, if the player has a linked profile.

City cached from the RTTF profile, or null.

Birth year cached from the RTTF profile, or null.

Whether the RTTF link was confirmed by the player (vs. created by an organizer).

Phone for the organizers: present only for a manager (or the participant themselves) and only when the player registered on their own — the phone typed in at registration, else the profile phone they share with organizers.

Set when this row was a tournament guest merged into : who the guest was and how the merge went ("ранее — временный «…»"). Public; null for any other row.

Maps a participant model to a response.

The participant to map. Whether the caller may see this tournament's RTTF details — pass true only for a privileged caller (organizer / co-organizer or a confirmed participant of the same tournament). It ANDs with the row's own confirmation: an unconfirmed participant's RTTF details are withheld from everyone, including the organizer. Current UTC year from the injected , used to hide a minor's birth year from other users (§7). Null skips the minor check. The authenticated caller's player id (0 when anonymous); a row belonging to the caller is "self". Whether the caller is an admin; admins keep seeing a minor's birth year like self. Whether the caller manages the tournament (organizer / co-organizer / admin) and may see participants' phones.

One tournament a player took part in, for the "player tournaments" surface (summary on the player card and the full player-tournaments page). Two kinds: — a tournament in our system (place, size, match balance, rank, rating delta; navigates to the tournament page) — and — imported from an open source (name, link, dates and rating delta only; no place/opponents). The whole entry counts toward ONE rating axis (); a tournament played on both axes is delivered as two entries.

Which kind of tournament this is (Own = in our system, External = imported).

Own-tournament id in our system (drives navigation). 0 for external.

Tournament name.

Date the tournament was held (UTC).

Rating axis the tournament counted toward (a hand, not a physical side).

Rating change credited for this tournament, on . Null while an Own tournament is still live (no result yet); present for external (the gain credited on import).

Own only: the player was merged in from a tournament guest after the guest's games were rated, and the player had a rating of their own — is the guest's and did not move the player's rating (shown as "без пересчёта"). False when the player also played rated games after the merge (a multi-day tournament, a league): is then those games' alone.

Own-tournament status: Active while running (no rank yet) or Finished.

Final placement (1-based) among ; null while live.

Number of participants (the final tournament size, not a bracket/group). 0 for external.

Venue / place text (Own only).

Match wins of the player in this Own tournament. Null for external.

Match losses of the player in this Own tournament. Null for external.

Source URL (External only), opened in a new tab.

When the external result was imported into our system (External only).

Maps a repository projection to the response.

Kind of a player-tournament entry.

A tournament in our "Tournaments" section.

Imported from an open external source (RTTF, etc.).

Coarse status of an Own player-tournament entry (finer states collapse into these two).

Still running — no final place yet.

Concluded — has a final place and rating delta.

Request to move a waiting player into the tournament roster (organizer / co-organizer / admin).

Add the player even when the roster is already full (the organizer confirmed the over-the-limit warning). False refuses a full roster with 409 ParticipantLimitReached.

Request to register a participant in a tournament

Player's playing hand.

Optional phone for the organizers of THIS tournament (digits, '+', '-', spaces, brackets). Omit it to let them see the profile phone when the player shares it with organizers. Never published in the profile.

Also save to the profile and turn on passing it to organizers of later tournaments. Ignored without a phone.

Result of DELETE .../participants/{id} when the caller declined their own invitation to a closed tournament. A plain removal returns 204 with no body; this body is returned only for the decline branch so the client can show the "Отказались" group without a second fetch.

True when the row moved to the declined list (invited player declined), rather than being removed.

Request to change a co-organizer's finish right.

The new finish right for the co-organizer.

Request to set a participant's "entry fee received" mark (organizer/co-organizer/admin). There is no cashier in TTAR — this is a public bookkeeping mark only, no amounts are charged or reconciled.

Whether the entry fee is marked as received.

Request to set a participant's seeding rating (organizer/admin, before start). Used only for group split / bracket placement — it never affects the rating delta. Null clears the override (falls back to live rating).

Seed rating (100–3000), or null to clear the override.

Request to set (or clear) the organizer's finish recap on a finished tournament. An empty or whitespace-only clears the recap.

The recap text (2–3 paragraphs, blank-line separated), or empty/null to clear it.

Request to change the sets-to-win of one stage of a running tournament. Applies to that stage's unplayed matches only — matches already completed, forfeited or awaiting score confirmation keep their value.

Which stage to change: Groups (grouped formats' group stage), Bracket (the knockout / final stage of a grouped or flat bracket format), or Single (the round-robin stage of RoundRobin / RoundRobin2 / League). Rejected with 400 when the tournament's format does not have that stage.

New sets-to-win for the stage (1–5, best-of = 2*SetsToWin-1).

Request to change the number of tables of a running tournament.

New number of tables (1–50). Growing always succeeds; shrinking is rejected when it would drop below the number of tables currently in use — free the extra tables first. Live pairs sitting above the new count are renumbered down onto the freed low tables.

Request to start a tournament

Number of tables available for the tournament (1–50). Ignored for asynchronous formats (League), where there is no shared table pool — any valid value is accepted.

Final tournament format, chosen at start. Required — the binding format must be decided before the schedule can be generated.

Final battle schema fixed for this tournament. When null, defaults are derived from . When its own Type is empty, is used. The schema is validated against the actual participant count on start.

Auto-call state to start the tournament with. null keeps the tournament's saved value; a non-null value overwrites it before the schedule is generated (so the immediate table-fill honors it).

Request to submit match score

Score of participant 1.

Score of participant 2.

Request to calculate tournament duration and table recommendations

Number of participants (2–255).

Number of tables available.

Number of sets per match (1–7).

Tournament format type.

Target tournament duration in minutes for table recommendation

Per-stage breakdown line in a calculator response.

Stable stage key (groups / bracket / rr / final).

Human-readable stage label.

Optional note.

Number of matches in the stage.

Sets-to-win used in the stage.

Number of sequential rounds in the stage.

Tables actually usable in parallel for this stage.

Estimated stage duration in minutes.

Advisory warning line in a calculator response. Text-free: the client localizes by , interpolating in code-specific order.

Severity: info / warn.

Stable warning code (the client renders the localized text per code).

Values to interpolate into the localized text, in code-specific order (stringified).

Tournament duration and table recommendations. The four legacy aggregates are kept; v4 adds the per-stage breakdown, per-player match bounds, projected finish, table cap, warnings and a readable summary (ТЗ §5.1).

Total number of matches in the tournament.

Estimated total duration in minutes.

Average wait time between matches per player, in minutes.

Recommended number of tables to reach the target duration. Null for async formats.

Minimum matches a single player will play.

Maximum matches a single player will play.

Projected finish time, when a start time was supplied.

Maximum tables that can ever be used in parallel across stages.

Per-stage breakdown.

Advisory warnings.

Readable one-line schema summary.

Maps a legacy flat estimate to a response (the four aggregates only).

Maps a full schema estimate to a response.

Request body for the schema-based calculator (POST /tournaments/calculator). Carries the nested so the server can reproduce the client's calcSchema preview exactly.

Number of participants (2–255).

Number of tables available (1–50).

Target tournament duration in minutes for the table recommendation.

The configurable schema to estimate. When null, a default RoundRobin schema is used.

Optional start time; when set, the response includes a projected finish time.

The tournament as an event of the caller's calendar (GET /tournaments/{id}/calendar): the card the client shows and the ready links. The same event as a file is GET /tournaments/{id}/calendar.ics.

Event UID, tour-{tournamentId}-{playerId}@ttar.app: re-adding the event replaces it.

The tournament's data version — the .ics SEQUENCE. Grows on any change, not only of the time.

Event title — the tournament name.

Start (UTC).

End (UTC): start plus .

Minutes east of UTC the organizer entered the start in (as TournamentResponse.startDateUtcOffsetMinutes), for showing the club's wall-clock time; null when unknown.

IANA time zone of the linked venue; null when no venue is linked or it has no zone.

Event length: the calculated duration rounded up to 30 minutes, or 120 when it can't be calculated.

True when comes from the schema calculator, false for the default.

Localized basis of the duration with its prefix, e.g. "estimated: Round robin, players: up to 8, tables: 2".

Venue name; null without a linked venue.

Venue address line, else the tournament's free-text place; null when the place is not known.

Place name and address in one line (the event's LOCATION); null when the place is not known.

Latitude of the linked venue (WGS 84), for a precise place in the device calendar (iOS EKStructuredLocation); null without a linked venue or its point. The .ics carries it as GEO.

Longitude of the linked venue (WGS 84); null whenever is.

Localized event description; lines are separated by \n.

Short link to the tournament's web page.

that opens the "add to calendar" step (?cal=1) — the QR code target.

Google Calendar "add event" link.

Outlook.com "add event" link.

Maps the built calendar event.

Tournament match info

Match record ID.

Tournament this match belongs to.

Participant 1 ID, or null if the slot is empty (bracket slot pending, or a bye's empty side).

Player record ID of participant 1, or null if the slot is empty.

Display name of participant 1, or empty if the slot is empty.

Relative path to participant 1 avatar, or null if not set.

Participant 2 ID, or null if the slot is empty (bracket slot pending, or a bye's empty side).

Player record ID of participant 2, or null if the slot is empty.

Display name of participant 2, or empty if the slot is empty.

Relative path to participant 2 avatar, or null if not set.

Round number, if applicable.

1-based group number for a group-stage match, or null for non-group matches (bracket / final / ungrouped formats). Decoded from the group-stage tag; use it to bucket matches into per-group protocols on the client.

1-based round (tour) number WITHIN the group for a group-stage match, or null for non-group matches. Decoded from the group-stage tag (which is stored encoded/negative); use it to order matches by tour inside a group's protocol without decoding on the client.

Which sub-bracket this match belongs to (upper / lower / third-place / final).

The place this match awards its winner (place-fixing matches), or null.

Bracket link: the next-round match the WINNER advances to, or null (final / non-bracket).

Which slot of the winner fills (1 or 2), or null.

Consolation link: the lower-bracket match the LOSER drops into, or null.

Which slot of the loser fills (1 or 2), or null.

Table number the match is played on.

Current match status.

Sets-to-win for this match (best-of = 2*SetsToWin-1), snapshotted at generation from the tournament schema by stage — group matches carry the groups value, bracket / final matches the bracket value. Prefer this over the tournament-level SetsInMatch when rendering a match. Null only for matches generated before per-match sets existed; fall back to the tournament's SetsInMatch in that case.

Score of participant 1.

Score of participant 2.

Whether the result was recorded as a walkover.

ID of the walkover winner, if applicable.

Linked game record ID, if applicable.

Participant 1's rating BEFORE this match, from the linked game's snapshot. Null for a walkover / a match not yet registered as a rated game. The finish page shows "after = before + delta"; delta is .

Participant 1's rating change from this match (signed: win > 0, loss < 0), from the linked game. Null for a walkover / an unregistered match. A no-show contributes 0 via the walkover path (no game).

Participant 2's rating BEFORE this match (see ).

Participant 2's rating change from this match (see ).

Participant 1's figures belong to a guest since merged into this player without recalculation: the match did not move the player's rating (show "без пересчёта"), and its score can no longer be corrected.

Participant 2's side, see .

Participant ID of the player who submitted the score. Null until score is submitted.

When the current score was submitted (two-player confirm mode). The opponent's confirmation window runs from here; re-submitting a score moves this forward and restarts the window. Null until a score is submitted.

Deadline for the opponent to confirm a submitted score before it is auto-confirmed ( + 5 min). Only set for a match awaiting confirmation (InProgress); null otherwise. The client shows the countdown from here; the value moves whenever the score is re-submitted.

True when the result was auto-confirmed by the confirmation-timeout timer rather than by the opponent or an organizer (the opponent went silent). Lets the UI badge the result as auto-accepted.

Scheduled start time of the match.

When players were called to the table.

When the match was confirmed as started.

When the match ended (before score submission).

Number of times players were called.

Date and time the result was confirmed.

For an OPEN match in an Active tournament being finished early: whether its outcome can still change some final place. Only set for the bracket family (where "affects" is crisp — the match still reaches a place-awarding node); null for round-robin matches and for any match with no verdict (the client then shows no "affects places / place decided" badge). Populated at the tournament level, not by the per-match which lacks the bracket graph.

True when this is a group-stage match whose result is carried over into a round-robin final (the pair was not replayed in the final; the group result counts toward the final standings directly). Populated at the tournament level by the GetMatches endpoint; false by default on the per-match path which lacks the schema context.

Maps a match model to a response.

Reads the linked game's per-hand rating snapshot and aligns it to the two participant slots by PlayerId (the game's hand order is independent of the match's slot order). Returns all-null when there is no rated game (walkover, or a one-day match not yet registered at finish). Requires the game's PlayerHands loaded.

The fully computed state of a tournament's tables and waiting queue at the moment of the request: which live match sits on each table, which pair is recommended for each free table, and the ordered call queue. The order IS the call priority (the shared fairness ranking — group balance, then matches-played, then rest) — clients render it as-is and must not re-sort. Built server-side by so the queue is a single, unambiguous invariant shared across all organizers and clients, and identical to the order the bot auto-calls pairs in.

Revision counter of the tournament at the moment this snapshot was built (see ). The same value comes back from GET /tournaments/{id} and rides the SignalR signal, letting the client keep matches and queue as one consistent state.

Total number of tables (capacity), as set by set-tables-count. The list can be LONGER than this if a live match sits on a table number above the current capacity (possible right after a shrink) — such a table is still shown.

State of each physical table, in table-number order (1..N).

Ordered queue of waiting pairs (Scheduled, both sides drawn), in fairness order: least-COMPLETE group first by progress (load/size, so uneven groups stay interleaved), then fewest matches played by the pair, then longest rested. is a display flag, NOT the sort key — a pair blocked by a busy player keeps its fair position (marked not ready) rather than sinking to the bottom. The client renders it as-is and does NOT re-sort.

Builds the queue snapshot from a fully-loaded tournament (participants + matches). Delegates the ordering to so the on-screen queue matches the bot's call order exactly (the shared fairness ranking). feeds the rest-time key; it cancels out between any two pairs, so a ticking clock never reorders the rendered list.

State of one physical table: the live match on it (if any) and the recommended next pair.

1-based table number.

Match currently on the table (Called / Active / InProgress), or null when the table is free.

Which pair to call onto this table if it is free. Populated ONLY when is null AND a ready pair is available; otherwise null.

One row of the waiting queue: a Scheduled pair, its readiness, and who blocks it if not ready.

The waiting match.

True when both participants are idle (not in a live match) and the pair can be called now.

When is false — this pair's participant(s) currently busy in another live match. Empty when the pair is ready. The client shows "waiting: {name}".

A participant of a queued pair who is currently busy elsewhere, blocking the pair's call.

Participant id that is busy in another live match.

Display name of the busy participant.

Compact match slice for the queue / table board — only the fields a queue row needs to render. Mirrors the relevant subset of (names, weak-hand tags, group/round context).

Match record id.

Current match status.

Table number the match is on, or null while queued.

Round number (may be a negative group-stage tag), or null.

1-based group number for a group-stage match, or null for non-group matches.

1-based round (tour) within the group for a group-stage match, or null otherwise.

Number of times the pair has been called to a table (recall counter for the UI).

Participant 1 id, or null if the slot is empty.

Display name of participant 1, or empty if the slot is empty.

Relative path to participant 1 avatar, or null if not set.

True when participant 1 is registered on their weak (left) hand — a tag in the UI.

Participant 2 id, or null if the slot is empty.

Display name of participant 2, or empty if the slot is empty.

Relative path to participant 2 avatar, or null if not set.

True when participant 2 is registered on their weak (left) hand — a tag in the UI.

Maps a match model to a compact queue entry (mirrors TournamentMatchResponse.From conventions).

Brief info about the current player's nearest upcoming match in an active tournament.

Match ID.

Current match status.

Table number the match is assigned to, if any.

Display name of the opponent, or empty if not yet determined.

Opponent participant ID, or null if the opponent is not yet determined (bracket slot pending).

Whether the caller submitted this match's score and waits for the opponent ("ждёт соперника" instead of "Подтвердите счёт"). Always false unless is InProgress.

Full tournament info

Tournament ID.

Tournament name.

Optional description.

Current tournament status.

Tournament format type. Null until the format is chosen (v4 "decide at start").

Reference plan (calculator-only schema chosen at creation). Null when not set.

Final battle schema fixed at start; drives schedule rendering. Null before start.

ConsolationMixed only: number of trailing pre-final upper rounds following long rules. Null otherwise.

Whether the tournament is completed in a single day.

Number of sets per match.

Scheduled start date (UTC).

Minutes east of UTC the organizer entered in (e.g. +240 for GMT+4), or null when the offset is unknown. Lets clients render the organizer's local start time even without the organizer's time zone (matching what Telegram announcements show).

Registration deadline.

Free-text venue address (fallback when no structured venue is linked).

Linked structured venue id, or null.

Linked venue's display name, if a venue is linked.

Telegram chat ID linked to the tournament.

Display name of the linked chat, if any.

Public link or invite link of the linked chat, if any.

Where the announcement and results go: null — by the chat's settings; a value — the tournament's own topic (General is 1).

The announcement is reposted after this many chat messages; null — no reposts.

…or this many hours after it was posted, if someone wrote after it; null — no time trigger.

Approximate distance from the provided geo coordinates to this tournament's location, in meters, rounded to GeoSearchPrecisionInMeters. Null when no geo was supplied or the tournament has no known location.

Organizer player ID.

Display name of the organizer.

Who may join: Open (anyone self-registers) or Invite (closed — the organizer builds the roster, self- registration is refused with 403 InviteOnlyTournament). Invite forces the rating window off.

Minimum player rating required to participate.

Maximum player rating allowed to participate.

Only rated players can participate.

Only members of the linked chat can participate.

Minimum number of participants.

Maximum number of participants.

Optional note: participation cost and other conditions; null when not set.

Organizer's free-text summary of a finished tournament (2–3 paragraphs, blank-line separated). Null when not written. Editable by the organizer / co-organizers via PATCH .../recap while the tournament is Finished.

Controls who is allowed to submit match results.

When true, participants may submit a match score without the pair being called to a table first (async formats such as League). The UI uses this to offer out-of-turn score entry.

Number of tables used in the tournament.

When true, a freed table automatically calls the next ready pair onto it; when false, the organizer calls the next pair manually. Editable via PUT /tournaments/{id} (autoCallEnabled); turning it on immediately fills the free tables.

Score string assigned for walkovers.

Date and time the tournament was created.

Date and time of the last update.

When the tournament's results were published (it was moved to Finished). Null until finished. The finish page shows "Итоги опубликованы …" from it; unlike a later edit does not change it.

Monotonically increasing revision counter for this tournament, bumped on every change that affects the tables/queue state (call, move, unassign, score, set-tables-count, registration/withdrawal). The same value is returned by GET /tournaments/{id}/queue and carried in the SignalR signal, so a client can treat matches and queue as one consistent snapshot and drop stale refreshes.

True when the tournament is Active with open matches remaining, yet the top-three podium is already mathematically decided — so it may be finished EARLY (the same rule POST /finish enforces). The client uses this to turn the finish button green and show the "podium decided" note without re-deriving the rule; false whenever there are no open matches (a normal finish) or the podium is still contestable. See .

How much of a RUNNING tournament's format PUT /tournaments/{id}/format may still replace, decided by what has been played: Full — nothing played, the whole format; SecondStage — group matches played, the finals only; None — second-stage (or single-stage) matches played, only the sets-to-win of unplayed matches. Pairs merely called to a table lock nothing. None whenever the tournament is not Active (before start the plan is edited through PUT /tournaments/{id}). See Docs/Tournaments/format-change.md.

Co-organizers running the tournament alongside the organizer, each with its own finish right. Empty when the organizer runs it alone. The organizer () is never listed here.

List of registered participants (active roster: excludes removed and declined players).

Players who declined an invitation to a closed tournament ("Отказались" block). MANAGER-ONLY: populated only when the caller is the organizer / a co-organizer / an admin; empty for everyone else. Not in the active roster (no counts, seeding or limit). Each carries its DeclinedAt. See CHANGE_closed_tournaments.

Players waiting for a seat ("Запас" block), in queue order. PUBLIC — everyone who sees the tournament sees who waits. Not in the active roster (no counts, seeding or limit). Emptied when the tournament starts, is cancelled or becomes closed. goes to managers (and the player) only. See CHANGE_waitlist.

The caller's 1-based place in , or null when they are not in it (or anonymous).

When a guest of this tournament may still be linked to a TTAR profile: until the finish and 7 more days. See Docs/Tournaments/guest-link.md.

Players' "this guest is me" requests, any status, oldest first: all of them for the organizer (or an admin) — co-organizers do not decide guest links — and only the caller's own for anyone else.

List of tournament matches. Always empty for a ladder (see ).

The ladder's rules and timeline; null for an ordinary tournament.

A ladder's recorded games, newest first; empty for an ordinary tournament.

A ladder's pairs (two participants with any record against each other): their score, what still waits and their registration for rating. Empty for an ordinary tournament.

The live table board + call queue, folded into this response when the caller passed includeQueue=true (an Active tournament only). Null when not requested, or requested for a non-Active tournament. Same shape as GET /tournaments/{id}/queue, so a client that receives it here can skip that extra round-trip.

The current/final standings, folded into this response when the caller passed includeStandings=true (Active / Finished / cancelled-with-matches only). Null when not requested, or requested for a status that has no standings. Same shape as GET /tournaments/{id}/standings, so the client can skip that round-trip.

Maps a tournament model to a full response.

The tournament to map. Distance-blurring precision in meters. Whether the caller may see participant RTTF PII (a manager or a confirmed participant of this tournament). Pass false for outside viewers and anonymous callers — it ANDs with each row's own confirmation. Current UTC year (from the injected TimeProvider), used to hide a minor's birth year from others (§7). Null skips the check. Authenticated caller's player id (0 when anonymous); their own participant row keeps its birth year. Whether the caller is an admin (admins keep seeing a minor's birth year). Optional pre-computed queue snapshot to fold into the response (see ). The endpoint gates it by status/flag and computes it from this same loaded model. Optional pre-computed standings to fold into the response (see ). Gated and computed by the endpoint from this same loaded model. Raw distance (meters) to use instead of m.DistanceMeters. The detail endpoint caches the tournament graph WITHOUT a geo point (shared across callers), so it must not write distance onto the shared model — it passes the per-caller distance here instead. Null falls back to the model's own value. Whether the caller is a manager (organizer / co-organizer / admin). Gates the manager-only list — false leaves it empty. Others must never see who declined. Also gates the participants' . The current UTC time (from the injected TimeProvider) for ; null — the system clock.

Blurs a raw distance (meters, computed in MySQL by the repository) down to the configured precision so the exact venue location is never leaked. Shared by both response shapes. Returns null when no distance is available. A non-positive precision is treated as 1 so a misconfiguration cannot divide by zero.

Summary tournament info for list endpoints

Tournament ID.

Tournament name.

Current tournament status.

Tournament format type. Null until the format is chosen (v4 "decide at start").

Access mode: Open or Invite (closed). Drives the lock badge next to the status on the card.

Whether the tournament is completed in a single day.

Scheduled start date (UTC).

Minutes east of UTC the organizer entered in, or null when unknown. Lets clients render the organizer's local start time even without the organizer's time zone.

Free-text venue address.

Display name of the linked chat, if any.

Public link or invite link of the linked chat, if any.

Organizer player ID.

Display name of the organizer.

Number of active participants.

Whether the tournament ever had at least one participant, counting those later removed. Lets clients reliably hide truly empty Cancelled tournaments without guessing from ParticipantCount (which excludes removed participants and so reads 0 for a tournament that was cancelled after everyone left).

Whether the current authenticated player is registered in this tournament. Null for anonymous requests.

Whether the tournament waits for the caller to confirm participation ("Подтвердите участие" instead of "Вы участвуете"): an invitation, or a confirmation reset after the date/place/fee changed. Counted in the tournaments menu badge by the same rule. False for anonymous requests and for the organizer.

Whether the current authenticated player is a co-organizer of this tournament (drives the "you are a co-organizer" list badge). Null for anonymous requests.

Number of co-organizers of this tournament (0 when the organizer runs it alone).

Number of players waiting for a seat ("запас N"). Not included in .

The caller's 1-based place in the waitlist ("В запасе · 3-й"), or null when they are not in it (or anonymous).

Nearest upcoming match for the current player in this active tournament. Non-null only when Status=Active and AmIRegistered=true.

Minimum player rating required to participate. Null when the tournament is open.

Maximum player rating allowed to participate. Null when the tournament is open.

Maximum number of participants (the registration cap), or null when uncapped.

Date and time the tournament was created.

A ladder's games for the card ("N игр · в рейтинге M · ждут K", "ждут вас"); null for an ordinary tournament.

Pending guest-link requests waiting for the caller as the organizer ("N заявки на привязку"); 0 for anyone else. The same requests the tournaments menu badge counts.

Matches of an active (non-ladder) tournament whose submitted score awaits confirmation, for the caller as the organizer or a co-organizer ("На подтверждении N матчей" on the card); 0 for anyone else.

Maps a tournament model to a list item.

Paginated list of tournaments

Tournament list items for the current page.

Pagination metadata.

A single row of the tournament standings table. The standings endpoint returns a FLAT list with EXACTLY ONE entry per player — render it directly as the "положение в турнире" table, no deduping or bucketing needed. is the player's overall tournament place and only says how it was decided (Bracket for a knockout, Single for round-robin/league, Groups for a grouped tournament that is still in its group phase). is always null here (the flat table is never split by group).

Maps a tournament standing entry from the core library to an API response model.

How this player's place was decided, purely informational for the client: for a knockout / consolation (place read off the bracket), for round-robin / league (ranked by points), and for a grouped tournament that is STILL in its group phase (the bracket has not been generated yet, so the table is the current group-play snapshot). It never changes the "one row per player" shape.

Always null. The standings table is a single flat list and is never bucketed by group; the field is kept for backward compatibility of the response shape.

The player's overall tournament place (1-based).

Player record ID.

Display name of the player.

Relative path to the player's avatar image, or null if not set.

Number of matches won (excluding walkovers), across every stage the player took part in.

Number of matches lost (excluding walkovers), across every stage the player took part in.

Total sets won, across all completed matches.

Total sets lost, across all completed matches (mirrors ).

DEPRECATED. Balls-in-set are not stored, so this is always 0. Kept only to preserve the response contract during the deprecation window (the field is still required in swagger); it will be removed once the generated client no longer expects it. Do not read it — the standings tie-break no longer uses balls.

DEPRECATED. Always 0 (see ); slated for removal after the client is regenerated.

Number of walkover wins (counted in tournament standings, not Elo). A walkover with no set score still counts toward .

ITTF match points across all stages: win = 2, played loss = 1, walkover loss = 0 — the "Очки" column. For a bracket the place is decided by structure, not by these points, but they are still filled so the column is not blank.

A tournament template: named create-form settings, personal or shared by a club.

Template ID.

The template's own name (the tournament name is data.name).

Personal — only the author sees it; Club — the owner and representatives of .

The club of a club template; null for a personal one.

Name of ; null for a personal template.

Player ID of whoever created the template.

The author's display name (login if none).

Which create form the template fills.

How many times the template was applied to the create form.

When the template was created (UTC).

When the template was last edited (UTC); the list is ordered by it, newest first.

The saved create-form settings, already normalized for and .

Saves the create form as a new template.

The template's name, 2–100 characters.

Personal (default) or Club; fixed for the template's lifetime.

Required for a club template: a venue the caller owns or represents. The template is then always held there (data.venueId is forced to it, data.placeAddress cleared).

Which create form the template fills; Standard by default.

The create-form settings; fields that do not apply to are dropped on save.

Renames a template and/or replaces its settings; omitted fields stay. The scope never changes (copy instead).

New name, 2–100 characters; null keeps the current one.

New create-form kind; null keeps it. Changing it alone also reshapes the stored settings.

Replaces the whole settings object.

Request to change a participant's rating hand (organizer/admin, before start).

Rating hand to use for the participant.

Request to update a tournament (only allowed before start)

New tournament name.

New description of the tournament.

New tournament status.

New access mode (open / invite). Only settable before start (Draft/Registration) — 409 on Active/Finished. Setting Invite drops the rating window. Not a critical field — never resets participant confirmations. Null leaves it unchanged. See CHANGE_closed_tournaments.

New number of sets per match (1–7).

New scheduled start date. Critical field — changing it resets participant confirmations. Send an ISO-8601 value with the organizer's offset (e.g. "2026-07-24T11:00:00+04:00"); the instant is stored as UTC and the offset is kept so the local time can be shown in Telegram announcements.

New registration deadline.

New free-text venue address; an empty string clears it. The place when no structured is linked — then a change resets participant confirmations; under a venue it is only an annotation.

New structured-venue link. A positive value links (or re-links) the tournament to that venue; a value of 0 clears the link (back to the free-text fallback); null leaves it unchanged. Re-linking to another venue resets participant confirmations; linking one to an address, or clearing the link while the address stays, does not.

New minimum player rating required to participate.

New maximum player rating allowed to participate.

Restrict participation to rated players only.

Restrict participation to members of the linked chat only.

New minimum number of participants (2–255).

New maximum number of participants (2–255).

Optional note: participation cost and other conditions. Not a critical field — never resets confirmations. Null leaves it unchanged; "" (or blank) clears it.

New result input mode controlling who submits match scores.

New auto-call state: whether the server automatically calls the next ready pair onto a freed table (and pushes "you're called to table N"). Null leaves it unchanged. Turning it on immediately fills any free tables. Not a critical field — never resets participant confirmations.

New announce channel (internal Chats.Id): a positive value links (or re-links) the tournament to that chat; 0 unlinks; null leaves it unchanged. Not a critical field — never resets participant confirmations. A new chat, or a new own topic in the linked one, must be a chat the caller is active in, unless an admin (403 ChatLinkForbidden).

Where the announcement and results go: 0 — back to the chat's settings, any other value — the tournament's own topic (a Telegram topic id; the General topic is 1); null leaves it unchanged, but a change resets it to the chat's settings. The server checks the bot can post into the own topic (400 AnnounceTopicUnavailable); a moved topic re-posts the announcement there. Not a critical field.

Repost the announcement after this many chat messages: 0 turns reposts off, null leaves it unchanged.

Also repost after this many hours: 0 drops the time trigger, null leaves it unchanged.

New walkover score string, e.g. "11:0".

New reference plan (calculator-only schema, edited in Draft). Null leaves the stored plan unchanged. Not a critical field — editing it never resets participant confirmations.

Desired co-organizer roster (replace-semantics): null leaves the roster untouched (backward compatible), a list drives the roster to exactly that state — assign the newcomers, remove the ones no longer listed, flip on the rest. Same validation and cap (5) as the CRUD endpoint; an invalid element fails the whole edit with a 400 and the roster is not touched. Allowed on Draft / Registration / Active. Not a critical field — never resets participant confirmations.

Ladder rules (replace-semantics: all four at once; autoStart null — unchanged). Null leaves them unchanged. Before the start only; the auto-confirm period of a running or finished ladder changes via PUT .../ladder/auto-confirm. Refused (400 TournamentTypeMismatch) for an ordinary tournament.

A player waiting for a seat in a full tournament ("запас"). Not a participant: not counted in the limit, the roster or seeding. The queue is public — everyone who sees the tournament sees who waits and in what order.

1-based place in the queue (order of joining).

Player ID.

Display name of the player.

The rating hand the player chose when joining; the participant gets it on promotion.

When the player joined the queue (UTC). Kept when the player re-joins to change the hand.

Relative path to the player's avatar photo, or null.

Rating stats for the chosen hand. Null when hand data is not loaded or the player has no such hand yet.

The player's physical main hand (Left/Right), for the "left hand" badge. Null when never set.

Phone for the organizers: present only for a manager (or the player themselves) — the phone typed in when joining, else the profile phone the player shares.

Even-only ladder: the player waits for a pair, not for a seat — the roster has room, and they get in together with the next player who signs up. False in a full tournament's queue and everywhere else.

Maps the whole queue in order, numbering the positions.

The tournament's waitlist (with Player, Hands and Images loaded for full rows). The authenticated caller's player id (0 when anonymous); their own row carries their phone. Whether the caller manages the tournament and may see every phone. Even-only ladder: the free seats of the roster — the entries ahead of them wait for a pair. Null otherwise.

Maps one queue entry at a known position.

An optional edit value where 0 clears the setting and anything else must lie in [, ]. Null (unchanged) is valid.

Lowest allowed non-zero value (inclusive).

Highest allowed value (inclusive).

Request to create a venue. Only and a location (a point or a place) are required.

Venue name (required).

Short name for tight strings.

Latitude of the venue's point. Required together with unless a place is given.

Longitude of the venue's point.

Human-readable place as one line ("city, street"), an alternative to a point.

Opening hours (7 pipe-separated day strings, Mon..Sun; empty segment = closed).

Phone number.

Telegram handle/link.

Web site.

Free-text description.

Number of identical tables the venue lets (pool capacity).

Hourly price; null keeps the venue in the directory with booking off.

Non-bookable remainder (0..tablesCount−1).

Whether bookings auto-confirm (default true).

IANA time zone of the venue.

When true, also submits an ownership/representation claim in the same step.

Claim role (owner / representative), used only when is true.

Optional contact for moderation, used only when is true.

The map card the fields were taken from (source of POST /places/parse), if any.

A venue the caller owns or represents, for the "my venues" strip: the card fields of plus what awaits the caller's decision there. The pending counts of all the caller's venues add up to the clubs menu badge (GET /me/badges).

Venue ID.

Venue name.

Short name, if any.

Human-readable place as one line ("city, street").

Number of tables (pool capacity).

Hourly price, or null when booking is off.

Whether online booking is available (owner + price + pool mode).

True when the caller owns the venue; false when they represent it.

Whether the caller may top up a player's wallet here (same as ).

Other players' Requested bookings not over yet: the rows of GET /venues/{venueId}/venue-bookings marked "awaits decision" for the caller. The caller's own booking is not counted.

Pending representative requests (GET /venues/{venueId}/representative-claims); always 0 for a representative.

Maps a managed venue; is the caller's right, computed by the service.

Request to edit a venue. Every field is optional; a null field is left unchanged. Owner/verification and the claim are set through their own endpoints, not here.

New name.

New short name.

New latitude (send together with to move the point).

New longitude.

New place line ("city, street").

New opening hours.

New phone.

New Telegram handle/link.

New web site.

New description.

New table count (pool capacity).

New hourly price; send 0 or a value to enable booking, or omit to leave unchanged.

New non-bookable remainder (0..tablesCount−1).

New auto-confirm toggle.

New IANA time zone.

A venue announcement (info notice or a closing notice tied to an interval).

Announcement ID.

Info or Closed.

Title.

Body text, if any.

Start of the affected interval (UTC), for a closing announcement.

End of the affected interval (UTC), for a closing announcement.

Author player ID, if known.

Whether this announcement blocks bookings.

Whether the announcement is pinned.

Creation timestamp.

Maps an announcement model to its response DTO.

Per-hour availability for a venue over a requested date, in the venue's time zone (each slot's is the UTC start of a 1-hour slot).

Venue ID.

The requested calendar date (venue-local).

Total tables in the pool.

Non-bookable remainder kept for walk-ins.

Per-hour slots.

Availability of one 1-hour slot: capacity, free, blocked, booked (DATA_API §1 poolAt).

Slot start (UTC).

Bookable capacity that hour (tablesCount − blocked − reservedRemainder).

Free bookable tables that hour (capacity − booked).

Tables removed by tournaments and owner blocks that hour.

Tables taken by player bookings that hour.

Maps a calculator slot to its response DTO.

A player booking (a pool seat, or several via a group). Reservations and blocks are not exposed here.

Booking ID.

Venue ID.

Specific table id, or null for a pool seat (the usual case).

Number of tables this booking occupies.

Group id when several tables were booked in one action; null otherwise.

Start (UTC).

End (UTC).

Booking player ID.

Booking lifecycle status.

Amount held for this booking.

Creation timestamp.

Venue name. Populated only by the cross-venue "my bookings" endpoint; null on venue-scoped responses.

Venue short name, when set. Populated only by the cross-venue "my bookings" endpoint.

The booking player. Populated only by the venue console (GET /venues/{venueId}/venue-bookings); null on the other responses, where the caller is the booker.

Maps a booking model to its response DTO.

Like but also copies the loaded venue's name/short name — for the cross-venue "my bookings" endpoint, whose rows span venues and must show which venue each belongs to.

Like but also maps the loaded player (hands and images included) — for the venue console, whose rows are other players' bookings.

Request to resolve a venue claim. On a reject, is required (one of the fixed set: not_verified · no_contact · owner_confirmed · venue_closed · other); owner_confirmed is valid only for a venue that has an owner, and other requires a non-empty .

True to approve (transfer ownership + verify), false to reject.

Fixed-set reject reason. Required on a reject; ignored on approve.

Message shown to the claimant (a draft the moderator may edit). Required for the "other" reason.

Optional moderator note added to the claim's internal history on this decision.

Request to append a moderator note to a claim.

The note text (required).

The moderation queue: pending claims grouped by venue, venues ordered by their freshest claim.

One group per venue that has at least one claim in the requested status.

Projects the repository-level groups to the response shape.

One venue's group in the moderation queue: a compact venue header plus its claims (newest first).

Venue id.

Venue name.

Short name, if any.

Place ("city, street").

Phone.

Import source (!= null ⇒ the "Import" chip applies).

Current owner player id (!= null ⇒ this is a dispute over a live owner).

Current owner display name (the "current owner" line of a dispute), if any.

Player who added the venue to the directory (creating is not owning); null for an imported venue.

Display name of , if any.

The venue's claims in the requested status, newest first.

Projects a repository group to the response.

One claim in the moderation queue: the claim plus the claimant's mini-profile and folded note info.

Claim id.

The venue this claim is on.

Owner / representative.

Free-text contact the claimant left, if any.

When the claim was filed.

True when the claimant is also the venue's creator (the "venue creator" pill).

Claimant player id.

Claimant display name.

Claimant Telegram nick, if any.

Claimant TTAR rating (main hand), if rated.

Claimant games played (main hand).

When the claimant joined TTAR (the "in TTAR since …" line).

Claimant avatar path, if any.

The most recent moderator note on the claim, for the list's "last note" line.

Total moderator notes on the claim.

Projects a repository claim (with claimant loaded) to the response.

One moderator note (append-only history). Internal — never returned to the claimant.

Note id.

Author player id.

Author display name.

When the note was written.

Note text.

Projects a note (with author loaded) to the response.

Maps a to the HTTP-facing , status and default detail. Kept out of the controllers so both VenuesController and BookingsController map identically.

Maps a service business error to its HTTP-facing error code, default detail message and status code.

The service error to translate. The error code, a human-readable detail, and the HTTP status.

A venue representative as shown publicly on the venue page (the venue's contacts in TTAR).

Representative player id.

Display name.

Avatar path, if any.

Projects a representative row; the name/avatar need its player loaded.

A venue representative as the owner manages it: the public item plus the extra rights.

Extra rights granted by the owner (empty = base management rights only).

When the player became a representative.

Projects a representative row (player loaded).

A pending request to become a representative, as the venue's owner sees it: the request plus the claimant's mini-profile. Moderator notes are never part of it.

Claim id.

The venue the request is on.

Free-text contact the claimant left, if any.

When the request was filed.

Claimant player id.

Claimant display name.

Claimant Telegram nick, if any.

Claimant TTAR rating (main hand), if rated.

Claimant games played (main hand).

When the claimant joined TTAR.

Claimant avatar path, if any.

Projects a claim with its claimant (hands + images) loaded.

Request to add a representative to a venue (owner only).

The player to add.

Extra rights to grant (empty = base management rights only).

Request to replace a representative's extra rights (owner only).

The full new set of extra rights (empty = revoke all).

The owner's decision on a request to become a representative.

True to add the claimant as a representative, false to decline.

Optional message to the claimant.

Maps the stored permission bitmask to the wire shape (a list of single members) and back.

The set members of , excluding None.

The bitmask of a wire list (null/empty = None).

Request to claim ownership/representation of a venue (SCREENS §5).

Owner or representative.

Optional contact for moderation.

Request to create a booking of a pool seat (or several) over an interval (DATA_API §4).

Interval start (UTC), on the whole-hour grid.

Interval end (UTC), exclusive, on the whole-hour grid.

Number of tables to book (≥ 1). The limit is the minimum free across the whole window.

Request to credit a player's venue balance (venue admin only).

The player to credit.

Amount to add (positive).

Optional client-generated idempotency key. When supplied, a retry / double-submit with the same key credits the balance at most once. Omit for a plain (non-idempotent) top-up.

Request to close an interval for booking (owner block / отпуск-ремонт), DATA_API §4.

Interval start (UTC), whole-hour grid.

Interval end (UTC), whole-hour grid.

Reason; goes into the closing announcement when is set.

Whether to also publish a closing announcement for this interval.

Request to publish a venue announcement (DATA_API §4).

Info or Closed. A closing announcement also lays down a booking block for its interval.

Title (required).

Body text.

Interval start (UTC) for a closing announcement.

Interval end (UTC) for a closing announcement.

Whether to pin this announcement to the top of the venue page.

Request to link a chat to the venue (§8.1).

Internal chat id (Chats.Id), not the Telegram chat id.

Optional forum topic id within the chat.

What the current caller may do on a venue, as decided by the service (never re-derived client-side).

Full venue info for the venue page.

Venue ID.

Venue name (the only mandatory text field).

Short name for tight strings, if any.

Latitude of the venue's point, if a point is set.

Longitude of the venue's point, if a point is set.

Human-readable place as one line ("city, street").

Opening hours (7 pipe-separated day strings, Mon..Sun; empty segment = closed).

Phone number.

Telegram handle/link.

Web site.

Free-text description.

Owner player ID, or null for an ownerless venue.

Owner display name, if the venue has an owner.

Owner avatar path, if any.

Players who run the venue on the owner's behalf — public contacts in TTAR, oldest first.

True when the current caller may manage the venue (owner, representative or admin).

True when the current caller may credit players' wallets here.

Player who added the venue (creating is not owning), if known.

True once an ownership claim is approved.

Import source (e.g. "OpenStreetMap"), shown as a "not verified" badge. Null for community venues.

Number of identical tables the venue lets (pool capacity).

Hourly price, or null when booking is off.

Non-bookable remainder kept as a walk-in guarantee.

Whether bookings auto-confirm; false means each booking waits for the venue's decision.

Rent mode (pool by default; per-table is not served by the API yet).

Whether booking is currently available (owner + price + pool mode).

IANA time zone of the venue, if set.

Linked chat internal ID (not the Telegram chat id), if any.

Linked chat display name, if any.

Optional forum topic id within the linked chat.

Whether the chat link awaits confirmation.

The CURRENT CALLER's own claim status on this venue: null = no claim of theirs; Pending ⇒ show the "your claim is on review" pill and hide "I'm the owner" / "dispute". Other players' claims are never shown.

Approximate distance from the provided geo coordinates to the venue, in meters, rounded to GeoSearchPrecisionInMeters. Null when no geo was supplied or the venue has no known location.

Venue tables, when requested/loaded.

Venue announcements, when requested/loaded.

Creation timestamp.

Last update timestamp.

Maps a loaded venue to its response DTO. blurs the exposed distance, supplies a per-caller distance computed on top of a shared model, is the CURRENT caller's own claim status on this venue and what that caller may do (null = nothing). Owner and representative names/avatars are filled only when those players were loaded with the venue.

The map card a venue was filled from — as returned by POST /places/parse and passed back unchanged to POST /venues. Stored but never returned: no response reveals that a venue was filled from a map.

Map service.

The place's id within the provider (normalized by the server).

Link to the card.

Paginated list of venues.

Venue list items for the current page.

Pagination metadata.

The point the list is ordered from (nearest first), or null when it is ordered by name.

Where the venue list is ordered from.

The coordinates the client sent.

The client's IP, located to a city: the client sent no coordinates. Venue distances are then not returned.

The point the venue list is ordered from.

Where the point comes from.

Latitude.

Longitude.

ISO 3166-1 alpha-2 country of an point; null for a device one.

Compact venue card for the directory list.

Venue ID.

Venue name.

Short name, if any.

Human-readable place as one line ("city, street").

Latitude, if a point is set.

Longitude, if a point is set.

Number of tables (pool capacity).

Hourly price, or null when booking is off.

Owner player ID, or null for an ownerless venue.

Whether booking is currently available.

True once an ownership claim is approved.

Import source, if imported.

Blurred distance in meters, or null.

Whether online booking is available (owner + price + pool mode). Semantic alias of — the "book strip" and map badge read this (DATA_API §5, booking as a distinct flag).

Opening hours (7 pipe-separated day strings, Mon..Sun; empty segment = closed), for the "Open now" pill/filter.

IANA time zone of the venue, needed to evaluate opening hours / the next-slot window client-side.

Nearest bookable slot with a free table no earlier than the travel window (freeFrom = now + travel buffer). Null when the venue is not bookable, or no free slot remains until end of the working day.

Maps a venue model to a compact list item, blurring distance to .

The nearest bookable slot with a free table for a venue's "book strip" (DATA_API §5). Computed server-side in the venue's time zone; the hour is returned in UTC.

UTC start of the one-hour slot.

Free tables in that slot (same grid as availability: bookings + tournaments + blocks − reservedRemainder).

True when the slot is inside freeFrom..freeTo (green "free from HH:mm" strip); false when it is a later fallback slot (amber).

A single venue table (number + optional name/type/price).

Table ID.

Stable table number within the venue.

Optional display name.

Optional table type.

Per-table hourly price (per-table mode only; null in pool).

Maps a table model to its response DTO.

A player's per-venue wallet: the folded balance plus the append-only journal.

Venue ID.

Player ID.

Total balance (ΣTopUp − ΣCapture).

Amount currently held under bookings.

Amount available to book (Total − Held).

The journal, oldest first.

Builds the wallet response from the folded balance and the journal entries.

A single append-only wallet journal entry.

Entry ID.

Entry kind (TopUp / Hold / Capture / Release).

Amount (always positive; the kind gives the direction).

Human-readable note.

Booking id / group id this entry refers to, if any.

Creation timestamp.

Maps a wallet entry model to its response DTO.

Interactive IdP login page for the OpenID Connect authorize flow. On success it establishes the cookie session (with the same PlayerId/Name/Email claims the API reads) and returns to the original authorize request.

Email entered on the login form.

Password entered on the login form.

The original authorize URL to return to after a successful sign-in.

Validation/authentication error shown on the form, if any.

Renders the empty login form.

Validates the credentials, establishes the IdP cookie session and returns to the authorize request.

Normalizes every crossing the API boundary to UTC, upholding the project-wide invariant that the database always stores UTC. On read: a value carrying an offset (e.g. "2026-07-24T20:00:00+03:00") is converted to UTC; a naive value (no offset) is assumed to already be UTC rather than reinterpreted in the server's local time zone. Either way the result is a flat . Without this, deserializing an offset into a plain DateTime yields a server-timezone-dependent value, which then fails to compare equal to the UTC value stored in the DB (breaking, among other things, the tournament critical-field change check). On write: the value (which comes from the DB as ) is emitted with an explicit "Z" suffix so clients receive an unambiguous UTC timestamp.

Nullable counterpart of .

Tags every log entry of a request with the TTAR app and version from the / headers, so a failure can be traced to a stale web build or an old app release. Scopes reach the console only with Logging:Console:FormatterOptions:IncludeScopes.

Runs the rest of the pipeline inside the client scope (or without one when the client sent neither header).

Admin page "Поддержка проекта": support payments entered by hand (Boosty does not report them) and the anonymous counters of the "Expenses and support" page. Only the running month (UTC) takes new payments or deletions; a closed one stays as it is. A write is seen at once by the menu banner and the page.

The payments and the sums of a month; null for a month after the running one.

Adds a payment to the running month.

Soft-deletes a payment of the running month.

The page counters of [, ]: the days (or months) with any, in order; the client fills the gaps with zeros.

Why an admin write was refused.

The amount is not in (0, 99 999.99] or has fractions of a cent.

The month is not the running one.

No such payment in the month (or it is deleted already).

The outcome of an admin write: the response, or why it was refused.

A refused write.

Fits Donations.Amount, decimal(10, 2), with room to spare (DONATE.md §6).

Project expenses and the players' support, month by month, from the earliest fixed month up to the running one. A closed month keeps the expenses fixed for it; one closed without them gets the configured fixed on the first read after it. Every method returns null while the section is switched off.

The running month (the menu banner).

The running month, the running year and the whole history (the coverage scales).

The months of (the running one by default) within the history; empty for a year outside it.

Every year of the history.

The payment methods of the support sheet offered in the caller's country, and that country: of (0 for a guest), else of .

Counts an event of the support page in today's (UTC) anonymous counters.

false (nothing counted) while the section is switched off.

Drops the cached ledger: the next read sees the payments just added or deleted.

Every month of the history in order; the last one is the running month.

Service responsible for registering games and handling game registration logic.

Registers a batch of games for a player.

The ID of the player registering the games. List of new game requests. Cancellation token. List of game batch entity responses.

Groups game requests by chat for batch processing.

List of new game requests. Dictionary of player hands. Current list of results to exclude already processed games. List of grouped game requests.

Filters out game requests that are considered cheating or invalid.

List of new game requests. Dictionary of player hands. List of game batch entity responses for cheaters or invalid requests.

Resolves and retrieves player hands for all requests.

List of new game requests. Cancellation token. Dictionary of player hand pairs to hand models.

Registers a single game request.

The new game request. Player 1 hand model. Player 2 hand model. The ID of the player registering the game. Cancellation token. Tuple containing the game response and registration status.

Validates a game request for cheating or invalid data.

The new game request. Player 1 hand model. Player 2 hand model. Game registration status if invalid, otherwise null.

API-only read cache in front of for the /top endpoints. Caches the caller-independent, fully-ordered top list (one entry per scope + include flags) under a short TTL to absorb the open-the-top-page burst, then applies the per-caller target-player positions and paging on top. Geo-filtered requests (location + distance) bypass the cache and read fresh via SQL so the geodesic filter stays byte-identical to the current behavior. Mirrors the method shapes the controller already used, so the controller swaps the repository for this service with no other change. The Telegram bot keeps reading fresh straight from the repository — this service is not on its path.

Global/geo full top. When + are set the read bypasses the cache (fresh SQL geo filter); otherwise it is served from the cached list.

Chat-scoped (or global when is null) full top, served from the cached list.

Active top over the last , served from the cached list.

Chat selection list ordered by proximity. The expensive per-chat total-games aggregate is cached; the caller's per-chat game counts and the geodesic distances are read fresh and merged per request.

Service responsible for registering games and handling game registration logic.

Registers a batch of games for a player.

The ID of the player registering the games. List of new game requests. Cancellation token. List of game batch entity responses.

Forwards users' requests for a new interface language to the admin (Telegram and email). Nothing is stored.

Notifies the admin of a language request. Each channel is tried on its own; the call fails only when neither delivered, so the client can retry instead of the request being lost.

The request as the user submitted it. The requesting player, 0 for an anonymous caller. The caller's account email, the reply address when the form gives none. The app and its version, e.g. Web 3.0.24.0. Cancellation token.

Sends a throttled Telegram alert to the super-admin when a client trips the rate limiter. Reports carry only what is available on the spot (who is logged in, client IP, the offending path and the referring page) — no extra activity logging is introduced.

Reports a single rate-limit rejection. Silently coalesces bursts: at most one alert per client per cooldown, capped by a global ceiling per window so a flood can't self-amplify.

Auto-generated public partial Program class for top-level statement apps.

Custom -derived type for the PhonePattern method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the CardPattern method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the HolderPattern method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the CountryPattern method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Helper methods used by generated -derived implementations.

Default timeout value set in , or if none was set.

Whether is non-infinite.

Supports searching for characters in or not in " '-.ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".

Generates a documentation comment ID for a type. Example: T:Namespace.Outer+Inner`1 becomes T:Namespace.Outer.Inner`1

Generates a documentation comment ID for a property. Example: P:Namespace.ContainingType.PropertyName or for an indexer P:Namespace.ContainingType.Item(System.Int32)

Generates a documentation comment ID for a property given its container type and property name. Example: P:Namespace.ContainingType.PropertyName

Generates a documentation comment ID for a method (or constructor). For example: M:Namespace.ContainingType.MethodName(ParamType1,ParamType2)~ReturnType M:Namespace.ContainingType.#ctor(ParamType)

Generates a documentation ID string for a type. This method handles nested types (replacing '+' with '.'), generic types, arrays, pointers, by-ref types, and generic parameters. The flag controls whether constructed generic type arguments are emitted, while controls whether the generic arity marker (e.g. "`1") is appended.

Normalizes a documentation comment ID to match the compiler-style format. Strips the return type suffix for ordinary methods but retains it for conversion operators.

The documentation comment ID to normalize. The normalized documentation comment ID.