@indiegems/gem-web-sdk 7.4.2 → 7.6.0

package/dist/function.d.ts

@@ -0,0 +1,978 @@
+interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+type AuthFailure = "chain_exhausted" | "unavailable" | "timeout" | "internal";
+type AuthState = "ready" | "pending" | "degraded" | "lost";
+interface TokenGrant {
+    readonly token: string;
+    readonly expiresAt: number;
+    readonly chainEndsAt: number;
+}
+declare class AuthError extends Error {
+    readonly reason: AuthFailure;
+    constructor(reason: AuthFailure, message: string);
+    static isAuthError(error: unknown): error is AuthError;
+}
+declare class TransportRefusal extends Error {
+    readonly retryable: false;
+    constructor(message: string);
+    static isRefusal(error: unknown): error is TransportRefusal;
+}
+declare const CONDITIONAL_HEADERS: readonly [
+    "if-match",
+    "if-none-match"
+];
+type ConditionalRequestHeaders = Partial<Record<(typeof CONDITIONAL_HEADERS)[number], string>>;
+interface TransportRequest {
+    readonly method: "GET" | "PUT" | "POST" | "PATCH" | "DELETE";
+    readonly path: string;
+    readonly body?: unknown;
+    readonly bytes?: Uint8Array;
+    readonly responseType?: "json" | "bytes";
+    readonly headers?: ConditionalRequestHeaders;
+    readonly signal?: AbortSignal;
+    readonly keepalive?: boolean;
+}
+interface TransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+    readonly etag?: string;
+    readonly retryAfterSeconds?: number;
+    readonly invocationId?: string;
+}
+interface Transport {
+    request(request: TransportRequest): Promise<TransportResponse>;
+}
+type Base64String = string & {
+    readonly __contentEncoding: "base64";
+};
+declare function toBase64(value: string | Uint8Array): Base64String;
+type GemErrorReason = "invalid" | "forbidden" | "not_found" | "conflict" | "precondition_failed" | "not_modified" | "insufficient_funds" | "too_large" | "rate_limited" | "unavailable";
+declare class GemApiError extends Error {
+    readonly reason: GemErrorReason;
+    readonly status: number;
+    readonly detail: string;
+    readonly retryAfterSeconds?: number | undefined;
+    readonly code?: string | undefined;
+    constructor(reason: GemErrorReason, status: number, detail: string, retryAfterSeconds?: number | undefined, code?: string | undefined);
+    get retryable(): boolean;
+}
+interface ClientOptions {
+    readonly transport: Transport;
+    readonly clock: Clock;
+    readonly maxRetries?: number;
+}
+interface RequestOptions {
+    readonly keepalive?: boolean;
+    readonly ifMatch?: string;
+    readonly replaySafe?: boolean;
+}
+interface VersionedGetOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+type VersionedResponse<T> = {
+    readonly modified: true;
+    readonly body: T;
+    readonly etag?: string;
+} | {
+    readonly modified: false;
+    readonly etag?: string;
+};
+interface BytesResponse {
+    readonly bytes: Uint8Array;
+    readonly invocationId?: string;
+}
+declare class GemClient {
+    private readonly options;
+    constructor(options: ClientOptions);
+    get<T>(path: string, signal?: AbortSignal): Promise<T>;
+    getWithEtag<T>(path: string, options?: VersionedGetOptions): Promise<VersionedResponse<T>>;
+    put<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    postBytes(path: string, bytes: Uint8Array, signal?: AbortSignal, options?: RequestOptions): Promise<BytesResponse>;
+    patch<T>(path: string, body: unknown, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string, signal?: AbortSignal, options?: RequestOptions): Promise<T>;
+    private send;
+    private sendRaw;
+    private backoff;
+}
+type SessionEndReason = "grant_expiring" | "session_ended" | "navigating" | "kill_switch" | "pagehide";
+type PlatformEventName = "gem_session_start" | "gem_session_end" | "gem_pause" | "gem_resume" | "gem_boot_ready" | "gem_match_started" | "gem_match_ended" | "gem_auth_lost";
+type AnalyticsValue = string | number;
+interface AnalyticsRejection {
+    readonly index: number;
+    readonly code: string;
+}
+interface AnalyticsFlushResult {
+    readonly accepted: number;
+    readonly rejected: readonly AnalyticsRejection[];
+    readonly dropped: number;
+    readonly duplicate: boolean;
+}
+interface AnalyticsFlushOptions {
+    readonly keepalive?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface AnalyticsOptions {
+    readonly enabled?: boolean;
+    readonly flushIntervalMs?: number;
+    readonly maxQueue?: number;
+}
+interface AnalyticsApiOptions {
+    readonly environment?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+    readonly client: () => GemClient;
+    readonly clock: Clock;
+    readonly gameId: () => string | null;
+    readonly playerId: () => string | null;
+    readonly options?: AnalyticsOptions;
+    readonly log?: ((message: string) => void) | null;
+}
+declare class AnalyticsApi {
+    #private;
+    constructor(options: AnalyticsApiOptions);
+    track(name: string, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    setContext(props: Readonly<Record<string, AnalyticsValue>>): void;
+    get environment(): Readonly<Record<string, string>>;
+    flush(options?: AnalyticsFlushOptions): Promise<AnalyticsFlushResult>;
+    trackPlatform(name: PlatformEventName, props?: Readonly<Record<string, AnalyticsValue>>): void;
+    hold(): void;
+    release(): void;
+    get held(): boolean;
+    startSession(): void;
+    endSession(reason: SessionEndReason): void;
+    setPaused(paused: boolean): void;
+    setHidden(hidden: boolean): void;
+    dispose(): void;
+    get pending(): number;
+}
+interface GameApi {
+    readonly client: GemClient;
+    gameId(): string;
+}
+type Boundary = {
+    "boundary"?: string;
+    "reset_time"?: string;
+};
+type BucketConfig = Boundary & {
+    "grant_sources"?: OrderSource[];
+    "name": string;
+    "priority": number;
+    "reset_amount"?: number | null;
+    "reset_cap"?: number | null;
+    "reset_interval": BucketResetInterval;
+};
+type BucketResetInterval = "never" | "daily" | "weekly" | "monthly";
+type EntityType = "player" | "character";
+type ItemCategory = "cosmetic" | "progression";
+type OrderSource = "real_money_purchase" | "real_money_refund" | "full_game_purchase" | "full_game_refund" | "platform_purchase" | "reward" | "admin" | "system" | "promo" | "game_consume" | "play" | "recipe" | "transfer" | "platform_funded_game_inventory_purchase";
+type PlatformPrice = {
+    "platform_currency_id": string;
+    "price": number;
+};
+type SnapshotCurrency = {
+    "bucket_config"?: BucketConfig[] | null;
+    "display_name"?: string | null;
+    "history_tracking": boolean;
+    "id": string;
+    "max_balance": number;
+    "min_balance": number;
+    "slug"?: string | null;
+};
+type SnapshotItem = {
+    "category"?: ItemCategory;
+    "consumable": boolean;
+    "description"?: string | null;
+    "display_name"?: string | null;
+    "fungible": boolean;
+    "icon_url"?: string | null;
+    "id": string;
+    "item_type": string;
+    "metadata"?: unknown;
+    "platform_prices"?: PlatformPrice[];
+    "properties"?: Record<string, unknown> | null;
+    "slug"?: string | null;
+    "stack_size"?: number | null;
+    "transfer_mode": string;
+    "transfer_policy": string;
+};
+declare const MAX_PERIODS_BACK = 400;
+type ChallengeWindow = "daily" | "weekly" | "monthly" | "cron" | (string & {});
+interface Challenge {
+    readonly id: string;
+    readonly slug?: string;
+    readonly window: ChallengeWindow;
+    readonly periodStartAt: number;
+    readonly periodEndsAt: number;
+    readonly periodLocalDate?: string;
+    readonly boundary: string;
+    readonly resetTime: string;
+    readonly seed: string;
+    readonly data?: string;
+    readonly dataHash?: string;
+}
+interface ListChallengesOptions {
+    readonly periodsBack?: number;
+    readonly signal?: AbortSignal;
+}
+declare class ChallengesApi {
+    #private;
+    constructor(api: GameApi);
+    list(options?: ListChallengesOptions): Promise<Challenge[]>;
+}
+type CacheParam = string | number | boolean | undefined;
+declare class EntityReadCache {
+    private readonly clock;
+    private readonly identity?;
+    private generation;
+    private readonly slots;
+    private readonly listeners;
+    private boundTo;
+    constructor(clock: Clock, identity?: (() => string | null) | undefined);
+    read<T>(route: string, params: readonly CacheParam[], fetch: () => Promise<T>, maxAgeMs?: number): Promise<T>;
+    invalidate(): void;
+    onInvalidate(listener: () => void): () => void;
+    private rebind;
+}
+interface Page<T> {
+    readonly data: readonly T[];
+    readonly nextCursor?: string;
+}
+interface InventoryItem {
+    readonly itemDefinitionId: string;
+    readonly instanceId: string;
+    readonly quantity: number;
+    readonly acquiredAt: number;
+    readonly properties?: unknown;
+    readonly customData?: unknown;
+}
+interface Progression {
+    readonly progressionDefinitionId: string;
+    readonly currentValue: number;
+    readonly completionCount: number;
+    readonly isCompleted: boolean;
+    readonly achievements?: readonly ProgressionAchievement[];
+    readonly achievementsUnavailable?: boolean;
+}
+interface ProgressionAchievement {
+    readonly id: string;
+    readonly threshold: number;
+    readonly points: number;
+    readonly hidden: boolean;
+    readonly unlockedAt?: number;
+    readonly revoked?: boolean;
+}
+interface CurrencyBucket {
+    readonly bucket: string;
+    readonly balance: number;
+}
+interface CurrencyRow {
+    readonly currencyId: string;
+    readonly total: number;
+    readonly buckets?: readonly CurrencyBucket[];
+}
+interface InventorySnapshot {
+    readonly currencies: Page<CurrencyRow>;
+    readonly items: Page<InventoryItem>;
+    readonly progressions: Page<Progression>;
+    readonly etag?: string;
+}
+interface SnapshotPageOptions {
+    readonly currencyCursor?: string;
+    readonly itemCursor?: string;
+    readonly progressionCursor?: string;
+    readonly currencyLimit?: number;
+    readonly itemLimit?: number;
+    readonly progressionLimit?: number;
+    readonly includeBuckets?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface SnapshotOptions {
+    readonly buckets?: boolean;
+}
+declare class InventoryApi {
+    private readonly api;
+    private readonly entity;
+    private readonly cache;
+    constructor(api: GameApi, entity: EntityRef, cache: EntityReadCache);
+    snapshot(options?: SnapshotOptions): Promise<InventorySnapshot>;
+    instances(itemDefinitionId: string, signal?: AbortSignal): Promise<readonly InventoryItem[]>;
+    page(options: SnapshotPageOptions): Promise<InventorySnapshot>;
+    refresh(): void;
+    onChanged(listener: () => void): () => void;
+    invalidate(): void;
+    private fetch;
+}
+interface CurrencyBalance {
+    readonly currencyId: string;
+    readonly total: number | null;
+    readonly buckets?: readonly CurrencyBucket[];
+}
+interface CurrencyReadOptions {
+    readonly buckets?: boolean;
+}
+declare class CurrenciesApi {
+    private readonly inventory;
+    private readonly resolveCurrencyId?;
+    constructor(inventory: InventoryApi, resolveCurrencyId?: ((slugOrId: string) => Promise<string | undefined>) | undefined);
+    list(options?: CurrencyReadOptions): Promise<readonly CurrencyBalance[]>;
+    get(currencyId: string, options?: CurrencyReadOptions): Promise<CurrencyBalance>;
+}
+type GameOrderSource = "play" | "game_consume";
+interface RecipeAvailability {
+    readonly canExecute: boolean;
+    readonly reasons: readonly string[];
+    readonly usesRemaining?: number;
+    readonly cooldownExpiresAt?: string;
+    readonly locked: boolean;
+    readonly lockReasons: readonly RecipeLock[];
+}
+interface RecipeLock {
+    readonly prerequisiteType: string;
+    readonly referenceId: string;
+    readonly required: number;
+    readonly current: number;
+}
+interface RecipeUsage {
+    readonly recipeId: string;
+    readonly useCount: number;
+    readonly isOnCooldown: boolean;
+    readonly lastUsedAt?: string;
+    readonly cooldownExpiresAt?: string;
+}
+interface RecipeUsageList {
+    readonly usages: readonly RecipeUsage[];
+    readonly truncated: boolean;
+}
+type RecipeChange = {
+    readonly kind: "currency";
+    readonly currencyId: string;
+    readonly bucket: string;
+    readonly delta: number;
+    readonly balanceAfter: number;
+} | {
+    readonly kind: "item";
+    readonly itemDefinitionId: string;
+    readonly instanceId: string;
+    readonly delta: number;
+    readonly quantityAfter: number;
+} | {
+    readonly kind: "progression";
+    readonly progressionDefinitionId: string;
+    readonly delta: number;
+    readonly valueAfter: number;
+    readonly completed: boolean;
+} | {
+    readonly kind: "other";
+    readonly type: string;
+};
+interface LootRoll {
+    readonly entryId: string;
+    readonly rarityTier?: string;
+    readonly rollNumber: number;
+    readonly wasReplacement: boolean;
+    readonly grants: readonly RecipeChange[];
+}
+interface RecipeResult {
+    readonly orderId: string;
+    readonly status: string;
+    readonly etag?: string;
+    readonly granted: readonly RecipeChange[];
+    readonly consumed: readonly RecipeChange[];
+    readonly autoClaimedRewards: readonly RecipeChange[];
+    readonly lootResults?: readonly LootRoll[];
+}
+interface ConfiguredPurchasePayment {
+    readonly kind: "configured";
+}
+interface PlatformCurrencyPurchasePayment {
+    readonly kind: "platform_currency";
+    readonly currencySlug: string;
+}
+interface ConfiguredPurchaseRequest {
+    readonly kind: "recipe";
+    readonly catalogId: string;
+    readonly targetId: string;
+    readonly quantity?: 1;
+    readonly payment: ConfiguredPurchasePayment;
+}
+type PlatformCurrencyPurchaseRequest = {
+    readonly kind: "recipe";
+    readonly catalogId: string;
+    readonly targetId: string;
+    readonly quantity?: 1;
+    readonly payment: PlatformCurrencyPurchasePayment;
+} | {
+    readonly kind: "item";
+    readonly targetId: string;
+    readonly quantity?: number;
+    readonly payment: PlatformCurrencyPurchasePayment;
+};
+type DirectPurchaseRequest = ConfiguredPurchaseRequest | PlatformCurrencyPurchaseRequest;
+interface PurchaseOptions {
+    readonly ifMatch?: string;
+    readonly signal?: AbortSignal;
+}
+interface ConfiguredPurchaseResult extends RecipeResult {
+    readonly payment: "configured";
+}
+interface PlatformCurrencyPurchaseResult {
+    readonly payment: "platform_currency";
+    readonly orderId: string;
+    readonly status: string;
+    readonly purchaseId: string;
+    readonly sourceOrderId: string;
+    readonly price: {
+        readonly currencyId: string;
+        readonly amount: number;
+    };
+}
+type DirectPurchaseResult = ConfiguredPurchaseResult | PlatformCurrencyPurchaseResult;
+type InventoryOperation = {
+    readonly type: "currency_grant";
+    readonly currencyId: string;
+    readonly amount: number;
+} | {
+    readonly type: "currency_consume";
+    readonly currencyId: string;
+    readonly amount: number;
+} | {
+    readonly type: "item_grant";
+    readonly itemDefinitionId: string;
+    readonly quantity: number;
+} | {
+    readonly type: "item_remove";
+    readonly itemDefinitionId: string;
+    readonly quantity: number;
+};
+interface OrderOptions {
+    readonly source?: GameOrderSource;
+    readonly ifMatch?: string;
+    readonly signal?: AbortSignal;
+}
+interface OrderResult {
+    readonly orderId: string;
+    readonly status: string;
+    readonly etag?: string;
+}
+declare class MutationsApi {
+    private readonly api;
+    private readonly entity;
+    private readonly cache;
+    constructor(api: GameApi, entity: EntityRef, cache: EntityReadCache);
+    create(operations: readonly InventoryOperation[], options?: OrderOptions): Promise<OrderResult>;
+    createMany(orders: ReadonlyArray<readonly InventoryOperation[]>, options?: OrderOptions): Promise<unknown>;
+    recipeAvailability(catalogId: string, recipeId: string, signal?: AbortSignal): Promise<RecipeAvailability>;
+    recipeUsageAll(): Promise<RecipeUsageList>;
+    recipeUsage(recipeId: string): Promise<RecipeUsage | null>;
+    purchase(request: ConfiguredPurchaseRequest, options?: PurchaseOptions): Promise<ConfiguredPurchaseResult>;
+    purchase(request: PlatformCurrencyPurchaseRequest, options?: PurchaseOptions): Promise<PlatformCurrencyPurchaseResult>;
+    executeRecipe(catalogId: string, recipeId: string, options?: OrderOptions): Promise<RecipeResult>;
+    addProgression(progressionId: string, amount: number, signal?: AbortSignal): Promise<OrderResult>;
+    maxProgression(progressionId: string, value: number, signal?: AbortSignal): Promise<OrderResult>;
+    claimProgression(progressionId: string, signal?: AbortSignal): Promise<OrderResult>;
+    resetProgression(progressionId: string, signal?: AbortSignal): Promise<OrderResult>;
+    private write;
+}
+interface Order {
+    readonly orderId: string;
+    readonly status: string;
+    readonly source: string;
+    readonly createdAt: number;
+}
+interface OrderPageOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+declare class OrdersApi {
+    private readonly api;
+    private readonly entity;
+    constructor(api: GameApi, entity: EntityRef);
+    list(options?: OrderPageOptions): Promise<Page<Order>>;
+    get(orderId: string, signal?: AbortSignal): Promise<Order>;
+}
+declare class ProgressionsApi {
+    private readonly api;
+    private readonly entity;
+    private readonly inventory;
+    constructor(api: GameApi, entity: EntityRef, inventory: InventoryApi);
+    list(): Promise<readonly Progression[]>;
+    get(progressionDefinitionId: string, signal?: AbortSignal): Promise<Progression | null>;
+}
+interface SaveRecord {
+    readonly key: string;
+    readonly sizeBytes: number;
+    readonly etag: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+interface SavePage {
+    readonly saves: readonly SaveRecord[];
+    readonly nextCursor?: string;
+}
+declare class GemSaveError extends Error {
+    readonly reason: "upload_failed" | "download_failed" | "save_timeout" | "save_malformed";
+    constructor(reason: "upload_failed" | "download_failed" | "save_timeout" | "save_malformed", message: string);
+}
+interface SavesOptions {
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
+}
+interface PutSaveOptions {
+    readonly metadata?: Record<string, unknown>;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+interface PutBytesOptions extends PutSaveOptions {
+    readonly contentType?: string;
+}
+interface GetSaveOptions {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+interface DescribeSaveOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+interface ListSavesOptions {
+    readonly signal?: AbortSignal;
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+declare class SavesApi {
+    private readonly api;
+    private readonly entity;
+    private readonly options;
+    constructor(api: GameApi, entity: EntityRef, options?: SavesOptions);
+    put(key: string, value: unknown, options?: PutSaveOptions): Promise<SaveRecord>;
+    putBytes(key: string, bytes: Uint8Array, options?: PutBytesOptions): Promise<SaveRecord>;
+    get<T = unknown>(key: string, options?: GetSaveOptions): Promise<T | null>;
+    getBytes(key: string, options?: GetSaveOptions): Promise<Uint8Array | null>;
+    describe(key: string, options?: DescribeSaveOptions): Promise<SaveRecord | null>;
+    list(options?: ListSavesOptions): Promise<SavePage>;
+    delete(key: string, signal?: AbortSignal): Promise<void>;
+    private budget;
+    private timeout;
+    private rethrow;
+}
+interface Setting {
+    readonly key: string;
+    readonly value: string;
+    readonly etag?: string;
+    readonly updatedAt: number;
+}
+interface GetSettingOptions {
+    readonly signal?: AbortSignal;
+    readonly ifNoneMatch?: string;
+}
+interface PutSettingOptions {
+    readonly signal?: AbortSignal;
+    readonly ifMatch?: string;
+}
+declare class SettingsApi {
+    private readonly api;
+    private readonly entity;
+    constructor(api: GameApi, entity: EntityRef);
+    list(signal?: AbortSignal): Promise<readonly Setting[]>;
+    get(key: string, options?: GetSettingOptions): Promise<Setting | null>;
+    put(key: string, value: string, options?: PutSettingOptions): Promise<Setting>;
+    delete(key: string, signal?: AbortSignal): Promise<void>;
+}
+interface EntityRef {
+    readonly type: "players" | "characters";
+    readonly id: string;
+}
+interface EntityScope {
+    readonly settings: SettingsApi;
+    readonly inventory: InventoryApi;
+    readonly currencies: CurrenciesApi;
+    readonly mutations: MutationsApi;
+    readonly saves: SavesApi;
+    readonly orders: OrdersApi;
+    readonly progressions: ProgressionsApi;
+}
+interface Character extends EntityScope {
+    readonly id: string;
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: string;
+    readonly name: string;
+    readonly slotIndex: number;
+    readonly isActive: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface SlotInfo {
+    readonly totalSlots: number;
+    readonly availableSlots: number;
+    readonly activeCharacterCount: number;
+    readonly defaultMaxSlots: number;
+    readonly purchasedExtraSlots: number;
+    readonly canPurchaseMore: boolean;
+}
+interface CreateCharacterOptions {
+    readonly name: string;
+    readonly signal?: AbortSignal;
+}
+declare class CharactersApi {
+    private readonly api;
+    private readonly saves?;
+    private readonly identity?;
+    private readonly resolveCurrencyId?;
+    private readonly scopes;
+    constructor(api: GameApi, saves?: SavesOptions | undefined, identity?: (() => string | null) | undefined, resolveCurrencyId?: ((slugOrId: string) => Promise<string | undefined>) | undefined);
+    private readonly scope;
+    list(signal?: AbortSignal): Promise<readonly Character[]>;
+    get(id: string, signal?: AbortSignal): Promise<Character>;
+    create(options: CreateCharacterOptions): Promise<Character>;
+    update(id: string, name: string, signal?: AbortSignal): Promise<Character>;
+    delete(id: string, signal?: AbortSignal): Promise<void>;
+    slots(signal?: AbortSignal): Promise<SlotInfo>;
+}
+declare class PlayerText {
+    #private;
+    constructor(value: string);
+    toString(): string;
+    toJSON(): string;
+    get [Symbol.toStringTag](): string;
+    static unwrap(t: PlayerText): string;
+}
+declare function asPlayerText(value: string): PlayerText;
+declare const text: {
+    toPlain(t: PlayerText): string;
+    compare(a: PlayerText | string, b: PlayerText | string, locale?: string): number;
+    equals(a: PlayerText | string, b: PlayerText | string): boolean;
+};
+type TransferDirection = "incoming" | "outgoing";
+interface Transfer {
+    readonly id: string;
+    readonly status: string;
+    readonly sourceEntityId: string;
+    readonly targetEntityId: string;
+    readonly message?: PlayerText;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly resolvedAt?: string;
+}
+interface InitiateTransferOptions {
+    readonly to: EntityRef;
+    readonly items?: ReadonlyArray<{
+        itemDefinitionId: string;
+        quantity: number;
+    }>;
+    readonly currencies?: ReadonlyArray<{
+        currencyId: string;
+        amount: number;
+    }>;
+    readonly message?: string;
+    readonly signal?: AbortSignal;
+}
+interface ListTransfersOptions {
+    readonly direction?: TransferDirection;
+    readonly status?: string;
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+declare class TransfersApi {
+    private readonly api;
+    private readonly self;
+    private readonly inventory;
+    constructor(api: GameApi, self: EntityRef, inventory: InventoryApi);
+    initiate(options: InitiateTransferOptions): Promise<Transfer>;
+    list(options?: ListTransfersOptions): Promise<{
+        readonly transfers: readonly Transfer[];
+        readonly nextCursor?: string;
+    }>;
+    get(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    accept(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    reject(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    cancel(transferId: string, signal?: AbortSignal): Promise<Transfer>;
+    private resolve;
+}
+interface PlayerBadge {
+    readonly itemId: string;
+    readonly iconUrl: string;
+}
+interface PlayerIdentity {
+    readonly playerId?: string;
+    readonly displayName?: PlayerText;
+    readonly discriminator?: string;
+    readonly displayTag?: PlayerText;
+    readonly avatarIconId?: string;
+    readonly avatarIconUrl?: string;
+    readonly badges: readonly PlayerBadge[];
+}
+declare function mapIdentity(row: unknown): PlayerIdentity;
+declare function platformIconUrl(url: string | undefined): string | undefined;
+interface Friend extends PlayerIdentity {
+    readonly playerId: string;
+}
+interface FriendsPage {
+    readonly friends: readonly Friend[];
+    readonly nextCursor?: string;
+}
+interface ListFriendsOptions {
+    readonly limit?: number;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+interface FriendChallengeRequest {
+    readonly playerId: string;
+    readonly template: string;
+    readonly params?: Readonly<Record<string, string | number>>;
+}
+type FriendChallengeOutcomeKind = "accepted" | "cancelled" | "refused" | "unavailable";
+interface FriendChallengeOutcome {
+    readonly outcome: FriendChallengeOutcomeKind;
+}
+type FriendChallengeErrorCode = "unknown_template" | "template_not_on_channel" | "param_invalid" | "param_undeclared" | "recipient_invalid" | (string & {});
+declare class FriendChallengeError extends GemApiError {
+    readonly code?: FriendChallengeErrorCode;
+    readonly param?: string;
+    readonly channel?: string;
+    readonly configVersion?: number;
+    constructor(source: GemApiError, extra?: {
+        readonly param?: string;
+        readonly channel?: string;
+        readonly configVersion?: number;
+    });
+}
+interface FriendsApiDependencies {
+    readonly challenge?: (request: FriendChallengeRequest) => Promise<FriendChallengeOutcome>;
+}
+declare class FriendsApi {
+    #private;
+    constructor(api: GameApi, dependencies?: FriendsApiDependencies);
+    list(options?: ListFriendsOptions): Promise<FriendsPage>;
+    challenge(request: FriendChallengeRequest): Promise<FriendChallengeOutcome>;
+}
+interface LeaderboardEntry extends RankedRow, PlayerIdentity {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly entityId?: string;
+    readonly entityType?: EntityType;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
+    readonly isViewer?: boolean;
+}
+interface Leaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly entries: readonly LeaderboardEntry[];
+    readonly generatedAt: number;
+    readonly updateFrequencySeconds?: number;
+}
+interface RankedRow {
+    readonly rank: number;
+    readonly occurredAt: number;
+    readonly stats?: Readonly<Record<string, number>>;
+    readonly properties?: Readonly<Record<string, unknown>>;
+}
+interface EntityLeaderboardEntry extends RankedRow {
+    readonly rank: number;
+    readonly stats?: Readonly<Record<string, number>>;
+}
+interface EntityLeaderboard {
+    readonly leaderboardType: string;
+    readonly runType: string;
+    readonly entityType: EntityType;
+    readonly entityId: string;
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly entries: readonly EntityLeaderboardEntry[];
+    readonly personalBest: EntityLeaderboardEntry | null;
+    readonly totalRuns: number;
+    readonly totalRunsExact: boolean;
+    readonly generatedAt: number;
+}
+interface EntityLeaderboardOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+interface GetLeaderboardOptions {
+    readonly bucket1?: string;
+    readonly bucket2?: string;
+    readonly signal?: AbortSignal;
+}
+declare class LeaderboardsApi {
+    #private;
+    constructor(api: GameApi);
+    get(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
+    friends(leaderboardType: string, options?: GetLeaderboardOptions): Promise<Leaderboard>;
+    mine(leaderboardType: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
+    character(leaderboardType: string, characterId: string, options?: EntityLeaderboardOptions): Promise<EntityLeaderboard>;
+}
+type PlatformCurrencyAccess = "read" | "spend";
+interface PlatformCurrency {
+    readonly slug: string;
+    readonly currencyId: string;
+    readonly balance: number;
+    readonly access: PlatformCurrencyAccess;
+}
+interface PlatformCurrencyReadOptions {
+    readonly signal?: AbortSignal;
+}
+declare class PlatformCurrenciesApi {
+    #private;
+    constructor(api: GameApi);
+    get(options?: PlatformCurrencyReadOptions): Promise<readonly PlatformCurrency[]>;
+}
+type EarnAllowancePeriod = "day" | "window";
+interface EarnAllowance {
+    readonly currencySlug: string;
+    readonly currencyId: string;
+    readonly limit: number;
+    readonly earned: number;
+    readonly remaining: number;
+    readonly period: EarnAllowancePeriod;
+    readonly periodDays: number;
+    readonly resetsAt?: number;
+}
+interface EarnAllowanceReadOptions {
+    readonly signal?: AbortSignal;
+}
+interface EarnAllowanceSignal {
+    on(listener: () => void): () => void;
+    emit(): void;
+}
+type EarnAllowanceEvent = "changed";
+declare class PlatformEarnAllowanceApi {
+    #private;
+    constructor(api: GameApi, signal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
+    get(options?: EarnAllowanceReadOptions): Promise<readonly EarnAllowance[]>;
+    on(event: EarnAllowanceEvent, listener: () => void): () => void;
+}
+declare class PlatformApi {
+    readonly currencies: PlatformCurrenciesApi;
+    readonly earnAllowance: PlatformEarnAllowanceApi;
+    constructor(api: GameApi, earnAllowanceSignal?: EarnAllowanceSignal, log?: ((line: string) => void) | null);
+}
+interface ProfileShowcaseEntry {
+    readonly key: string;
+    readonly visibility: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
+}
+interface PlayerProfile extends PlayerIdentity {
+    readonly playerId: string;
+    readonly showcase: readonly ProfileShowcaseEntry[];
+    readonly generatedAt: number;
+}
+interface ProfileCallOptions {
+    readonly signal?: AbortSignal;
+}
+declare class ProfilesApi {
+    #private;
+    constructor(api: GameApi);
+    of(playerId: string, options?: ProfileCallOptions): Promise<PlayerProfile | null>;
+}
+interface ShowcaseValue {
+    readonly playerId: string;
+    readonly key: string;
+    readonly value: unknown;
+    readonly updatedAt: number;
+}
+interface ShowcaseFriendEntry extends PlayerIdentity {
+    readonly playerId: string;
+    readonly value: unknown;
+    readonly isViewer: boolean;
+    readonly updatedAt: number;
+}
+interface ShowcaseFriends {
+    readonly key: string;
+    readonly entries: readonly ShowcaseFriendEntry[];
+    readonly generatedAt: number;
+}
+interface ShowcaseCallOptions {
+    readonly signal?: AbortSignal;
+}
+declare class ShowcaseApi {
+    private readonly api;
+    private readonly selfPlayerId;
+    constructor(api: GameApi, selfPlayerId: () => Promise<string>);
+    friends(key: string, options?: ShowcaseCallOptions): Promise<ShowcaseFriends>;
+    of(playerId: string, key: string, options?: ShowcaseCallOptions): Promise<ShowcaseValue | null>;
+    set(key: string, value: unknown, options?: ShowcaseCallOptions): Promise<ShowcaseValue>;
+    clear(key: string, options?: ShowcaseCallOptions): Promise<void>;
+}
+interface FunctionContext {
+    readonly gameId: string;
+    readonly channel: "dev" | "test" | "release";
+    readonly invocationId: string;
+    readonly caller: {
+        readonly type: "player";
+        readonly playerId: string;
+    } | {
+        readonly type: "game-server";
+        readonly serverId: string | null;
+    };
+}
+declare global {
+    var __gemFunctionHost: {
+        context(): FunctionContext;
+    } | undefined;
+}
+interface GemFunctionIdentity {
+    readonly playerId: string;
+    readonly gameId: string;
+    readonly channel: string;
+}
+interface GemFunction {
+    readonly context: FunctionContext;
+    readonly identity: GemFunctionIdentity | null;
+    awaitIdentity(timeoutMs?: number): Promise<GemFunctionIdentity>;
+    awaitBridge(timeoutMs?: number): Promise<"connected">;
+    readonly client: GemClient;
+    readonly me: EntityScope;
+    readonly characters: CharactersApi;
+    readonly transfers: TransfersApi;
+    readonly analytics: AnalyticsApi;
+    readonly leaderboards: LeaderboardsApi;
+    readonly challenges: ChallengesApi;
+    readonly showcase: ShowcaseApi;
+    readonly friends: FriendsApi;
+    readonly platform: PlatformApi;
+    readonly profiles: ProfilesApi;
+}
+declare function createGem(options?: unknown): GemFunction;
+interface FunctionInvokeOptions {
+    readonly signal?: AbortSignal;
+}
+interface FunctionResult {
+    readonly bytes: Uint8Array;
+    readonly invocationId?: string;
+    text(): string;
+    json<T = unknown>(): T;
+}
+type FunctionFailure = "trap" | "memory_exceeded" | "cpu_budget_exceeded" | "host_call_limit";
+declare class GemFunctionError extends GemApiError {
+    readonly invocationId?: string;
+    readonly functionMessage?: string;
+    readonly failure?: FunctionFailure | (string & {});
+    constructor(source: GemApiError, extra: {
+        readonly invocationId?: string;
+        readonly functionMessage?: string;
+        readonly failure?: string;
+    });
+    get retryable(): boolean;
+}
+interface PlayerBoostMultiplier {
+    readonly currencyId: string;
+    readonly currencySlug: string;
+    readonly multiplier: number;
+}
+interface PlayerBoost {
+    readonly active: boolean;
+    readonly multipliers: readonly PlayerBoostMultiplier[];
+    readonly expiresInDays?: number;
+}
+export { AnalyticsApi, type AnalyticsApiOptions, type AnalyticsFlushOptions, type AnalyticsFlushResult, type AnalyticsOptions, type AnalyticsRejection, type AnalyticsValue, AuthError, type AuthFailure, type AuthState, type Base64String, type Boundary, type BucketConfig, type BucketResetInterval, type BytesResponse, CONDITIONAL_HEADERS, type CacheParam, type Challenge, type ChallengeWindow, ChallengesApi, type Character, CharactersApi, type ClientOptions, type Clock, type ConditionalRequestHeaders, type ConfiguredPurchasePayment, type ConfiguredPurchaseRequest, type ConfiguredPurchaseResult, type CreateCharacterOptions, CurrenciesApi, type CurrencyBalance, type CurrencyBucket, type CurrencyReadOptions, type CurrencyRow, type DescribeSaveOptions, type DirectPurchaseRequest, type DirectPurchaseResult, type EarnAllowance, type EarnAllowanceEvent, type EarnAllowancePeriod, type EarnAllowanceReadOptions, type EarnAllowanceSignal, type EntityLeaderboard, type EntityLeaderboardEntry, type EntityLeaderboardOptions, EntityReadCache, type EntityRef, type EntityScope, type EntityType, type Friend, FriendChallengeError, type FriendChallengeErrorCode, type FriendChallengeOutcome, type FriendChallengeOutcomeKind, type FriendChallengeRequest, FriendsApi, type FriendsApiDependencies, type FriendsPage, type FunctionContext, type FunctionFailure, type FunctionInvokeOptions, type FunctionResult, type GameApi, type GameOrderSource, GemApiError, GemClient, type GemErrorReason, type GemFunction, GemFunctionError, type GemFunctionIdentity, GemSaveError, type GetLeaderboardOptions, type GetSaveOptions, type GetSettingOptions, type InitiateTransferOptions, InventoryApi, type InventoryItem, type InventoryOperation, type InventorySnapshot, type ItemCategory, type Leaderboard, type LeaderboardEntry, LeaderboardsApi, type ListChallengesOptions, type ListFriendsOptions, type ListSavesOptions, type ListTransfersOptions, type LootRoll, MAX_PERIODS_BACK, MutationsApi, type Order, type OrderOptions, type OrderPageOptions, type OrderResult, type OrderSource, OrdersApi, type Page, PlatformApi, PlatformCurrenciesApi, type PlatformCurrency, type PlatformCurrencyAccess, type PlatformCurrencyPurchasePayment, type PlatformCurrencyPurchaseRequest, type PlatformCurrencyPurchaseResult, type PlatformCurrencyReadOptions, PlatformEarnAllowanceApi, type PlatformEventName, type PlatformPrice, type PlayerBadge, type PlayerBoost, type PlayerBoostMultiplier, type PlayerIdentity, type PlayerProfile, PlayerText, type ProfileCallOptions, type ProfileShowcaseEntry, ProfilesApi, type Progression, type ProgressionAchievement, ProgressionsApi, type PurchaseOptions, type PutBytesOptions, type PutSaveOptions, type PutSettingOptions, type RankedRow, type RecipeAvailability, type RecipeChange, type RecipeLock, type RecipeResult, type RecipeUsage, type RecipeUsageList, type RequestOptions, type SavePage, type SaveRecord, SavesApi, type SavesOptions, type SessionEndReason, type Setting, SettingsApi, ShowcaseApi, type ShowcaseCallOptions, type ShowcaseFriendEntry, type ShowcaseFriends, type ShowcaseValue, type SlotInfo, type SnapshotCurrency, type SnapshotItem, type SnapshotOptions, type SnapshotPageOptions, type TokenGrant, type Transfer, type TransferDirection, TransfersApi, type Transport, TransportRefusal, type TransportRequest, type TransportResponse, type VersionedGetOptions, type VersionedResponse, asPlayerText, createGem, mapIdentity, platformIconUrl, text, toBase64 };