@ughuuu/gamend 1.0.0

package/dist/api/AuthenticationApi.js

@@ -0,0 +1,556 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _ApiClient = _interopRequireDefault(require("../ApiClient"));
+var _AdminConsumeItem400Response = _interopRequireDefault(require("../model/AdminConsumeItem400Response"));
+var _DeviceLoginRequest = _interopRequireDefault(require("../model/DeviceLoginRequest"));
+var _ErrorResponse = _interopRequireDefault(require("../model/ErrorResponse"));
+var _LinkDeviceRequest = _interopRequireDefault(require("../model/LinkDeviceRequest"));
+var _ListAuthProviders200Response = _interopRequireDefault(require("../model/ListAuthProviders200Response"));
+var _Login200Response = _interopRequireDefault(require("../model/Login200Response"));
+var _LoginRequest = _interopRequireDefault(require("../model/LoginRequest"));
+var _OAuthSessionStatus = _interopRequireDefault(require("../model/OAuthSessionStatus"));
+var _OauthApiCallback200Response = _interopRequireDefault(require("../model/OauthApiCallback200Response"));
+var _OauthApiCallbackRequest = _interopRequireDefault(require("../model/OauthApiCallbackRequest"));
+var _OauthCallbackApiAppleIosRequest = _interopRequireDefault(require("../model/OauthCallbackApiAppleIosRequest"));
+var _OauthGoogleIdTokenRequest = _interopRequireDefault(require("../model/OauthGoogleIdTokenRequest"));
+var _OauthRequest200Response = _interopRequireDefault(require("../model/OauthRequest200Response"));
+var _OauthSessionStatus404Response = _interopRequireDefault(require("../model/OauthSessionStatus404Response"));
+var _RefreshToken200Response = _interopRequireDefault(require("../model/RefreshToken200Response"));
+var _RefreshTokenRequest = _interopRequireDefault(require("../model/RefreshTokenRequest"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
+ * Gamend API
+ * API for Gamend. Provides HTTP REST API, real-time WebSocket channels, and WebRTC DataChannels for low-latency game data. Features authentication, users, lobbies, groups, parties, friends, chat, notifications, quests, leaderboards, tournaments, matchmaking, payments, server scripting, and admin portal.  ## **1. Authentication**  This API uses JWT (JSON Web Tokens) with access and refresh tokens:  ### **1.1 Getting Tokens** - **Email/Password**: POST to `/api/v1/login` with email and password - **Device (SDK)**: POST to `/api/v1/login` with a `device_id` string (creates/returns a device user) - **Discord OAuth**: Use `/api/v1/auth/discord` flow - **Google OAuth**: Use `/api/v1/auth/google` flow - **Facebook OAuth**: Use `/api/v1/auth/facebook` flow - **Apple Sign In**: Use `/auth/apple` browser flow or apple sdk flow - **Steam (OpenID)**: Use `/api/v1/auth/steam` flow  Both methods return: - `access_token` - Short-lived (15 min), use for API requests - `refresh_token` - Long-lived (30 days), use to get new access tokens  ### **1.2 Using Tokens** Include the access token in the Authorization header: ``` Authorization: Bearer <access_token> ```  ### **1.3 Refreshing Tokens** When your access token expires, use POST `/api/v1/refresh` with your refresh token to get a new access token.  ## **2. Users** Users endpoints cover the user lifecycle and profile features. Key highlights:  - **Registration and login** (email/password, device token for SDKs, and OAuth providers) - **Profile metadata** (JSON blob per user) and editable profile fields - **Account lifecycle**: password reset, email confirmation, and account deletion - **Sessions & tokens**: both browser sessions and JWT-based API tokens are supported  ## **3. Friends** The Friends domain offers lightweight social features:  - **Friend requests** (send / accept / reject / block flows) - **Friend listing & pagination**, with basic privacy controls - **Domain helpers** to manage and query friend relationships from API or UI contexts  ## **4. Lobbies** Lobbies provide matchmaking / room management primitives. Highlights:  - **Create / list / update / delete** lobbies with rich metadata (mode, region, tags) - **Host-managed or hostless** modes (hostless allowed internally, not creatable via public API) - **Membership management**: join, leave, kick users, and automatic host transfer - **Controls & protection**: max users, hidden/locked states, and optional password protection - **Hidden lobbies** are excluded from public listings; public listing endpoints are paginated  ## **5. Notifications** Persistent user-to-user notifications that survive across sessions:  - **Send notifications** to accepted friends with a title, optional content, and optional metadata - **List own notifications** with pagination (ordered oldest-first) - **Delete notifications** by ID (single or batch) - **Real-time delivery** via the user WebSocket channel (`\"notification\"` events) - **Offline delivery**: undeleted notifications are replayed on WebSocket reconnect - **Push delivery**: notifications also fan out to the recipient's registered mobile devices (see Push notifications)  ## **5b. Push notifications** Mobile/web push delivery to registered devices (FCM for Android/Web, APNs-direct for iOS):  - **Register device tokens** via `POST /me/push_tokens` (`token`, `platform`, optional `provider`/`device_id`); re-registering a `device_id` rotates its token in place - **List/remove own devices** via `GET /me/push_tokens` and `DELETE /me/push_tokens/:id` - **Server-authoritative sending** — no public send endpoint; pushes originate from server hooks (`Gamend.Push.send_to_user/2`) or the admin API - **Per-token routing**: each token's `provider` (\"fcm\" | \"apns\") selects the delivery backend; unconfigured backends log instead of sending (dev-friendly) - **Reliability**: delivery rides the durable job queue with retries; dead tokens reported by the provider are disabled automatically  ## **6. Groups** Groups provide persistent community management for players:  - **Three group types**: `public` (anyone joins directly), `private` (users request to join, admins approve), `hidden` (invite-only, never listed) - **Membership roles**: `admin` and `member`, with promote/demote capabilities - **Join requests**: for private groups, users submit requests that admins approve or reject - **Invitations**: admins can invite users directly (blocked users are rejected) - **CRUD operations**: create, update, delete groups with metadata support - **Group chat**: integrated via the Chat API with `chat_type: \"group\"`  ## **7. Parties** Ephemeral groups of users for short-lived sessions (e.g., matchmaking squads):  - **Invite-only joining**: the party leader sends invites by user ID to friends or shared-group members - **Invite flow**: `POST /parties/invite` → recipient accepts via `POST /parties/invite/accept` or declines via `POST /parties/invite/decline`; leader can cancel via `POST /parties/invite/cancel` - **Invite visibility**: leader can list sent invites (`GET /parties/invitations/sent`); recipient can list received invites (`GET /parties/invitations`) - **Connection requirement**: invites can only be sent to users who are friends or share at least one group with the leader - **One party at a time**: a user can only be in one party; accepting an invite while already in a party is rejected - **Leader management**: the creator is the leader; leadership can be transferred - **Lobby integration**: parties can create or join lobbies as a group - **Party chat**: integrated via the Chat API with `chat_type: \"party\"` - **Real-time events** via the party WebSocket channel  ## **8. Chat** Real-time messaging across multiple conversation types:  - **Chat types**: `lobby` (within a lobby), `group` (within a group), `party` (within a party), `friend` (DMs between friends) - **Send messages** with content, optional metadata, and automatic access validation - **List messages** with pagination (newest first) - **Read tracking**: mark messages as read and get unread counts per conversation - **Real-time delivery** via PubSub and WebSocket channels - **Moderation is built in**: an admin-managed word filter (`block` / `mask` / `flag`, matched on a normalized form so leetspeak and padding do not slip through) and mutes are enforced before a message is stored or broadcast; the `before_chat_message` pipeline hook stays available for rules of your own - **Report a message**: `POST /chat/messages/:id/report` with an optional `reason` — one report per player per message, capped per day; reports the filter files itself have no reporter - **Scoped mutes** mirror kick: `POST /lobbies/mute` + `/lobbies/unmute` (lobby host), `POST /groups/:id/mute` + `/groups/:id/unmute` (group admin), `POST /parties/mute` + `/parties/unmute` (party leader), each with a paginated `.../mutes` listing for the same authority. Body is `{target_user_id, expires_at?, reason?}`; omitting `expires_at` mutes permanently - **Global mutes and the blocklist are server-authoritative** — no public endpoint; admin API (`/api/v1/admin/chat`) or a plugin calling `Gamend.Chat.mute_user/4` - **Real-time moderation events**: the muted player receives `chat_muted` / `chat_unmuted` on their user channel  ## **9. Leaderboards** Server-managed ranked scoreboards:  - **Multiple leaderboards**: create named leaderboards with configurable sort order - **Score submission**: submit scores with optional metadata - **Rankings**: retrieve paginated rankings with user details - **Reset support**: leaderboards can be reset periodically  ## **10. Key-Value Storage** Per-user persistent key-value storage for game state, preferences, and settings:  - **Get/set/delete** key-value pairs scoped to the authenticated user - **List keys** with optional prefix filtering - **Metadata support**: values can include arbitrary JSON metadata  ## **11. Quests / Progression** One event-driven progression engine covering achievements, daily/weekly quests, time-boxed event quests, chains, and groups:  - **Kinds**: `achievement` (permanent one-shot — the replacement for the old achievements system), `daily`/`weekly` (reset per UTC period), `event` (starts_at/ends_at window), `chain` (requires a prerequisite quest) - **Objectives**: each quest lists objectives `{event, target, params}`; server-side `report_event` advances every matching active quest — there is **no public endpoint to advance progress** (server-authoritative) - **Rewards**: currencies (Economy) and items (Inventory), paid **exactly once** per period via idempotent grants; `auto_claim` quests pay on completion, others via `POST /me/quests/:key/claim` - **My quests**: `GET /me/quests` returns active quests, per-period progress, and a claimable flag; hidden quests appear once completed - **Groups**: quests sharing a `group_key` collapse to one entry carrying `group_size`; `?group=<key>` lists that group's members in full - **Catalog**: `GET /quests` and per-user completions `GET /quests/user/:user_id` (gated by `LIST_QUESTS_ENABLED`) - **Admin management**: definitions CRUD plus per-user grant/reset/force-claim under `/api/v1/admin/quests`  ## **12. Tournaments** Single-elimination bracket tournaments, server-structured and game-judged:  - **Registration window → seeded draw → timed rounds → champions**; recurring tournaments (cron) create one occurrence per cycle sharing a slug; a nil starts_at keeps registration open until an admin draws manually - **Join/leave** as an entry leader (`POST`/`DELETE /tournaments/:id/join`); team composition is game policy - **Browse**: list/filter tournaments, standings, full bracket view, and the caller's current match (`GET /tournaments/:id/my_match`) - **Match verdicts are server-side** (game hooks) — no public resolve endpoint; clients get `tournament_match_ready` / `tournament_match_resolved` / `tournament_updated` / `tournament_finished` on the user channel - **Admin management** over HTTP: create/update/delete, cancel, draw now, finish, and force match verdicts under `/api/v1/admin/tournaments`  ## **13. Matchmaking** Ticket-based queueing that turns waiting players into hidden, locked lobbies:  - **Join over HTTP** (`POST /matchmaking/tickets` with a `match_params` string map); only tickets with identical params match together — encode mode/map/skill band as parameter values - **A match forms** when a group reaches `max_players`, or has at least `min_players` and the oldest ticket outwaited the timeout; the server creates a hidden lobby, seats everyone and locks it - **The result is a push, not a poll**: matched players receive `match_found` (`lobby_id`, `match_params`) on their user channel; disconnecting cancels your tickets - **Inspect**: `GET /matchmaking/tickets/me` for your ticket, `GET /matchmaking/stats` for queue depths - **Admin management** over HTTP: list/filter tickets, force-cancel, and stats under `/api/v1/admin/matchmaking`  ## **14. Ready checks** One primitive for \"everyone must answer before this proceeds\", with one client-facing surface:  - **A player holds at most one check per lane** — the match lane (lobby ready-up or matchmaking accept) and the party lane (the party's standing board) — so answering needs no id: `GET /me/ready_check` returns `{\"lobby\": …, \"party\": …}` (each null when none) and `POST /me/ready_check` with `{\"ready\": true|false, \"scope\": \"lobby\"|\"party\"}` answers one (scope defaults to `lobby`) - **Two kinds.** `ready` (lobby/party board) is a toggle — a \"no\" just leaves the check open, and it lists every participant. `accept` (match confirmation) is final — one decline fails it for everyone — and returns counts plus your own state, so a pending match does not reveal who you were paired with - **Hosts open one** with `POST /lobbies/ready_check` (host-managed lobbies only; hostless matchmaking lobbies belong to the server), **party leaders** with `POST /parties/ready_check`; either call is a **reset** — it quietly replaces an already-open board with a fresh one over the current members, so the same endpoint serves \"ready check!\", \"force ready\" (with `timeout_ms`) and \"start over\". Call it off with `DELETE /lobbies/ready_check` / `DELETE /parties/ready_check`. The opener is pre-marked ready — clicking the button is their answer - **Failure does nothing on its own**: a declined or timed-out check kicks nobody, starts nothing, and moves no lobby state. It reports who did not answer, and the game (or the host, with the kick they already have) decides - **Live**: `ready_check_started` / `ready_check_updated` / `ready_check_passed` / `ready_check_failed` on the lobby channel, the party channel for a party board, or the user channel for an accept check - **Admin management** over HTTP: list/filter checks, force-cancel, and 24h outcome stats under `/api/v1/admin/ready_checks`  ## **15. Real-time: WebSocket Channels** The server provides real-time communication via Phoenix WebSocket channels. Connect to the WebSocket endpoint and join topic-based channels for live updates.  ### **15.1 Connection** Connect to `wss://your-server.com/socket` with your JWT token as a parameter: ``` const socket = new Socket(\"wss://your-server.com/socket\", { params: { token: \"<access_token>\" } }) socket.connect() ```  ### **15.2 Available Channels** - **User channel** (`user:<user_id>`): notifications, friend events, quest progress/completions/claims, party/group invites, tournament events, chat mutes (`chat_muted` / `chat_unmuted`), KV subscriptions - **Lobby channel** (`lobby:<lobby_id>`): lobby member joins/leaves, lobby updates, lobby chat - **Lobbies channel** (`lobbies`): global lobby list changes (created, updated, deleted) - **Group channel** (`group:<group_id>`): group member changes, group updates, group chat - **Groups channel** (`groups`): global group list changes - **Party channel** (`party:<party_id>`): party member changes, party updates, party chat  ### **15.3 JS SDK Helper** The `GameRealtime` class (included in this SDK) wraps Phoenix.Socket with convenient channel helpers: ```javascript import { GameRealtime } from '@ughuuu/gamend' const realtime = new GameRealtime('https://your-server.com', accessToken) const userChannel = realtime.joinUserChannel(userId) userChannel.on('notification', payload => console.log(payload)) ``` Requires the `phoenix` npm package as a peer dependency: `npm install phoenix`  ## **16. Real-time: WebRTC DataChannels** For low-latency game data, the server supports WebRTC DataChannels alongside WebSocket. The server acts as a WebRTC peer (not P2P between clients).  ### **16.1 How It Works** 1. Client connects via WebSocket and joins the **User channel** 2. Client sends an SDP offer over the channel (`webrtc:offer` event) 3. Server responds with an SDP answer (`webrtc:answer` event) 4. ICE candidates are exchanged (`webrtc:ice` events) 5. Once connected, named DataChannels carry game data at low latency  ### **16.2 Default DataChannels** - **`events`** (reliable, ordered): important game events (player actions, state changes) - **`state`** (unreliable, unordered): high-frequency position/state sync  ### **16.3 JS SDK Helper** The `GameWebRTC` class (included in this SDK, browser-only) handles signaling automatically: ```javascript import { GameRealtime, GameWebRTC } from '@ughuuu/gamend' const realtime = new GameRealtime('https://your-server.com', token) const userChannel = realtime.joinUserChannel(userId) const webrtc = new GameWebRTC(userChannel, {   onData: (label, data) => console.log(label, data) }) await webrtc.connect() webrtc.send('events', JSON.stringify({ type: 'move', x: 10, y: 20 })) ``` 
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ *
+ */
+/**
+* Authentication service.
+* @module api/AuthenticationApi
+* @version 1.0.0
+*/
+var AuthenticationApi = exports["default"] = /*#__PURE__*/function () {
+  /**
+  * Constructs a new AuthenticationApi. 
+  * @alias module:api/AuthenticationApi
+  * @class
+  * @param {module:ApiClient} [apiClient] Optional API client implementation to use,
+  * default to {@link module:ApiClient#instance} if unspecified.
+  */
+  function AuthenticationApi(apiClient) {
+    _classCallCheck(this, AuthenticationApi);
+    this.apiClient = apiClient || _ApiClient["default"].instance;
+  }
+
+  /**
+   * Device login
+   * Authenticate or create a device-backed user using a device_id (no password).
+   * @param {Object} opts Optional parameters
+   * @param {module:model/DeviceLoginRequest} [deviceLoginRequest] Device login
+   * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OauthApiCallback200Response} and HTTP response
+   */
+  return _createClass(AuthenticationApi, [{
+    key: "deviceLoginWithHttpInfo",
+    value: function deviceLoginWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['deviceLoginRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _OauthApiCallback200Response["default"];
+      return this.apiClient.callApi('/api/v1/login/device', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Device login
+     * Authenticate or create a device-backed user using a device_id (no password).
+     * @param {Object} opts Optional parameters
+     * @param {module:model/DeviceLoginRequest} opts.deviceLoginRequest Device login
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OauthApiCallback200Response}
+     */
+  }, {
+    key: "deviceLogin",
+    value: function deviceLogin(opts) {
+      return this.deviceLoginWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Link device ID
+     * Links a device_id to the current authenticated user's account.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/LinkDeviceRequest} [linkDeviceRequest] Device ID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object} and HTTP response
+     */
+  }, {
+    key: "linkDeviceWithHttpInfo",
+    value: function linkDeviceWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['linkDeviceRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['authorization'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = Object;
+      return this.apiClient.callApi('/api/v1/me/device', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Link device ID
+     * Links a device_id to the current authenticated user's account.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/LinkDeviceRequest} opts.linkDeviceRequest Device ID
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object}
+     */
+  }, {
+    key: "linkDevice",
+    value: function linkDevice(opts) {
+      return this.linkDeviceWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * List sign-in providers
+     * The OAuth providers a player may currently sign in with.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/ListAuthProviders200Response} and HTTP response
+     */
+  }, {
+    key: "listAuthProvidersWithHttpInfo",
+    value: function listAuthProvidersWithHttpInfo() {
+      var postBody = null;
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _ListAuthProviders200Response["default"];
+      return this.apiClient.callApi('/api/v1/auth/providers', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * List sign-in providers
+     * The OAuth providers a player may currently sign in with.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/ListAuthProviders200Response}
+     */
+  }, {
+    key: "listAuthProviders",
+    value: function listAuthProviders() {
+      return this.listAuthProvidersWithHttpInfo().then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Login
+     * Authenticate user with email and password
+     * @param {Object} opts Optional parameters
+     * @param {module:model/LoginRequest} [loginRequest] Login credentials
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Login200Response} and HTTP response
+     */
+  }, {
+    key: "loginWithHttpInfo",
+    value: function loginWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['loginRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _Login200Response["default"];
+      return this.apiClient.callApi('/api/v1/login', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Login
+     * Authenticate user with email and password
+     * @param {Object} opts Optional parameters
+     * @param {module:model/LoginRequest} opts.loginRequest Login credentials
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Login200Response}
+     */
+  }, {
+    key: "login",
+    value: function login(opts) {
+      return this.loginWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Logout
+     * Revoke the caller's tokens. Send the access or refresh token in the Authorization header. This signs the account out on every device, because revocation works by bumping the account's token version. Always returns 200, so a client with an already-expired token can still complete sign-out.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object} and HTTP response
+     */
+  }, {
+    key: "logoutWithHttpInfo",
+    value: function logoutWithHttpInfo() {
+      var postBody = null;
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = Object;
+      return this.apiClient.callApi('/api/v1/logout', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Logout
+     * Revoke the caller's tokens. Send the access or refresh token in the Authorization header. This signs the account out on every device, because revocation works by bumping the account's token version. Always returns 200, so a client with an already-expired token can still complete sign-out.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object}
+     */
+  }, {
+    key: "logout",
+    value: function logout() {
+      return this.logoutWithHttpInfo().then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * API callback / code exchange
+     * Accepts an OAuth authorization code via the API and returns access/refresh tokens on success. If a valid JWT is provided in the Authorization header, the provider will be **linked** to the authenticated user instead of logging in. For the Steam provider, the `code` field should contain a server-verifiable Steam credential (for example a Steam auth ticket or Steam identifier) and will be validated via the Steam Web API.
+     * @param {String} provider 
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthApiCallbackRequest} [oauthApiCallbackRequest] Code exchange or steam payload
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OauthApiCallback200Response} and HTTP response
+     */
+  }, {
+    key: "oauthApiCallbackWithHttpInfo",
+    value: function oauthApiCallbackWithHttpInfo(provider, opts) {
+      opts = opts || {};
+      var postBody = opts['oauthApiCallbackRequest'];
+      // verify the required parameter 'provider' is set
+      if (provider === undefined || provider === null) {
+        throw new Error("Missing the required parameter 'provider' when calling oauthApiCallback");
+      }
+      var pathParams = {
+        'provider': provider
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _OauthApiCallback200Response["default"];
+      return this.apiClient.callApi('/api/v1/auth/{provider}/callback', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * API callback / code exchange
+     * Accepts an OAuth authorization code via the API and returns access/refresh tokens on success. If a valid JWT is provided in the Authorization header, the provider will be **linked** to the authenticated user instead of logging in. For the Steam provider, the `code` field should contain a server-verifiable Steam credential (for example a Steam auth ticket or Steam identifier) and will be validated via the Steam Web API.
+     * @param {String} provider 
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthApiCallbackRequest} opts.oauthApiCallbackRequest Code exchange or steam payload
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OauthApiCallback200Response}
+     */
+  }, {
+    key: "oauthApiCallback",
+    value: function oauthApiCallback(provider, opts) {
+      return this.oauthApiCallbackWithHttpInfo(provider, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Apple callback (native iOS)
+     * Exchanges a native iOS Sign in with Apple authorization code using APPLE_IOS_CLIENT_ID.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthCallbackApiAppleIosRequest} [oauthCallbackApiAppleIosRequest] Apple callback params
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OauthApiCallback200Response} and HTTP response
+     */
+  }, {
+    key: "oauthCallbackApiAppleIosWithHttpInfo",
+    value: function oauthCallbackApiAppleIosWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['oauthCallbackApiAppleIosRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _OauthApiCallback200Response["default"];
+      return this.apiClient.callApi('/api/v1/auth/apple/ios/callback', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Apple callback (native iOS)
+     * Exchanges a native iOS Sign in with Apple authorization code using APPLE_IOS_CLIENT_ID.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthCallbackApiAppleIosRequest} opts.oauthCallbackApiAppleIosRequest Apple callback params
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OauthApiCallback200Response}
+     */
+  }, {
+    key: "oauthCallbackApiAppleIos",
+    value: function oauthCallbackApiAppleIos(opts) {
+      return this.oauthCallbackApiAppleIosWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Google ID token login (native/mobile)
+     * Verify a Google OpenID Connect id_token (eg. from Android Credential Manager) and return JWT tokens.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthGoogleIdTokenRequest} [oauthGoogleIdTokenRequest] Google ID token
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OauthApiCallback200Response} and HTTP response
+     */
+  }, {
+    key: "oauthGoogleIdTokenWithHttpInfo",
+    value: function oauthGoogleIdTokenWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['oauthGoogleIdTokenRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _OauthApiCallback200Response["default"];
+      return this.apiClient.callApi('/api/v1/auth/google/id_token', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Google ID token login (native/mobile)
+     * Verify a Google OpenID Connect id_token (eg. from Android Credential Manager) and return JWT tokens.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/OauthGoogleIdTokenRequest} opts.oauthGoogleIdTokenRequest Google ID token
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OauthApiCallback200Response}
+     */
+  }, {
+    key: "oauthGoogleIdToken",
+    value: function oauthGoogleIdToken(opts) {
+      return this.oauthGoogleIdTokenWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Initiate API OAuth
+     * Returns OAuth authorization URL for API clients
+     * @param {module:model/String} provider OAuth provider
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OauthRequest200Response} and HTTP response
+     */
+  }, {
+    key: "oauthRequestWithHttpInfo",
+    value: function oauthRequestWithHttpInfo(provider) {
+      var postBody = null;
+      // verify the required parameter 'provider' is set
+      if (provider === undefined || provider === null) {
+        throw new Error("Missing the required parameter 'provider' when calling oauthRequest");
+      }
+      var pathParams = {
+        'provider': provider
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _OauthRequest200Response["default"];
+      return this.apiClient.callApi('/api/v1/auth/{provider}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Initiate API OAuth
+     * Returns OAuth authorization URL for API clients
+     * @param {module:model/String} provider OAuth provider
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OauthRequest200Response}
+     */
+  }, {
+    key: "oauthRequest",
+    value: function oauthRequest(provider) {
+      return this.oauthRequestWithHttpInfo(provider).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Get OAuth session status
+     * Check the status of an OAuth session for API clients
+     * @param {String} sessionId Session ID from OAuth request
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/OAuthSessionStatus} and HTTP response
+     */
+  }, {
+    key: "oauthSessionStatusWithHttpInfo",
+    value: function oauthSessionStatusWithHttpInfo(sessionId) {
+      var postBody = null;
+      // verify the required parameter 'sessionId' is set
+      if (sessionId === undefined || sessionId === null) {
+        throw new Error("Missing the required parameter 'sessionId' when calling oauthSessionStatus");
+      }
+      var pathParams = {
+        'session_id': sessionId
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _OAuthSessionStatus["default"];
+      return this.apiClient.callApi('/api/v1/auth/session/{session_id}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Get OAuth session status
+     * Check the status of an OAuth session for API clients
+     * @param {String} sessionId Session ID from OAuth request
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/OAuthSessionStatus}
+     */
+  }, {
+    key: "oauthSessionStatus",
+    value: function oauthSessionStatus(sessionId) {
+      return this.oauthSessionStatusWithHttpInfo(sessionId).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Refresh access token
+     * Exchange a valid refresh token for a new access token
+     * @param {Object} opts Optional parameters
+     * @param {module:model/RefreshTokenRequest} [refreshTokenRequest] Refresh token
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/RefreshToken200Response} and HTTP response
+     */
+  }, {
+    key: "refreshTokenWithHttpInfo",
+    value: function refreshTokenWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = opts['refreshTokenRequest'];
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = [];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _RefreshToken200Response["default"];
+      return this.apiClient.callApi('/api/v1/refresh', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Refresh access token
+     * Exchange a valid refresh token for a new access token
+     * @param {Object} opts Optional parameters
+     * @param {module:model/RefreshTokenRequest} opts.refreshTokenRequest Refresh token
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/RefreshToken200Response}
+     */
+  }, {
+    key: "refreshToken",
+    value: function refreshToken(opts) {
+      return this.refreshTokenWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Unlink device ID
+     * Unlinks the device_id from the current authenticated user. Requires at least one OAuth provider or password to remain.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object} and HTTP response
+     */
+  }, {
+    key: "unlinkDeviceWithHttpInfo",
+    value: function unlinkDeviceWithHttpInfo() {
+      var postBody = null;
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['authorization'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = Object;
+      return this.apiClient.callApi('/api/v1/me/device', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Unlink device ID
+     * Unlinks the device_id from the current authenticated user. Requires at least one OAuth provider or password to remain.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object}
+     */
+  }, {
+    key: "unlinkDevice",
+    value: function unlinkDevice() {
+      return this.unlinkDeviceWithHttpInfo().then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Unlink OAuth provider
+     * Unlinks a provider from the current authenticated user.
+     * @param {module:model/String} provider 
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object} and HTTP response
+     */
+  }, {
+    key: "unlinkProviderWithHttpInfo",
+    value: function unlinkProviderWithHttpInfo(provider) {
+      var postBody = null;
+      // verify the required parameter 'provider' is set
+      if (provider === undefined || provider === null) {
+        throw new Error("Missing the required parameter 'provider' when calling unlinkProvider");
+      }
+      var pathParams = {
+        'provider': provider
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['authorization'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = Object;
+      return this.apiClient.callApi('/api/v1/me/providers/{provider}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Unlink OAuth provider
+     * Unlinks a provider from the current authenticated user.
+     * @param {module:model/String} provider 
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object}
+     */
+  }, {
+    key: "unlinkProvider",
+    value: function unlinkProvider(provider) {
+      return this.unlinkProviderWithHttpInfo(provider).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+  }]);
+}();