@krtuworks/sdk 0.0.0-stage → 1.0.0

package/dist/clock.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Time as the server reads it: each record carries the device's wall clock, this launch's
+ * id, the time since the launch (monotonic, immune to clock changes) and, once the server has answered,
+ * how far the device clock is from the server's. The server takes the age from the monotonic time within
+ * a launch and from the offset across launches; a record is never refused for its time.
+ */
+export declare class Clock {
+    readonly launchId: string;
+    private readonly started;
+    private offset;
+    /** Milliseconds since this launch began. */
+    monotonicMs(): number;
+    /** Server time minus device time, once known. */
+    get serverOffsetMs(): number | null;
+    /** The server's clock now, as well as it is known. */
+    serverNow(): number;
+    /** Learns the offset from a server timestamp (`serverTime` in an answer or the `Date` header). */
+    noteServerTime(value: string | null | undefined): void;
+}

package/dist/clock.js

@@ -0,0 +1,32 @@
+import { uuidV7 } from './ids.js';
+/**
+ * Time as the server reads it: each record carries the device's wall clock, this launch's
+ * id, the time since the launch (monotonic, immune to clock changes) and, once the server has answered,
+ * how far the device clock is from the server's. The server takes the age from the monotonic time within
+ * a launch and from the offset across launches; a record is never refused for its time.
+ */
+export class Clock {
+    launchId = uuidV7();
+    started = performance.now();
+    offset = null;
+    /** Milliseconds since this launch began. */
+    monotonicMs() {
+        return Math.max(0, Math.round(performance.now() - this.started));
+    }
+    /** Server time minus device time, once known. */
+    get serverOffsetMs() {
+        return this.offset;
+    }
+    /** The server's clock now, as well as it is known. */
+    serverNow() {
+        return Date.now() + (this.offset ?? 0);
+    }
+    /** Learns the offset from a server timestamp (`serverTime` in an answer or the `Date` header). */
+    noteServerTime(value) {
+        if (!value)
+            return;
+        const ms = Date.parse(value);
+        if (Number.isFinite(ms))
+            this.offset = ms - Date.now();
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,85 @@
+import type { KrtuStore } from './store.js';
+export type Environment = 'TEST' | 'LIVE';
+export type Platform = 'STEAM' | 'EPIC' | 'XBOX' | 'PLAYSTATION' | 'NINTENDO' | 'IOS' | 'ANDROID' | 'WEB' | 'WINDOWS' | 'MACOS' | 'LINUX';
+export type AppType = 'GAME' | 'MOBILE_APP' | 'WEB_APP' | 'DESKTOP_APP';
+/**
+ * `krtuworks-config.json`, downloaded from the app's "Credentials" page: nothing secret, only who the
+ * app is, what kind of app it is and its players' sign-in clients per environment.
+ */
+export interface KrtuworksAppConfig {
+    appId: string;
+    slug: string;
+    /** The game-only parts (levels, deaths) stay off in the other kinds. A file made before the field existed is a game's. */
+    type?: AppType;
+    environments: Partial<Record<Environment, {
+        clientId?: string;
+        webClientId?: string;
+    }>>;
+}
+/** The modules only a game has: levels (progression) and deaths (combat). */
+export declare const GAME_MODULES: readonly Module[];
+export interface DeviceInfo {
+    os?: string;
+    osVersion?: string;
+    model?: string;
+    gpu?: string;
+    ramMb?: number;
+    screenWidth?: number;
+    screenHeight?: number;
+}
+export interface KrtuworksOptions {
+    config: KrtuworksAppConfig;
+    environment: Environment;
+    platform: Platform;
+    /** The app's own version label (`1.4.2+381`), sent with every call. */
+    build: string;
+    /** `web` (a browser page: PKCE with an https redirect) or `native` (a desktop app: loopback redirect). Default: web in a browser. */
+    clientKind?: 'web' | 'native';
+    /** Overrides the client id the config names for the environment. */
+    clientId?: string;
+    /** Where the sign-in comes back: one of the web client's registered redirect addresses. */
+    redirectUri?: string;
+    store?: KrtuStore;
+    fetch?: typeof fetch;
+    device?: DeviceInfo;
+    /** The player's language tag (`tr`, `pt-BR`); achievement names come in it when the app has them. */
+    locale?: string;
+    /** Opens a session and keeps it alive while the app runs. Default true. */
+    sessions?: boolean;
+    idOrigin?: string;
+    devOrigin?: string;
+}
+export declare const ID_ORIGIN = "https://id.krtuworks.com";
+export declare const DEV_ORIGIN = "https://dev.krtuworks.com";
+/** The resource a player's tokens are for (the server). */
+export declare const DEV_RESOURCE = "https://dev.krtuworks.com";
+export declare const ISSUER = "https://id.krtuworks.com/oidc";
+export declare const PLAYER_SCOPE = "openid offline_access profile app:player";
+export declare const GUEST_SCOPE = "openid offline_access app:player";
+/** The legal documents a new guest accepts, as this SDK version knows them; a newer set answers terms_required with the list. */
+export declare const CURRENT_TERMS = "TERMS:v1 PRIVACY:v1";
+/** The SDK modules the owner switches per app (`config.modules`); a module that is off makes nothing. */
+export declare const MODULES: readonly ["sessions", "progression", "combat", "economy", "items", "ui", "performance", "settings", "errors", "bugReports", "achievements", "stats", "cloudSave", "remoteConfig", "abTests", "customEvents", "presence"];
+export type Module = (typeof MODULES)[number];
+/** Which module a ready-made event family belongs to; any other type is the app's own (customEvents). */
+export declare const FAMILY_MODULE: Readonly<Record<string, Module>>;
+export declare function moduleOfEventType(type: string): Module;
+export interface ResolvedOptions {
+    appId: string;
+    slug: string;
+    type: AppType;
+    /** The app is a game (type GAME): levels and deaths are kept. */
+    game: boolean;
+    environment: Environment;
+    platform: Platform;
+    build: string;
+    clientId: string;
+    clientKind: 'web' | 'native';
+    redirectUri: string | null;
+    idOrigin: string;
+    devOrigin: string;
+    device: DeviceInfo | null;
+    locale: string | null;
+    sessions: boolean;
+}
+export declare function resolveOptions(options: KrtuworksOptions): ResolvedOptions;

package/dist/config.js

@@ -0,0 +1,68 @@
+/** The modules only a game has: levels (progression) and deaths (combat). */
+export const GAME_MODULES = ['progression', 'combat'];
+export const ID_ORIGIN = 'https://id.krtuworks.com';
+export const DEV_ORIGIN = 'https://dev.krtuworks.com';
+/** The resource a player's tokens are for (the server). */
+export const DEV_RESOURCE = 'https://dev.krtuworks.com';
+export const ISSUER = 'https://id.krtuworks.com/oidc';
+export const PLAYER_SCOPE = 'openid offline_access profile app:player';
+export const GUEST_SCOPE = 'openid offline_access app:player';
+/** The legal documents a new guest accepts, as this SDK version knows them; a newer set answers terms_required with the list. */
+export const CURRENT_TERMS = 'TERMS:v1 PRIVACY:v1';
+/** The SDK modules the owner switches per app (`config.modules`); a module that is off makes nothing. */
+export const MODULES = [
+    'sessions', 'progression', 'combat', 'economy', 'items', 'ui', 'performance', 'settings', 'errors',
+    'bugReports', 'achievements', 'stats', 'cloudSave', 'remoteConfig', 'abTests', 'customEvents', 'presence',
+];
+/** Which module a ready-made event family belongs to; any other type is the app's own (customEvents). */
+export const FAMILY_MODULE = {
+    screen_view: 'ui',
+    button: 'ui',
+    tutorial: 'ui',
+    progression: 'progression',
+    death: 'combat',
+    damage: 'combat',
+    economy: 'economy',
+    balance: 'economy',
+    item: 'items',
+    interaction: 'items',
+    performance: 'performance',
+    settings: 'settings',
+    error: 'errors',
+};
+export function moduleOfEventType(type) {
+    return Object.prototype.hasOwnProperty.call(FAMILY_MODULE, type) ? FAMILY_MODULE[type] : 'customEvents';
+}
+const BUILD = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/;
+export function resolveOptions(options) {
+    const { config, environment } = options;
+    if (!config || typeof config.appId !== 'string' || typeof config.slug !== 'string')
+        throw new TypeError('config must be the app\'s krtuworks-config.json');
+    if (environment !== 'TEST' && environment !== 'LIVE')
+        throw new TypeError('environment is TEST or LIVE');
+    if (typeof options.build !== 'string' || !BUILD.test(options.build))
+        throw new TypeError('build is the app\'s version label, like 1.4.2+381');
+    const clientKind = options.clientKind ?? (typeof window === 'undefined' ? 'native' : 'web');
+    const env = config.environments?.[environment] ?? {};
+    const clientId = options.clientId ?? (clientKind === 'web' ? env.webClientId : env.clientId);
+    if (!clientId)
+        throw new TypeError(`krtuworks-config.json names no ${clientKind} client for ${environment}`);
+    const type = config.type || 'GAME';
+    return {
+        appId: config.appId,
+        slug: config.slug,
+        type,
+        game: type === 'GAME',
+        environment,
+        platform: options.platform,
+        build: options.build,
+        clientId,
+        clientKind,
+        redirectUri: options.redirectUri ?? null,
+        idOrigin: (options.idOrigin ?? ID_ORIGIN).replace(/\/+$/, ''),
+        devOrigin: (options.devOrigin ?? DEV_ORIGIN).replace(/\/+$/, ''),
+        device: options.device ?? null,
+        locale: options.locale ?? null,
+        sessions: options.sessions ?? true,
+    };
+}

package/dist/deviceKey.d.ts

@@ -0,0 +1,32 @@
+/** The four members of a P-256 public key, exactly what the server accepts in a proof's header. */
+export interface PublicDeviceKey {
+    kty: 'EC';
+    crv: 'P-256';
+    x: string;
+    y: string;
+}
+/**
+ * The device's own key: a P-256 pair made here, the private half non-extractable,
+ * kept in the store as a CryptoKey. A guest's account is bound to it; it never leaves the device.
+ */
+export interface DeviceKey {
+    privateKey: CryptoKey;
+    publicJwk: PublicDeviceKey;
+    /** RFC 7638 thumbprint (SHA-256, base64url) of the public key. */
+    thumbprint: string;
+}
+export type ProofPurpose = 'login' | 'promote' | 'delete' | 'cancel_deletion' | 'export_download';
+export declare function jwkThumbprint(jwk: PublicDeviceKey): Promise<string>;
+export declare function createDeviceKey(): Promise<DeviceKey>;
+/**
+ * The compact JWS a device-key call carries: header `{ alg: ES256, typ: krtu-device-key+jwt, jwk }`,
+ * claims `{ nonce, client_id, purpose, key_thumbprint, iat }`. WebCrypto's ECDSA signature is already the
+ * raw r||s form JWS wants. `iat` is the server's clock as far as it is known: a device whose clock is
+ * off still signs inside the server's minute.
+ */
+export declare function signProof(key: DeviceKey, claims: {
+    nonce: string;
+    clientId: string;
+    purpose: ProofPurpose;
+    iat: number;
+}): Promise<string>;

package/dist/deviceKey.js

@@ -0,0 +1,26 @@
+import { base64Url, sha256 } from './ids.js';
+export async function jwkThumbprint(jwk) {
+    // RFC 7638: the required members only, in lexicographic order, no whitespace.
+    return base64Url(await sha256(JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y })));
+}
+export async function createDeviceKey() {
+    const pair = (await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign', 'verify']));
+    const jwk = await crypto.subtle.exportKey('jwk', pair.publicKey);
+    if (typeof jwk.x !== 'string' || typeof jwk.y !== 'string')
+        throw new Error('the platform made no P-256 public key');
+    const publicJwk = { kty: 'EC', crv: 'P-256', x: jwk.x, y: jwk.y };
+    return { privateKey: pair.privateKey, publicJwk, thumbprint: await jwkThumbprint(publicJwk) };
+}
+/**
+ * The compact JWS a device-key call carries: header `{ alg: ES256, typ: krtu-device-key+jwt, jwk }`,
+ * claims `{ nonce, client_id, purpose, key_thumbprint, iat }`. WebCrypto's ECDSA signature is already the
+ * raw r||s form JWS wants. `iat` is the server's clock as far as it is known: a device whose clock is
+ * off still signs inside the server's minute.
+ */
+export async function signProof(key, claims) {
+    const header = base64Url(JSON.stringify({ alg: 'ES256', typ: 'krtu-device-key+jwt', jwk: key.publicJwk }));
+    const payload = base64Url(JSON.stringify({ nonce: claims.nonce, client_id: claims.clientId, purpose: claims.purpose, key_thumbprint: key.thumbprint, iat: claims.iat }));
+    const input = `${header}.${payload}`;
+    const signature = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, key.privateKey, new TextEncoder().encode(input));
+    return `${input}.${base64Url(signature)}`;
+}

package/dist/entitlements.d.ts

@@ -0,0 +1,48 @@
+import type { Api } from './api.js';
+import type { KrtuStore } from './store.js';
+/** One licence of the player in this app: the game itself (`sku` base) or one of its DLCs (the DLC's product key). */
+export interface Entitlement {
+    sku: string;
+    source: string;
+    /** null: the server never saw a licence (a DLC the player never owned). */
+    status: 'ACTIVE' | 'REVOKED' | null;
+    /** The platform's id the licence is read for (a Steam AppID); null when the server has none. */
+    platformProductId: string | null;
+    /** The server checked it with the platform in this launch (the session's answer). */
+    checked: boolean;
+}
+/**
+ * What the player owns (the server `entitlements`): the game's licence and its DLCs, as the server last said.
+ * Kept per player and environment in the store (the last answer of an earlier launch stays when the
+ * server cannot be reached). `ownsDlc` reads, in this order: what the server confirmed with the
+ * platform in this launch (a session answer item with `checked`), then the platform client's own answer
+ * (a browser has none), then the last answer the server gave, kept from an earlier launch or fetched.
+ */
+export declare class Entitlements {
+    private readonly clientId;
+    private readonly store;
+    private readonly api;
+    private readonly subject;
+    private cached;
+    constructor(clientId: string, store: KrtuStore, api: Api, subject: () => string | null);
+    private key;
+    /** Reads the current player's kept list. */
+    load(): Promise<void>;
+    /** Reads the kept list unless this player's is already held (a launch's confirmed answers stay). */
+    ensureLoaded(): Promise<void>;
+    /** The player changed or signed out: nothing of the old player stays in memory. */
+    forget(): void;
+    private current;
+    /** The licences as known now: the server's last answer, with `checked` on what it confirmed in this launch. */
+    list(): Entitlement[];
+    private keep;
+    /** The session answer's list: its checked items are this launch's confirmed answers, the whole list the server's last word. */
+    fromSession(value: unknown): Promise<void>;
+    /** `GET /v1/me/entitlements`: the stored licences replace what the kept list says (a DLC it no longer holds is kept as `null`, for its id). */
+    refresh(): Promise<Entitlement[]>;
+    /**
+     * Whether the player owns the DLC `key` (its product key). `local` is the platform client's own
+     * answer for the DLC's platform id (Steam's), when the platform has one.
+     */
+    ownsDlc(key: string, local?: (platformProductId: string) => boolean | null): boolean;
+}

package/dist/entitlements.js

@@ -0,0 +1,113 @@
+/** Reads the server's items (`entitlements` of a session answer, the list of `GET /v1/me/entitlements`); anything else is ignored. */
+function itemsOf(value) {
+    if (!Array.isArray(value))
+        return [];
+    const items = [];
+    for (const raw of value) {
+        if (!raw || typeof raw.sku !== 'string' || typeof raw.source !== 'string')
+            continue;
+        items.push({
+            sku: raw.sku,
+            source: raw.source,
+            status: raw.status === 'ACTIVE' || raw.status === 'REVOKED' ? raw.status : null,
+            platformProductId: typeof raw.platformProductId === 'string' ? raw.platformProductId : null,
+            checked: raw.checked === true,
+        });
+    }
+    return items;
+}
+/**
+ * What the player owns (the server `entitlements`): the game's licence and its DLCs, as the server last said.
+ * Kept per player and environment in the store (the last answer of an earlier launch stays when the
+ * server cannot be reached). `ownsDlc` reads, in this order: what the server confirmed with the
+ * platform in this launch (a session answer item with `checked`), then the platform client's own answer
+ * (a browser has none), then the last answer the server gave, kept from an earlier launch or fetched.
+ */
+export class Entitlements {
+    clientId;
+    store;
+    api;
+    subject;
+    cached = null;
+    constructor(clientId, store, api, subject) {
+        this.clientId = clientId;
+        this.store = store;
+        this.api = api;
+        this.subject = subject;
+    }
+    key(subject) {
+        return `krtu:${this.clientId}:entitlements:${subject}`;
+    }
+    /** Reads the current player's kept list. */
+    async load() {
+        const subject = this.subject();
+        this.cached = subject ? { subject, stored: (await this.store.get(this.key(subject))) ?? [], confirmed: new Map() } : null;
+    }
+    /** Reads the kept list unless this player's is already held (a launch's confirmed answers stay). */
+    async ensureLoaded() {
+        if (this.subject() && this.cached?.subject !== this.subject())
+            await this.load();
+    }
+    /** The player changed or signed out: nothing of the old player stays in memory. */
+    forget() {
+        this.cached = null;
+    }
+    current() {
+        return this.cached && this.cached.subject === this.subject() ? this.cached : null;
+    }
+    /** The licences as known now: the server's last answer, with `checked` on what it confirmed in this launch. */
+    list() {
+        const held = this.current();
+        return held ? held.stored.map((s) => held.confirmed.get(s.sku) ?? { ...s, checked: false }) : [];
+    }
+    async keep(held, stored) {
+        held.stored = stored;
+        await this.store.set(this.key(held.subject), stored);
+    }
+    /** The session answer's list: its checked items are this launch's confirmed answers, the whole list the server's last word. */
+    async fromSession(value) {
+        const subject = this.subject();
+        const items = itemsOf(value);
+        if (!subject || !items.length)
+            return;
+        await this.ensureLoaded();
+        const held = this.current();
+        if (!held)
+            return;
+        held.confirmed = new Map(items.filter((i) => i.checked).map((i) => [i.sku, i]));
+        await this.keep(held, items.map(({ checked: _checked, ...rest }) => rest));
+    }
+    /** `GET /v1/me/entitlements`: the stored licences replace what the kept list says (a DLC it no longer holds is kept as `null`, for its id). */
+    async refresh() {
+        const subject = this.subject();
+        if (!subject)
+            return [];
+        await this.ensureLoaded();
+        const answer = await this.api.player('/v1/me/entitlements');
+        const held = this.current();
+        if (!held)
+            return [];
+        const items = itemsOf(answer.json?.entitlements);
+        const listed = new Set(items.map((i) => i.sku));
+        const unlisted = held.stored.filter((s) => !listed.has(s.sku)).map((s) => ({ ...s, status: null }));
+        await this.keep(held, [...items.map(({ checked: _checked, ...rest }) => rest), ...unlisted]);
+        return this.list();
+    }
+    /**
+     * Whether the player owns the DLC `key` (its product key). `local` is the platform client's own
+     * answer for the DLC's platform id (Steam's), when the platform has one.
+     */
+    ownsDlc(key, local) {
+        const held = this.current();
+        const kept = held?.stored.find((s) => s.sku === key);
+        const confirmed = held?.confirmed.get(key);
+        if (confirmed)
+            return confirmed.status === 'ACTIVE';
+        if (local && kept?.platformProductId) {
+            const said = local(kept.platformProductId);
+            if (said !== null)
+                return said;
+        }
+        return kept?.status === 'ACTIVE';
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Every failure the SDK reports. `code` is the server's code (the server `{ error: { code } }`, Krtuworks ID's
+ * OAuth `error`), or one of the SDK's own:
+ *   - network_error: no answer (offline, DNS, a dropped connection); the call may or may not have arrived
+ *   - context_changed: the account or environment changed while the call ran; its answer was dropped
+ *   - signed_out: the call needs a player and none is signed in
+ *   - switched_off: the owner switched this build off (`message` says why)
+ */
+export declare class KrtuworksError extends Error {
+    /** HTTP status; 0 when nothing came back. */
+    readonly status: number;
+    readonly code: string;
+    /** Seconds to wait before trying again, when the server said so. */
+    readonly retryAfter: number | null;
+    /** The rest of the server's answer (`mergedInto`, `current`, `endsAt`, `terms` …). */
+    readonly details: Record<string, unknown>;
+    constructor(code: string, message: string, status?: number, retryAfter?: number | null, details?: Record<string, unknown>);
+    /** True when trying the same call again later can succeed (no answer, a busy or briefly closed server). */
+    get retryable(): boolean;
+}
+export declare function isKrtuworksError(err: unknown, code?: string): err is KrtuworksError;

package/dist/errors.js

@@ -0,0 +1,32 @@
+/**
+ * Every failure the SDK reports. `code` is the server's code (the server `{ error: { code } }`, Krtuworks ID's
+ * OAuth `error`), or one of the SDK's own:
+ *   - network_error: no answer (offline, DNS, a dropped connection); the call may or may not have arrived
+ *   - context_changed: the account or environment changed while the call ran; its answer was dropped
+ *   - signed_out: the call needs a player and none is signed in
+ *   - switched_off: the owner switched this build off (`message` says why)
+ */
+export class KrtuworksError extends Error {
+    /** HTTP status; 0 when nothing came back. */
+    status;
+    code;
+    /** Seconds to wait before trying again, when the server said so. */
+    retryAfter;
+    /** The rest of the server's answer (`mergedInto`, `current`, `endsAt`, `terms` …). */
+    details;
+    constructor(code, message, status = 0, retryAfter = null, details = {}) {
+        super(message);
+        this.name = 'KrtuworksError';
+        this.code = code;
+        this.status = status;
+        this.retryAfter = retryAfter;
+        this.details = details;
+    }
+    /** True when trying the same call again later can succeed (no answer, a busy or briefly closed server). */
+    get retryable() {
+        return this.status === 0 || this.status === 429 || this.status >= 500 || this.code === 'account_merging';
+    }
+}
+export function isKrtuworksError(err, code) {
+    return err instanceof KrtuworksError && (code === undefined || err.code === code);
+}

package/dist/events.d.ts

@@ -0,0 +1,93 @@
+import type { Api } from './api.js';
+import type { Clock } from './clock.js';
+import type { ResolvedOptions } from './config.js';
+import type { KrtuStore } from './store.js';
+export interface EventPosition {
+    space: 'world' | 'screen';
+    area: string;
+    x: number;
+    y: number;
+    z?: number;
+}
+/** An event as `/v1/events` takes it. */
+export interface WireEvent {
+    id: string;
+    type: string;
+    createdAt: string;
+    launchId: string;
+    monotonicMs: number;
+    serverOffsetMs?: number;
+    sessionId?: string;
+    build?: string;
+    schemaVersion?: number;
+    position?: EventPosition;
+    data?: Record<string, unknown>;
+}
+export declare const ANON = "anon";
+export interface EventQueueContext {
+    opts: ResolvedOptions;
+    store: KrtuStore;
+    clock: Clock;
+    api: Api;
+    /** Who the events are sent as now (null: nobody signed in). */
+    subject: () => string | null;
+}
+export interface FlushResult {
+    sent: number;
+    rejected: Array<{
+        id: string;
+        code: string;
+    }>;
+    /** Why the queue stopped early (network_error, switched_off …), null when it emptied. */
+    stoppedBy: string | null;
+}
+/**
+ * Telemetry events: every event is made with its id and
+ * bound to the player it is about (`anon` before any account; that queue goes to the first player).
+ * Queued events are written to the store before they are sent; a batch is frozen before its first send
+ * and sent again unchanged after a failure; each event's answer is read on its own: accepted, duplicate
+ * and rejected leave the queue, retry goes back with its id into a new batch.
+ */
+export declare class EventQueue {
+    private readonly ctx;
+    private buffer;
+    private persistTimer;
+    private notBefore;
+    private backoffMs;
+    constructor(ctx: EventQueueContext);
+    private key;
+    private lock;
+    private load;
+    private save;
+    /** Makes an event now, for whoever plays now. Kept in memory for a moment, then written to the store. */
+    add(event: Omit<WireEvent, 'id' | 'createdAt' | 'launchId' | 'monotonicMs' | 'serverOffsetMs'>): WireEvent;
+    /** Writes the events made since the last write; drops the oldest when the queue is full or too old. */
+    persist(): Promise<void>;
+    private trim;
+    /** Events waiting for `owner` (written and not yet written). */
+    size(owner: string): Promise<number>;
+    /**
+     * Moves `from`'s queue to `to`: the events made before any account go to the first player; a merged
+     * account's go to the one it went into (the server counts each event once by its id, and a batch it
+     * took under the old account answers the same under the new one).
+     */
+    move(from: string, to: string): Promise<void>;
+    private freeze;
+    /** The dropped-events count, said once as an SDK error event (if the app keeps errors). */
+    private droppedNotice;
+    /**
+     * Sends the signed-in player's queue, batch by batch, until it is empty or a send fails (the frozen
+     * batch then waits, unchanged, for the next flush).
+     */
+    flush(options?: {
+        errorsOn: boolean;
+        maxBatches?: number;
+    }): Promise<FlushResult>;
+    private sendBatch;
+    /** A batch never taken by the server goes back to the front of the queue (only before any answer said otherwise). */
+    private unfreeze;
+    private failed;
+    private backoff;
+    /** Lets the next flush try at once (back online, or the player changed). */
+    resetBackoff(): void;
+}