@phantomclient/plugin 0.1.0 → 0.1.1

package/dist/types/vue.d.ts

@@ -42,6 +42,10 @@ declare const Achievements: PacketDefinition<{
     archived: boolean;
     achievements: AchievementEntry[];
 }>;
+type AdoptAPetCard = {
+    defId: number;
+    invId: number;
+};
 type RoomPet = {
     lBits: number;
     uBits: number;
@@ -119,6 +123,18 @@ type OwnListedAvatar = {
     avTypeId: number;
     customAvId: number;
 };
+type AvatarListFields = {
+    own: true;
+    userName: string;
+    slotFlags: number;
+    uuid: string;
+    avatars: OwnListedAvatar[];
+} | {
+    own: false;
+    userName: string;
+    perUserAvIds: number[];
+};
+declare const AvatarList: PacketDefinition<AvatarListFields>;
 type LookedUpAvatar = {
     accountType: number;
     isGuide: boolean;
@@ -153,6 +169,39 @@ type AvatarLookupFields = {
     avatar: LookedUpAvatar | null;
 };
 declare const AvatarLookup: PacketDefinition<AvatarLookupFields>;
+declare const AvatarKilled: PacketDefinition<{
+    success: boolean;
+    extra: number;
+}>;
+type AvatarNameIds = readonly [
+    number,
+    number,
+    number
+];
+declare const AvatarAdded: PacketDefinition<{
+    status: number;
+    perUserAvId: number;
+    avInvId: number;
+}>;
+declare const AvatarSlotBought: PacketDefinition<{
+    success: boolean;
+}>;
+declare const AvatarFastPassAdded: PacketDefinition<{
+    success: boolean;
+}>;
+declare const AvatarNameBarChanged: PacketDefinition<{
+    userId: number;
+    nameBarData: number;
+}>;
+declare const AvatarOrdained: PacketDefinition<{
+    success: boolean;
+}>;
+declare const AvatarPhotoTaken: PacketDefinition<{
+    gems: number;
+}>;
+declare const AvatarPhotoChecked: PacketDefinition<{
+    gems: number;
+}>;
 type BuddyEntry = {
     userName: string;
     uuid: string;
@@ -161,6 +210,16 @@ type BuddyEntry = {
     accountType: number;
     partyTimeLeft: number | null;
 };
+declare const BuddyList: PacketDefinition<{
+    blocked: boolean;
+    buddies: BuddyEntry[];
+    blockedUserNames: string[];
+}>;
+declare const BuddyAddResult: PacketDefinition<{
+    status: number;
+    userName: string;
+    userNameModerationFlag: number;
+}>;
 declare const BuddyLocation: PacketDefinition<{
     roomName: string;
     displayName: string;
@@ -213,8 +272,8 @@ declare const DenPrivacy: {
 type DenPrivacy = (typeof DenPrivacy)[keyof typeof DenPrivacy];
 declare const DenVisitorCount: PacketDefinition<{
     count: number;
-    countsOwner: boolean;
-    ownerName: string;
+    entering: boolean;
+    userName: string;
 }>;
 type DenRoom = {
     invIdx: number;
@@ -229,6 +288,90 @@ type DenMasterpieceItem = {
     uniqueImageCreatorDbId: number;
     uniqueImageCreatorUUID: string;
 };
+type DenMannequinLook = {
+    baseColor: number;
+    patternColor: number;
+    patternDefId: number;
+    eyeColor: number;
+    eyeDefId: number;
+};
+declare const MANNEQUIN_SLOTS: readonly [
+    "tail",
+    "leg",
+    "back",
+    "neck",
+    "head"
+];
+type MannequinSlot = (typeof MANNEQUIN_SLOTS)[number];
+type DenMannequinInvIds = DenMannequinLook & {
+    tailInvId: number;
+    legInvId: number;
+    backInvId: number;
+    neckInvId: number;
+    headInvId: number;
+};
+type DenMannequinWorn = {
+    defId: number;
+    color: number;
+    invIdx: number;
+};
+type DenMannequinOutfit = DenMannequinLook & Record<MannequinSlot, DenMannequinWorn>;
+type DenOwnedItem = {
+    invIdx: number;
+    defId: number;
+    categoryId: number;
+    version: number;
+    approved: boolean;
+    uniqueImageId: string;
+    uniqueImageCreatorDbId: number;
+    uniqueImageCreatorUUID: string;
+    mannequin: DenMannequinInvIds | null;
+    denStoreInvId: number;
+};
+type DenStateEntry = {
+    invIdx: number;
+    defId: number;
+    placed: boolean;
+    x: number;
+    y: number;
+    version: number;
+    flipped: number;
+    userNameLink: string | null;
+    uniqueImageId: string;
+    uniqueImageCreatorDbId: number;
+    uniqueImageCreatorUUID: string;
+    mannequin: DenMannequinOutfit | null;
+    ecoConsumerStateId: number;
+};
+type DenStatePet = {
+    invIdx: number;
+    lBits: number;
+    uBits: number;
+    eBits: number;
+    catId: number;
+    x: number;
+    y: number;
+    flipped: number;
+    createdTs: number;
+    traitDefId: number;
+    toyDefId: number;
+    foodDefId: number;
+    name: string;
+};
+type DenStateChange = {
+    refId: number;
+    invIdx: number;
+    placed: boolean;
+    x: number;
+    y: number;
+    flipped: number;
+    userNameLink: string;
+    mannequin: DenMannequinInvIds | null;
+};
+type DenEcoConsumer = {
+    invIdx: number;
+    stateId: number;
+};
 type JamAGram = {
     messageId: number;
     senderUserName: string;
@@ -374,6 +517,28 @@ declare const MinigameLeaderboard: PacketDefinition<{
     thisWeek: LeaderboardEntry[];
     buddies: LeaderboardEntry[];
 }>;
+type MinigameAwardSums = {
+    amountSum: number;
+    gameSum: number;
+    checkSum: number;
+};
+type MinigameAward = {
+    amount: number;
+    gameDefId: number;
+    userId: number;
+};
+type MinigameScoreSums = {
+    mainSum: number;
+    valueSum: number;
+    numSum: number;
+    varRefSum: number;
+    gameSum: number;
+};
+type MinigameScore = {
+    score: number;
+    leaderboardUserVarRef: number;
+    gameDefId: number;
+};
 declare const NewspaperPageSeen: PacketDefinition<{
     defId: number;
     timeSeen: number;
@@ -390,6 +555,14 @@ type CustomParty = {
     defId: number;
     timeLeft: number;
 };
+type PoolMasterpiece = {
+    frameId: number;
+    resourceId: number;
+    userName: string;
+    creatorDbId: number;
+    creatorUuid: string;
+    raw: Record<string, unknown>;
+};
 declare const CustomPartyHostResult: PacketDefinition<{
     secondsLeft: number | null;
     hosting: boolean;
@@ -430,6 +603,12 @@ type QuestJoinOutcome = {
     extra: string[];
 };
 declare const QuestJoinResult: PacketDefinition<QuestJoinOutcome>;
+declare const QuestWaiting: PacketDefinition<{
+    userIds: number[];
+}>;
+declare const QuestJoinCancelled: PacketDefinition<{
+    extra: string[];
+}>;
 type QuestActorInfo = {
     actorId: string;
     type: number;
@@ -477,15 +656,119 @@ declare const QuestAward: PacketDefinition<{
     userVarId: number;
     value: number;
 }>;
+declare const QuestExitByType: PacketDefinition<{
+    exitType: string;
+}>;
+type QuestBundledMessage = {
+    command: string;
+    args: string[];
+};
+type QuestDroppedTreasure = {
+    subType: number;
+    denDefId: number | null;
+    itemDefId: number | null;
+    color: number | null;
+    amount: number | null;
+};
+declare const QuestActorSpawned: PacketDefinition<{
+    spawnedFrom: string;
+    actorId: string;
+    type: number;
+    defId: number;
+    dropped: QuestDroppedTreasure | null;
+    spawnOffset: {
+        x: number;
+        y: number;
+    } | null;
+    extra: string[];
+}>;
+declare const QuestActorMoved: PacketDefinition<{
+    actorId: string;
+    x: number;
+    y: number;
+    velocity: number;
+    seekType: number;
+    nearestX: number;
+    nearestY: number;
+}>;
 declare const QuestActorSeek: PacketDefinition<{
     actorId: string;
     seekType: number;
     userId: number;
 }>;
+declare const QuestActorHealth: PacketDefinition<{
+    actorId: string;
+    healthPercent: number;
+    missed: boolean;
+    damage: number | null;
+    fierce: boolean | null;
+    extra: string[];
+}>;
+declare const QuestActorDied: PacketDefinition<{
+    actorId: string;
+    damage: number;
+    moved: boolean;
+    x: number;
+    y: number;
+    otherActorId: string;
+}>;
+declare const QuestActorRestored: PacketDefinition<{
+    actorId: string;
+    healthPercent: number;
+}>;
+declare const QuestCommand: PacketDefinition<{
+    command: number;
+    actorId: null;
+    state: null;
+    visible: null;
+    requireClick: null;
+    args: string[];
+} | {
+    command: 1;
+    actorId: string;
+    state: number;
+    visible: boolean | null;
+    requireClick: boolean | null;
+    args: string[];
+}>;
+declare const QuestVariable: PacketDefinition<{
+    command: number;
+    actorId: null;
+    state: null;
+    visible: null;
+    requireClick: null;
+    args: string[];
+} | {
+    command: 1;
+    actorId: string;
+    state: number;
+    visible: boolean | null;
+    requireClick: boolean | null;
+    args: string[];
+}>;
+declare const QuestActorSwfState: PacketDefinition<{
+    actorId: string;
+    swfState: string;
+}>;
+declare const QuestActorPath: PacketDefinition<{
+    actorId: string;
+    pathName: string;
+}>;
 declare const QuestActorIcon: PacketDefinition<{
     actorId: string;
     showing: boolean;
 }>;
+type QuestMovedItem = {
+    actorId: string;
+    innerRadius: number;
+    outerRadius: number;
+    x: number;
+    y: number;
+};
+declare const QuestMovedItems: PacketDefinition<{
+    items: QuestMovedItem[];
+    extra: string[];
+}>;
 declare const QuestPickUpResult: PacketDefinition<{
     extra: string[];
     result: number;
@@ -504,6 +787,9 @@ declare const QuestGiveItem: PacketDefinition<{
 declare const QuestPlayerDead: PacketDefinition<{
     userId: number;
 }>;
+declare const QuestCrystals: PacketDefinition<{
+    crystals: number;
+}>;
 declare const QuestExited: PacketDefinition<{
     extra: string[];
 }>;
@@ -544,6 +830,75 @@ declare const QuestAvSwitch: PacketDefinition<{
     avatarRefId: number | null;
     userId: number;
 }>;
+declare const QuestPlayerAttacked: PacketDefinition<{
+    actorId: string;
+    userId: number;
+    weaponDefId: number;
+    color: number;
+}>;
+declare const QuestBeamZapped: PacketDefinition<{
+    actorId: string;
+    userId: number;
+}>;
+declare const QuestPhantomZapped: PacketDefinition<{
+    actorId: string;
+    userId: number;
+}>;
+declare const QuestProjectileLaunched: PacketDefinition<{
+    weaponDefId: number;
+    x: number;
+    y: number;
+    actorId: string;
+    userId: number;
+    color: number;
+}>;
+declare const QuestSwiped: PacketDefinition<{
+    weaponDefId: number;
+    x: number;
+    y: number;
+    actorId: string;
+    userId: number;
+    color: number;
+}>;
+declare const QuestRespawnGranted: PacketDefinition<{
+    extra: string[];
+}>;
+declare const QuestSideScrollMoved: PacketDefinition<{
+    userId: number;
+    x: number;
+    y: number;
+    extra: string[];
+}>;
+declare const QuestPlayerRoomChange: PacketDefinition<{
+    userId: number;
+    roomName: string;
+    x: number;
+    y: number;
+}>;
+declare const QuestTorch: PacketDefinition<{
+    target: number;
+    lit: boolean;
+    actorId: string | null;
+    userId: number | null;
+}>;
+declare const QuestPlaySwf: PacketDefinition<{
+    mediaId: number;
+}>;
+declare const QuestPreloadSwf: PacketDefinition<{
+    mediaId: number;
+}>;
+declare const QuestFade: PacketDefinition<{
+    fadeIn: boolean;
+}>;
+declare const QuestShake: PacketDefinition<{
+    milliseconds: number;
+}>;
+declare const QuestMusic: PacketDefinition<{
+    name: string;
+}>;
+declare const QuestPostUri: PacketDefinition<{
+    uri: string;
+}>;
 type JoinedRoom = {
     name: string;
     id: number;
@@ -766,6 +1121,12 @@ type ShardNode = {
 declare const NodeHop: PacketDefinition<{
     host: string;
 }>;
+type Referral = {
+    userName: string;
+    moderatedUserName: string | null;
+    nameBarData: number | null;
+    accountType: string;
+};
 interface ClientClasses {
     [name: string]: any;
 }
@@ -1039,7 +1400,7 @@ type KeySpec = {
     alt: boolean | null;
     phase: "down" | "up";
     consume: boolean;
-    whileTyping: boolean;
+    whileTyping: "never" | "empty" | "always";
     repeat: boolean;
 };
 type NoteVerb = "write" | "read" | "has" | "forget" | "keys" | "clear";
@@ -1406,6 +1767,7 @@ type BridgeMessage = {
     shift: boolean;
     alt: boolean;
     phase: "down" | "up";
+    consumed?: boolean;
 };
 type BridgeErrorCode = "FLASH" | "TIMEOUT" | "CLOSED" | "NOT_READY" | "VERSION";
 declare class BridgeError extends Error {
@@ -1857,6 +2219,7 @@ type OverlayNode = (() => Promise<void>) & {
     on(event: OverlayMouseEvent, listener: (position: Position) => void): () => Promise<void>;
     on(event: "link", listener: (value: string) => void): () => Promise<void>;
     onFailed(listener: (message: string) => void): () => void;
+    onRemoved(listener: () => void): () => void;
 };
 type InputNode = OverlayNode & {
     update(changes: InputOptions): Promise<void>;
@@ -1962,7 +2325,7 @@ type FoundPlaces<Name> = Name extends keyof ClientInstances ? TypedFlash<ClientI
 type KeyOptions = {
     phase?: "down" | "up";
     consume?: boolean;
-    whileTyping?: boolean;
+    whileTyping?: boolean | "never" | "empty" | "always";
     repeat?: boolean;
 };
 type KeyPress = {
@@ -1972,6 +2335,7 @@ type KeyPress = {
     shift: boolean;
     alt: boolean;
     phase: "down" | "up";
+    consumed: boolean;
 };
 declare class FlashNotes<Value extends FlashData = FlashData> {
     private readonly bridge;
@@ -2094,6 +2458,9 @@ type PacketProblem = {
     error: Error;
     text: string;
 };
+type PacketWatchOptions = {
+    original?: boolean;
+};
 type MessageHook = (message: Message) => void | Promise<void>;
 declare class Side {
     private readonly channel;
@@ -2105,156 +2472,30 @@ declare class Side {
     send(what: Message | string): Promise<void>;
     on<Fields>(what: PacketDefinition<Fields>, hook: PacketHook<Fields>): Unsubscribe;
     on(what: string, hook: MessageHook): Unsubscribe;
-    watch<Fields>(what: PacketDefinition<Fields>, listener: (packet: Packet<Fields>) => void): Unsubscribe;
-    watch(what: string, listener: (message: Message) => void): Unsubscribe;
+    watch<Fields>(what: PacketDefinition<Fields>, listener: (packet: Packet<Fields>) => void, options?: PacketWatchOptions): Unsubscribe;
+    watch(what: string, listener: (message: Message) => void, options?: PacketWatchOptions): Unsubscribe;
     private read;
     private checked;
 }
-declare const BUBBLES: readonly [
-    {
-        readonly id: "phantom";
-        readonly name: "Phantom";
-        readonly fill: 1118483;
-        readonly border: 3816000;
-        readonly text: 15790322;
-        readonly alpha: 0.95;
-    },
-    {
-        readonly id: "classic";
-        readonly name: "Classic";
-        readonly fill: 16777215;
-        readonly border: 10265519;
-        readonly text: 1120295;
-        readonly alpha: 0.96;
-    },
-    {
-        readonly id: "midnight";
-        readonly name: "Midnight";
-        readonly fill: 988970;
-        readonly border: 3718648;
-        readonly text: 14742270;
-        readonly alpha: 0.94;
-    },
-    {
-        readonly id: "candy";
-        readonly name: "Candy";
-        readonly fill: 16642808;
-        readonly border: 15485081;
-        readonly text: 8591427;
-        readonly alpha: 0.96;
-    },
-    {
-        readonly id: "mint";
-        readonly name: "Mint";
-        readonly fill: 15531509;
-        readonly border: 1096065;
-        readonly text: 413243;
-        readonly alpha: 0.96;
-    },
-    {
-        readonly id: "sunset";
-        readonly name: "Sunset";
-        readonly fill: 16775149;
-        readonly border: 16347926;
-        readonly text: 8138002;
-        readonly alpha: 0.96;
-    },
-    {
-        readonly id: "gold";
-        readonly name: "Gold";
-        readonly fill: 2694917;
-        readonly border: 16436245;
-        readonly text: 16710083;
-        readonly alpha: 0.94;
-    }
-];
-type BubbleId = (typeof BUBBLES)[number]["id"];
-type CommunityRoom = {
-    key: string;
-    name: string;
-};
-type CommunityMember = {
+type HiddenPlayer = {
     screenName: string;
-    bubble: BubbleId;
-};
-type CommunityMessage = {
-    id: string;
-    from: string;
-    text: string;
-    bubble: BubbleId;
-    at: number;
-};
-type CommunityRequest = {
-    id: string;
-    kind: "invite" | "ask";
-    from: string;
-    room: CommunityRoom | null;
-    at: number;
-};
-type CommunityAnswer = {
-    id: string;
-    kind: "invite" | "ask";
-    by: string;
-    accepted: boolean;
-    room: CommunityRoom | null;
-};
-type CommunityStatus = {
-    state: "off" | "connecting" | "online" | "offline" | "refused";
-    screenName: string | null;
-    room: string | null;
-    error: string | null;
-};
-type CommunityOnline = {
-    count: number;
-    listed: readonly string[];
-};
-type CommunityJoinOptions = {
-    bubble?: BubbleId;
-    listed?: boolean;
 };
 type CommunityChannel = {
-    status(): CommunityStatus;
-    onStatus(listener: (status: CommunityStatus) => void): Unsubscribe;
-    join(options: Required<CommunityJoinOptions>): Promise<void>;
-    leave(): Promise<void>;
-    members(): readonly CommunityMember[];
-    onMembers(listener: (members: readonly CommunityMember[]) => void): Unsubscribe;
-    say(text: string, bubble: BubbleId | null): Promise<void>;
-    onMessage(listener: (message: CommunityMessage) => void): Unsubscribe;
-    online(): Promise<CommunityOnline>;
-    report(messageId: string, reason: string): Promise<void>;
-    invite(screenName: string): Promise<void>;
-    ask(screenName: string): Promise<void>;
-    answer(requestId: string, accept: boolean): Promise<void>;
-    onRequest(listener: (request: CommunityRequest) => void): Unsubscribe;
-    onAnswered(listener: (answer: CommunityAnswer) => void): Unsubscribe;
+    hidden(): Promise<readonly HiddenPlayer[]>;
+    onHidden(listener: (hidden: readonly HiddenPlayer[]) => void): Unsubscribe;
+    hide(screenName: string): Promise<void>;
+    unhide(screenName: string): Promise<void>;
+    report(screenName: string, reason: string): Promise<void>;
 };
 declare class CommunityApi {
-    private readonly game;
-    private readonly flash;
     private readonly channel;
-    private captured;
-    constructor(game: GameContext, flash: PhantomFlash);
+    constructor(game: GameContext);
     get available(): boolean;
-    get status(): CommunityStatus;
-    onStatus(listener: (status: CommunityStatus) => void): Unsubscribe;
-    join(options?: CommunityJoinOptions): Promise<void>;
-    leave(): Promise<void>;
-    get members(): readonly CommunityMember[];
-    onMembers(listener: (members: readonly CommunityMember[]) => void): Unsubscribe;
-    say(text: string, options?: {
-        bubble?: BubbleId;
-    }): Promise<void>;
-    onMessage(listener: (message: CommunityMessage) => void): Unsubscribe;
-    online(): Promise<CommunityOnline>;
-    report(messageId: string, reason?: string): Promise<void>;
-    invite(screenName: string): Promise<void>;
-    askToJoin(screenName: string): Promise<void>;
-    answer(requestId: string, accept: boolean): Promise<void>;
-    onRequest(listener: (request: CommunityRequest) => void): Unsubscribe;
-    onAnswered(listener: (answer: CommunityAnswer) => void): Unsubscribe;
-    captureChat(prefix: string | null): Promise<void>;
-    private patchChatBar;
+    hidden(): Promise<readonly HiddenPlayer[]>;
+    onHidden(listener: (hidden: readonly HiddenPlayer[]) => void): Unsubscribe;
+    hide(screenName: string): Promise<void>;
+    unhide(screenName: string): Promise<void>;
+    report(screenName: string, reason?: string): Promise<void>;
     private reach;
 }
 type ContentMatch = {
@@ -2358,30 +2599,428 @@ declare class ContentApi {
     private whenLoaded;
     private reach;
 }
-type GameContext = {
-    flash: FlashBridge;
-    server: Side;
-    client: Side;
-    content?: ContentChannel;
-    community?: CommunityChannel;
-    undo?: (key: string, requests: readonly string[] | null) => void;
-};
-type PlayerAchievements = PacketOf<typeof Achievements>;
-type AchievementDescription = {
-    defId: number;
-    name: string;
-    description: string;
-    type: number;
-    typeName: string;
-    userVarId: number;
-    triggerAmount: number;
-    iconMediaId: number;
-    baseMediaId: number;
-    extraText: string;
+type CustomRoomPicture = string | Uint8Array;
+type CustomRoomMotion = {
+    pulse?: {
+        seconds: number;
+        min?: number;
+    };
+    spin?: {
+        seconds: number;
+    };
+    bob?: {
+        seconds: number;
+        height: number;
+    };
 };
-type AchievementType = {
-    type: number;
-    name: string;
+type CustomRoomFrames = {
+    count: number;
+    fps: number;
+};
+type CustomRoomArea = {
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    circle: {
+        x: number;
+        y: number;
+        radius: number;
+    };
+} | {
+    polygon: Array<[
+        number,
+        number
+    ]>;
+};
+type CustomRoomProp = {
+    id: string;
+    art: CustomRoomPicture;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    layer?: "floor" | "standing" | "front";
+    motion?: CustomRoomMotion;
+    frames?: CustomRoomFrames;
+    solid?: boolean;
+    area?: CustomRoomArea;
+    clickable?: boolean;
+    nearDistance?: number;
+    bounce?: boolean;
+};
+type CustomRoomExit = {
+    id: string;
+    x: number;
+    y: number;
+    radius: number;
+};
+type CustomRoomSpec = {
+    name: string;
+    width: number;
+    height: number;
+    background: CustomRoomPicture;
+    walkable?: CustomRoomArea[];
+    blocked?: CustomRoomArea[];
+    spawn: {
+        x: number;
+        y: number;
+    };
+    props?: CustomRoomProp[];
+    exits?: CustomRoomExit[];
+    music?: {
+        track: string;
+        volume?: number;
+    };
+};
+type CustomRoomEnterOptions = {
+    shared?: boolean;
+};
+type CustomRoomInfo = {
+    id: string;
+    name: string;
+    shared?: boolean;
+};
+type CustomRoomLeaveReason = "left" | "exit" | "elsewhere" | "closed";
+type CustomRoomEvent = {
+    kind: "enter";
+    room: CustomRoomInfo;
+} | {
+    kind: "leave";
+    room: CustomRoomInfo;
+    reason: CustomRoomLeaveReason;
+} | {
+    kind: "move";
+    room: CustomRoomInfo;
+    x: number;
+    y: number;
+} | {
+    kind: "chat";
+    room: CustomRoomInfo;
+    text: string;
+    chatKind: number;
+} | {
+    kind: "propEnter" | "propLeave" | "propNear" | "propClick";
+    room: CustomRoomInfo;
+    prop: string;
+};
+type SharedRoomListing = {
+    name: string;
+    title: string;
+    people: number;
+};
+type CustomRoomsChannel = {
+    define(spec: CustomRoomSpec): Promise<string>;
+    shared(): Promise<SharedRoomListing[]>;
+    remove(roomId: string): Promise<boolean>;
+    enter(roomId: string, options?: CustomRoomEnterOptions): Promise<void>;
+    leave(): Promise<boolean>;
+    current(): CustomRoomInfo | null;
+    onEvent(listener: (event: CustomRoomEvent) => void): Unsubscribe;
+};
+declare class CustomRoomsApi {
+    private readonly channel;
+    constructor(game: GameContext);
+    get available(): boolean;
+    define(spec: CustomRoomSpec): Promise<string>;
+    remove(roomId: string): Promise<boolean>;
+    enter(roomId: string, options?: CustomRoomEnterOptions): Promise<void>;
+    shared(): Promise<SharedRoomListing[]>;
+    leave(): Promise<boolean>;
+    get current(): CustomRoomInfo | null;
+    onEnter(listener: (room: CustomRoomInfo) => void): Unsubscribe;
+    onLeave(listener: (event: {
+        room: CustomRoomInfo;
+        reason: CustomRoomLeaveReason;
+    }) => void): Unsubscribe;
+    onMove(listener: (event: {
+        room: CustomRoomInfo;
+        x: number;
+        y: number;
+    }) => void): Unsubscribe;
+    onChat(listener: (event: {
+        room: CustomRoomInfo;
+        text: string;
+        kind: number;
+    }) => void): Unsubscribe;
+    onPropEnter(listener: (event: {
+        room: CustomRoomInfo;
+        prop: string;
+    }) => void): Unsubscribe;
+    onPropLeave(listener: (event: {
+        room: CustomRoomInfo;
+        prop: string;
+    }) => void): Unsubscribe;
+    onPropNear(listener: (event: {
+        room: CustomRoomInfo;
+        prop: string;
+    }) => void): Unsubscribe;
+    onPropClick(listener: (event: {
+        room: CustomRoomInfo;
+        prop: string;
+    }) => void): Unsubscribe;
+    private onProp;
+    private on;
+    private reach;
+}
+type RealtimeChannelSpec = {
+    scope: "room";
+} | {
+    scope: "plugin";
+} | {
+    scope: "named";
+    name: string;
+    split?: boolean;
+};
+type RealtimeScope = RealtimeChannelSpec["scope"];
+type RealtimeObject = Record<string, unknown>;
+type RealtimeMember<Presence = RealtimeObject> = {
+    id: string;
+    screenName: string;
+    presence?: Presence;
+};
+type RealtimeCloseReason = "left" | "banned" | "killed" | "rate-limited" | "offline";
+type RealtimeAskFailure = "no-handler" | "failed";
+type RealtimeState = "off" | "connecting" | "online" | "offline" | "refused";
+type RealtimeStatus = {
+    state: RealtimeState;
+    error: string | null;
+};
+type RealtimeJoinOptions<Presence extends RealtimeObject = RealtimeObject> = {
+    presence?: Presence | null;
+};
+type RealtimeChannelInfo = {
+    id: string;
+    scope: RealtimeScope;
+    name: string | null;
+    part: number | null;
+    you: RealtimeMember;
+    members: RealtimeMember[];
+    state: RealtimeObject | null;
+    host: string | null;
+    hostHidden?: boolean;
+};
+type RealtimeMessage<Data = unknown> = {
+    channel: string;
+    from: RealtimeMember;
+    data: Data;
+    at: number;
+    direct: boolean;
+};
+type RealtimeMemberEvent = {
+    channel: string;
+    member: RealtimeMember;
+};
+type RealtimeStateEvent<State extends RealtimeObject = RealtimeObject> = {
+    channel: string;
+    state: State | null;
+    from: string | null;
+    at: number;
+};
+type RealtimePresenceEvent<Presence extends RealtimeObject = RealtimeObject> = {
+    channel: string;
+    member: RealtimeMember<Presence>;
+};
+type RealtimeHostEvent<Presence extends RealtimeObject = RealtimeObject> = {
+    channel: string;
+    host: RealtimeMember<Presence> | null;
+    you: boolean;
+    hosted: boolean;
+};
+type RealtimeAsk<Question = unknown> = {
+    channel: string;
+    id: string;
+    from: RealtimeMember;
+    data: Question;
+    at: number;
+};
+type RealtimeAskOptions = {
+    timeout?: number;
+};
+type RealtimeClose = {
+    channel: string;
+    reason: RealtimeCloseReason;
+    message: string;
+};
+type RealtimeEvent = ({
+    kind: "join";
+} & RealtimeMemberEvent) | ({
+    kind: "leave";
+} & RealtimeMemberEvent) | {
+    kind: "message";
+    message: RealtimeMessage;
+} | ({
+    kind: "state";
+} & RealtimeStateEvent) | ({
+    kind: "presence";
+} & RealtimePresenceEvent) | ({
+    kind: "host";
+} & RealtimeHostEvent) | ({
+    kind: "close";
+} & RealtimeClose);
+type RealtimeLink = {
+    open(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions): Promise<RealtimeChannelInfo>;
+    leave(channel: string): Promise<boolean>;
+    send(channel: string, data: unknown): Promise<void>;
+    sendTo(channel: string, member: string, data: unknown): Promise<void>;
+    setState(channel: string, state: RealtimeObject | null): Promise<void>;
+    setPresence(channel: string, presence: RealtimeObject | null): Promise<void>;
+    giveHost(channel: string, member: string): Promise<void>;
+    ask(channel: string, member: string, data: unknown, options?: RealtimeAskOptions): Promise<unknown>;
+    answer(askId: string, data: unknown): Promise<void>;
+    decline(askId: string, reason?: RealtimeAskFailure): Promise<void>;
+    channels(): RealtimeChannelInfo[];
+    status(): RealtimeStatus;
+    onEvent(listener: (event: RealtimeEvent) => void): Unsubscribe;
+    onAsk(listener: (ask: RealtimeAsk) => void): Unsubscribe;
+    onStatus(listener: (status: RealtimeStatus) => void): Unsubscribe;
+};
+type RealtimeCalls = {
+    open(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions): Promise<RealtimeChannelInfo>;
+    leave(channel: string): Promise<boolean>;
+    send(channel: string, data: unknown): Promise<void>;
+    sendTo(channel: string, member: string, data: unknown): Promise<void>;
+    setState(channel: string, state: RealtimeObject | null): Promise<void>;
+    setPresence(channel: string, presence: RealtimeObject | null): Promise<void>;
+    giveHost(channel: string, member: string): Promise<void>;
+    ask(channel: string, member: string, data: unknown, options?: RealtimeAskOptions): Promise<unknown>;
+    answer(askId: string, data: unknown): Promise<void>;
+    decline(askId: string, reason?: RealtimeAskFailure): Promise<void>;
+    onAsk(listener: (ask: RealtimeAsk) => void): Unsubscribe;
+    onMessage(listener: (message: RealtimeMessage) => void): Unsubscribe;
+    onJoin(listener: (event: RealtimeMemberEvent) => void): Unsubscribe;
+    onLeave(listener: (event: RealtimeMemberEvent) => void): Unsubscribe;
+    onState(listener: (event: RealtimeStateEvent) => void): Unsubscribe;
+    onPresence(listener: (event: RealtimePresenceEvent) => void): Unsubscribe;
+    onHost(listener: (event: RealtimeHostEvent) => void): Unsubscribe;
+    onClose(listener: (event: RealtimeClose) => void): Unsubscribe;
+};
+type Heard = {
+    kind: "message";
+    message: RealtimeMessage;
+} | ({
+    kind: "ask";
+} & RealtimeAsk) | ({
+    kind: "join" | "leave";
+} & RealtimeMemberEvent) | ({
+    kind: "state";
+} & RealtimeStateEvent) | ({
+    kind: "presence";
+} & RealtimePresenceEvent) | ({
+    kind: "host";
+} & RealtimeHostEvent) | ({
+    kind: "close";
+} & RealtimeClose);
+declare class RealtimeChannel<Data = unknown, State extends RealtimeObject = RealtimeObject, Presence extends RealtimeObject = RealtimeObject> {
+    private readonly calls;
+    readonly id: string;
+    readonly scope: RealtimeScope;
+    readonly name: string | null;
+    readonly part: number | null;
+    private self;
+    private list;
+    private shared;
+    private hostAt;
+    private hostIsHidden;
+    private closedWith;
+    private answers;
+    private readonly heard;
+    private stop;
+    constructor(info: RealtimeChannelInfo, calls: RealtimeCalls);
+    get you(): RealtimeMember<Presence>;
+    get open(): boolean;
+    members(): readonly RealtimeMember<Presence>[];
+    host(): RealtimeMember<Presence> | null;
+    get isHost(): boolean;
+    get hosted(): boolean;
+    giveHost(memberId: string): Promise<void>;
+    state(): State | null;
+    setState(state: State | null): Promise<void>;
+    presence(): Presence | null;
+    setPresence(presence: Presence | null): Promise<void>;
+    send(data: Data): Promise<void>;
+    sendTo(memberId: string, data: Data): Promise<void>;
+    ask<Answer = unknown>(memberId: string, question: unknown, options?: RealtimeAskOptions): Promise<Answer>;
+    onAsk<Question = unknown, Answer = unknown>(handler: (ask: RealtimeAsk<Question>) => Answer | PromiseLike<Answer>): Unsubscribe;
+    leave(): Promise<void>;
+    onMessage(listener: (message: RealtimeMessage<Data>) => void): Unsubscribe;
+    onJoin(listener: (member: RealtimeMember<Presence>) => void): Unsubscribe;
+    onLeave(listener: (member: RealtimeMember<Presence>) => void): Unsubscribe;
+    onState(listener: (event: RealtimeStateEvent<State>) => void): Unsubscribe;
+    onPresence(listener: (member: RealtimeMember<Presence>) => void): Unsubscribe;
+    onHost(listener: (event: RealtimeHostEvent<Presence>) => void): Unsubscribe;
+    onClose(listener: (close: RealtimeClose) => void): Unsubscribe;
+    hear(event: Heard): void;
+    private reply;
+    private turnDown;
+    stopWith(stop: () => void): void;
+    private listen;
+    private tell;
+    private refuse;
+}
+declare class RealtimeApi {
+    private readonly link;
+    constructor(game: GameContext);
+    get available(): boolean;
+    get status(): RealtimeStatus;
+    onStatus(listener: (status: RealtimeStatus) => void): Unsubscribe;
+    join<Data = unknown, State extends RealtimeObject = RealtimeObject, Presence extends RealtimeObject = RealtimeObject>(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions<Presence>): Promise<RealtimeChannel<Data, State, Presence>>;
+    open(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions): Promise<RealtimeChannelInfo>;
+    leave(channelId: string): Promise<boolean>;
+    send(channelId: string, data: unknown): Promise<void>;
+    sendTo(channelId: string, memberId: string, data: unknown): Promise<void>;
+    ask(channelId: string, memberId: string, question: unknown, options?: RealtimeAskOptions): Promise<unknown>;
+    answer(askId: string, answer: unknown): Promise<void>;
+    decline(askId: string, reason?: RealtimeAskFailure): Promise<void>;
+    state(channelId: string): RealtimeObject | null;
+    setState(channelId: string, state: RealtimeObject | null): Promise<void>;
+    presence(channelId: string): RealtimeObject | null;
+    setPresence(channelId: string, presence: RealtimeObject | null): Promise<void>;
+    host(channelId: string): RealtimeMember | null;
+    giveHost(channelId: string, memberId: string): Promise<void>;
+    channels(): RealtimeChannelInfo[];
+    members(channelId: string): RealtimeMember[];
+    private channelOf;
+    onMessage(listener: (message: RealtimeMessage) => void): Unsubscribe;
+    onJoin(listener: (event: RealtimeMemberEvent) => void): Unsubscribe;
+    onLeave(listener: (event: RealtimeMemberEvent) => void): Unsubscribe;
+    onState(listener: (event: RealtimeStateEvent) => void): Unsubscribe;
+    onPresence(listener: (event: RealtimePresenceEvent) => void): Unsubscribe;
+    onHost(listener: (event: RealtimeHostEvent) => void): Unsubscribe;
+    onAsk(listener: (ask: RealtimeAsk) => void): Unsubscribe;
+    onClose(listener: (event: RealtimeClose) => void): Unsubscribe;
+    private on;
+    private reach;
+}
+type GameContext = {
+    flash: FlashBridge;
+    server: Side;
+    client: Side;
+    content?: ContentChannel;
+    community?: CommunityChannel;
+    customRooms?: CustomRoomsChannel;
+    realtime?: RealtimeLink;
+    undo?: (key: string, requests: readonly string[] | null) => void;
+};
+type PlayerAchievements = PacketOf<typeof Achievements>;
+type AchievementDescription = {
+    defId: number;
+    name: string;
+    description: string;
+    type: number;
+    typeName: string;
+    userVarId: number;
+    triggerAmount: number;
+    iconMediaId: number;
+    baseMediaId: number;
+    extraText: string;
+};
+type AchievementType = {
+    type: number;
+    name: string;
 };
 type HeldAchievement = {
     defId: number;
@@ -2399,6 +3038,14 @@ type CachedStat = {
     value: number;
     type: number;
 };
+type EarnAnswer = {
+    defId: number;
+    userVarId: number;
+    asked: number;
+    kept: number;
+    earned: boolean;
+    achievements: AchievementEntry[];
+};
 type StatChange = {
     userVarId: number;
     value: number;
@@ -2413,17 +3060,21 @@ declare class AchievementsApi {
     private readonly server;
     private readonly values;
     private readonly changeListeners;
+    private readonly statsListeners;
     constructor(game: GameContext);
     stat(userVarId: number): number | null;
     get stats(): ReadonlyMap<number, number>;
     readStat(userVarId: number): Promise<number>;
     refreshStats(timeoutMs?: number): Promise<ReadonlyMap<number, number>>;
     setStat(userVarId: number, value: number, timeoutMs?: number): Promise<StatChange>;
+    earn(defId: number, timeoutMs?: number): Promise<EarnAnswer>;
     of(userName: string, timeoutMs?: number): Promise<PlayerAchievements>;
     onStatChange(listener: (change: StatChange) => void): () => void;
     onAchievement(listener: (achievement: AchievementEntry, change: StatChange) => void): () => void;
     definition(defId: number): Promise<Record<string, FlashValue> | null>;
     definitions(type?: number): Promise<Record<string, FlashValue>>;
+    definitionsByType(): Promise<Record<string, Record<string, FlashValue>[]>>;
+    onStats(listener: (stats: ReadonlyMap<number, number>) => void): () => void;
     hasUnseen(): Promise<boolean>;
     showNew(): Promise<void>;
     onAchievements(listener: (answer: PlayerAchievements) => void): () => void;
@@ -2494,6 +3145,47 @@ type AvatarKindDefinition = {
     availabilityStartTime: number;
     availabilityEndTime: number;
 };
+type AvatarSummary = {
+    userName: string;
+    uuid: string;
+    perUserAvId: number;
+    avInvId: number;
+    avName: string;
+    avTypeId: number;
+    customAvId: number;
+    colors: AvatarColors;
+    userId: number;
+    enviroTypeFlag: number;
+};
+type NewAvatar = {
+    avTypeId: number;
+    nameIds: AvatarNameIds;
+    customAvId?: number;
+    diamondDefId?: number;
+    shopId?: number;
+};
+type AdventurePlayer = {
+    userId: number;
+    userName: string;
+    avName: string;
+    isMember: boolean;
+    nameBarData: number;
+};
+type HostedGame = {
+    infoText: string;
+    userMessage: string;
+    difficulty: number;
+    severity: number;
+};
+type AvatarHosting = {
+    adventure: HostedGame | null;
+    pvp: HostedGame | null;
+};
+type AvatarRoomState = {
+    joiningRoom: boolean;
+    inPreviewRoom: boolean;
+    waitingForLanguage: boolean;
+};
 declare class AvatarApi {
     private readonly flash;
     private readonly client;
@@ -2502,9 +3194,11 @@ declare class AvatarApi {
     private readonly lookupListeners;
     private readonly paintListeners;
     private readonly offered;
-    private noClip;
+    private noClipHook;
+    private readonly noClipListeners;
     private grounded;
     private navigator;
+    private readonly nameBars;
     constructor(game: GameContext, flash: PhantomFlash);
     private gridOf;
     private readGrid;
@@ -2515,6 +3209,7 @@ declare class AvatarApi {
     userId(): Promise<number>;
     view(): Promise<FlashHandle>;
     standing(): Promise<AvatarStanding | null>;
+    private standingOfView;
     placeAt(position: Point, options?: {
         instant?: boolean;
     }): Promise<void>;
@@ -2542,6 +3237,7 @@ declare class AvatarApi {
     restoreColors(part: AvatarColorPart): Promise<boolean>;
     pickColor(part: AvatarColorPart, index: number): Promise<boolean>;
     paint(colors: AvatarColors): Promise<boolean>;
+    paintColor(part: AvatarColorPart, index: number): Promise<boolean>;
     act(action: AvatarAction): Promise<void>;
     list(): Promise<OwnListedAvatar[]>;
     switchTo(perUserAvId: number): Promise<boolean>;
@@ -2558,9 +3254,53 @@ declare class AvatarApi {
     setWalkSpeed(times: number): Promise<void>;
     glide(direction: Point | null): Promise<void>;
     setNoClip(on: boolean): Promise<boolean>;
+    private rebuildGrid;
+    get noClip(): boolean;
+    onNoClip(listener: (on: boolean) => void): () => void;
     setAirborne(on: boolean): Promise<boolean>;
     walkPath(points: readonly Point[]): Promise<void>;
     walkThrough(x: number, y: number, options?: WalkThroughOptions): Promise<boolean>;
+    create(animal: NewAvatar): Promise<PacketOf<typeof AvatarAdded>>;
+    buySlot(): Promise<boolean>;
+    createFirst(avTypeId: number, nameIds: AvatarNameIds): Promise<boolean>;
+    chooseUsable(avInvIds: readonly number[]): Promise<boolean>;
+    setPendingFlag(flag: number): Promise<void>;
+    canPayForPhoto(): Promise<boolean>;
+    payForPhoto(): Promise<number>;
+    definitionsLoaded(): Promise<boolean>;
+    loadDefinitions(): Promise<boolean>;
+    data(userName: string, perUserAvId: number, timeoutMs?: number): Promise<AvatarSummary>;
+    private loadAvatar;
+    private calledBack;
+    private summarise;
+    private summaryOf;
+    inRoom(userId: number): Promise<AvatarSummary | null>;
+    findInRoom(query: {
+        userName: string;
+        perUserAvId?: number;
+    } | {
+        avName: string;
+    }): Promise<AvatarSummary | null>;
+    standingOf(userId: number): Promise<AvatarStanding | null>;
+    defaultLook(avTypeId: number, custom?: boolean): Promise<AvatarSummary | null>;
+    buddyCardAvatar(): Promise<AvatarSummary | null>;
+    adventurePlayers(): Promise<AdventurePlayer[]>;
+    offScreenPlayers(): Promise<number[]>;
+    lastSeenAt(userId: number, roomName?: string): Promise<Point | null>;
+    hosting(): Promise<AvatarHosting>;
+    isHostingAdventure(): Promise<boolean>;
+    suitsEnvironment(enviroType: number): Promise<boolean>;
+    roomState(): Promise<AvatarRoomState>;
+    lastNameBar(userId: number): number | null;
+    onList(listener: (list: PacketOf<typeof AvatarList>) => void): () => void;
+    onRemoved(listener: (result: PacketOf<typeof AvatarKilled>) => void): () => void;
+    onAdded(listener: (added: PacketOf<typeof AvatarAdded>) => void): () => void;
+    onSlotBought(listener: (result: PacketOf<typeof AvatarSlotBought>) => void): () => void;
+    onFirstCreated(listener: (result: PacketOf<typeof AvatarFastPassAdded>) => void): () => void;
+    onNameBarChange(listener: (change: PacketOf<typeof AvatarNameBarChanged>) => void): () => void;
+    onUsableChosen(listener: (result: PacketOf<typeof AvatarOrdained>) => void): () => void;
+    onPhotoChecked(listener: (result: PacketOf<typeof AvatarPhotoChecked>) => void): () => void;
+    onPhotoTaken(listener: (result: PacketOf<typeof AvatarPhotoTaken>) => void): () => void;
 }
 type AdventurePrizeKind = "denItem" | "clothing" | "gems" | "crystals";
 type AdventureActorPrize = {
@@ -2816,6 +3556,83 @@ type SpawnActorOptions = {
     skipIfTaken?: boolean;
     parameters?: string;
 };
+type AdventureExperience = PacketOf<typeof QuestXp>;
+type AdventureDeparture = {
+    userId: number;
+    avatarName: string;
+};
+type AdventureAward = {
+    userVarId: number;
+    value: number;
+};
+type AdventureSeek = {
+    seekType: number;
+    userId: number;
+};
+type AdventureSeed = {
+    defId: number;
+    count: number;
+    max: number;
+};
+type AdventurePlant = {
+    actorId: string;
+    defId: number | null;
+    position: Point | null;
+    userName: string | null;
+    launcherUserId: number | null;
+    eaten: string[];
+    recoils: number;
+};
+type AdventureCombatStats = PacketOf<typeof QuestStatsUpdate>;
+type AdventureAttack = {
+    userId: number;
+    weaponDefId: number;
+    color: number;
+};
+type AdventurePlayerRoom = {
+    roomName: string;
+    position: Point;
+};
+type AdventureSoundCue = {
+    name: string;
+    voiceOver: boolean;
+    subtitle: string | null;
+};
+type AdventureZap = {
+    kind: "beam" | "phantom";
+    actorId: string;
+    userId: number;
+};
+type AdventureLaunch = {
+    ranged: boolean;
+    weaponDefId: number;
+    target: Point;
+    color: number;
+};
+type AdventureSoundPack = {
+    mediaId: number;
+};
+type AdventureActorMove = {
+    position: Point;
+    velocity: number;
+    seekType: number;
+    nearest: Point;
+};
+type AdventureWeaponLaunch = {
+    weaponDefId: number;
+    target: Point;
+    color: number;
+};
+type AdventureClientStatus = {
+    justJoined: boolean;
+    exitPending: boolean;
+    likeNormalRoom: boolean;
+    playAsPet: boolean;
+    joinableAfterStart: boolean;
+    throwKeyDown: boolean;
+    crystalCount: number;
+    maxGoals: number;
+};
 declare class AdventuresApi {
     readonly [STATE_FIELDS]: readonly [
         "lobbyState",
@@ -2825,7 +3642,38 @@ declare class AdventuresApi {
         "roomName",
         "rewardsOffered",
         "endReason",
-        "crystalCount"
+        "crystalCount",
+        "experienceState",
+        "levelByUser",
+        "departed",
+        "defeatedUserIds",
+        "awardList",
+        "givenItemIds",
+        "exitAnswered",
+        "lastBundleMessages",
+        "iconByActor",
+        "seekByActor",
+        "disguiseByUser",
+        "seedsByDef",
+        "plantByActor",
+        "combatState",
+        "volumeByActor",
+        "attackByActor",
+        "roomByUser",
+        "sideScrollByUser",
+        "actorTorches",
+        "playerTorches",
+        "musicName",
+        "cutsceneMedia",
+        "preloadedMedia",
+        "soundPackIds",
+        "screenFadedOut",
+        "lastZapState",
+        "launchBy",
+        "respawnsGrantedCount",
+        "shakeUntil",
+        "lastSoundCue",
+        "pageViewList"
     ];
     private readonly flash;
     private readonly navigator;
@@ -2851,6 +3699,37 @@ declare class AdventuresApi {
     private readonly loops;
     private nextLoop;
     private nextSwing;
+    private experienceState;
+    private readonly levelByUser;
+    private readonly departed;
+    private readonly defeatedUserIds;
+    private readonly awardList;
+    private readonly givenItemIds;
+    private exitAnswered;
+    private lastBundleMessages;
+    private readonly iconByActor;
+    private readonly seekByActor;
+    private readonly disguiseByUser;
+    private readonly seedsByDef;
+    private readonly plantByActor;
+    private combatState;
+    private readonly volumeByActor;
+    private readonly attackByActor;
+    private readonly roomByUser;
+    private readonly sideScrollByUser;
+    private readonly actorTorches;
+    private readonly playerTorches;
+    private musicName;
+    private cutsceneMedia;
+    private readonly preloadedMedia;
+    private readonly soundPackIds;
+    private screenFadedOut;
+    private lastZapState;
+    private readonly launchBy;
+    private respawnsGrantedCount;
+    private shakeUntil;
+    private lastSoundCue;
+    private readonly pageViewList;
     constructor(game: GameContext);
     get lobby(): AdventureLobby | null;
     get current(): Adventure | null;
@@ -3007,6 +3886,95 @@ declare class AdventuresApi {
     onSeedPlanted(listener: (planted: PacketOf<typeof QuestSeedPlanted>) => void): () => void;
     onPlantAte(listener: (ate: PacketOf<typeof QuestPlantAte>) => void): () => void;
     onPlantEatRecoil(listener: (recoil: PacketOf<typeof QuestPlantEatRecoil>) => void): () => void;
+    experience(): AdventureExperience | null;
+    playerLevel(userId: number): number | null;
+    departedPlayers(): AdventureDeparture[];
+    defeatedPlayers(): number[];
+    awards(): AdventureAward[];
+    givenItems(): string[];
+    get exitConfirmed(): boolean;
+    lastBundle(): QuestBundledMessage[];
+    actorIconShowing(actorId: string): boolean | null;
+    actorSeeking(actorId: string): AdventureSeek | null;
+    disguise(userId: number): number | null;
+    seeds(): AdventureSeed[];
+    plants(): AdventurePlant[];
+    combatStats(): AdventureCombatStats | null;
+    volumeProgress(actorId: string): number | null;
+    attackTarget(actorId: string): AdventureAttack | null;
+    playerRoom(userId: number): AdventurePlayerRoom | null;
+    sideScrollPosition(userId: number): Point | null;
+    actorTorch(actorId: string): boolean | null;
+    playerTorch(userId: number): boolean | null;
+    get music(): string | null;
+    get cutscene(): number | null;
+    preloadedCutscenes(): number[];
+    soundPacks(): number[];
+    get screenFaded(): boolean;
+    lastZap(): AdventureZap | null;
+    lastLaunch(by: number | string): AdventureLaunch | null;
+    get respawnsGranted(): number;
+    get shaking(): boolean;
+    lastSound(): AdventureSoundCue | null;
+    pageViews(): string[];
+    clientStatus(): Promise<AdventureClientStatus>;
+    actorPathToPlayer(actorId: string): Promise<boolean>;
+    onActorSpawned(listener: (spawned: PacketOf<typeof QuestActorSpawned>) => void): () => void;
+    onActorMoved(listener: (moved: PacketOf<typeof QuestActorMoved>) => void): () => void;
+    onActorHealth(listener: (health: PacketOf<typeof QuestActorHealth>) => void): () => void;
+    onActorDied(listener: (died: PacketOf<typeof QuestActorDied>) => void): () => void;
+    onActorRestored(listener: (restored: PacketOf<typeof QuestActorRestored>) => void): () => void;
+    onActorSwfState(listener: (state: PacketOf<typeof QuestActorSwfState>) => void): () => void;
+    onActorPath(listener: (path: PacketOf<typeof QuestActorPath>) => void): () => void;
+    onCommand(listener: (command: PacketOf<typeof QuestCommand>) => void): () => void;
+    onVariable(listener: (variable: PacketOf<typeof QuestVariable>) => void): () => void;
+    onPickUpResult(listener: (result: AdventurePickUpAnswer) => void): () => void;
+    onMovedItems(listener: (moved: PacketOf<typeof QuestMovedItems>) => void): () => void;
+    onCrystalCount(listener: (count: PacketOf<typeof QuestCrystals>) => void): () => void;
+    onSentOut(listener: (sent: PacketOf<typeof QuestExitByType>) => void): () => void;
+    onLobbyWaiting(listener: (waiting: PacketOf<typeof QuestWaiting>) => void): () => void;
+    onLobbyLeft(listener: (left: PacketOf<typeof QuestJoinCancelled>) => void): () => void;
+    onPlayerAttacked(listener: (attack: PacketOf<typeof QuestPlayerAttacked>) => void): () => void;
+    onBeamZap(listener: (zap: PacketOf<typeof QuestBeamZapped>) => void): () => void;
+    onPhantomZap(listener: (zap: PacketOf<typeof QuestPhantomZapped>) => void): () => void;
+    onThrow(listener: (thrown: PacketOf<typeof QuestProjectileLaunched>) => void): () => void;
+    onSwing(listener: (swung: PacketOf<typeof QuestSwiped>) => void): () => void;
+    onRespawnGranted(listener: (granted: PacketOf<typeof QuestRespawnGranted>) => void): () => void;
+    onPlayerRoomChange(listener: (change: PacketOf<typeof QuestPlayerRoomChange>) => void): () => void;
+    onSideScroll(listener: (moved: PacketOf<typeof QuestSideScrollMoved>) => void): () => void;
+    onTorch(listener: (torch: PacketOf<typeof QuestTorch>) => void): () => void;
+    onCutscene(listener: (film: PacketOf<typeof QuestPlaySwf>) => void): () => void;
+    onCutscenePreload(listener: (film: PacketOf<typeof QuestPreloadSwf>) => void): () => void;
+    onFade(listener: (fade: PacketOf<typeof QuestFade>) => void): () => void;
+    onShake(listener: (shake: PacketOf<typeof QuestShake>) => void): () => void;
+    onSound(listener: (sound: AdventureSoundCue) => void): () => void;
+    onMusic(listener: (music: PacketOf<typeof QuestMusic>) => void): () => void;
+    onSoundPack(listener: (pack: AdventureSoundPack) => void): () => void;
+    onPageView(listener: (view: PacketOf<typeof QuestPostUri>) => void): () => void;
+    reportHit(actorId: string, weaponDefId: number, at: Point): Promise<void>;
+    reportPlayerHit(weaponDefId: number): Promise<void>;
+    reportAttackOnPlayer(actorId: string, userId: number, weaponDefId: number, color: number): Promise<void>;
+    reportActorPosition(actorId: string, move: AdventureActorMove): Promise<void>;
+    requestActorSeek(actorId: string, seekType: number): Promise<void>;
+    untrigger(actorId: string): Promise<void>;
+    reportBeamZap(actorId: string): Promise<void>;
+    reportPhantomZap(actorId: string, at?: Point): Promise<void>;
+    reportDestructibleHit(phantomActorId: string, destructibleActorId: string): Promise<void>;
+    reportPlantAte(plantActorId: string, phantomActorId?: string): Promise<void>;
+    reportThrow({ weaponDefId, target, color }: AdventureWeaponLaunch): Promise<void>;
+    reportSwing({ weaponDefId, target, color }: AdventureWeaponLaunch): Promise<void>;
+    finishCutscene(): Promise<void>;
+    movedItems(timeoutMs?: number): Promise<PacketOf<typeof QuestMovedItems>>;
+    requestRespawn(at?: Point): Promise<void>;
+    finishMinigame(result: number, from?: {
+        actorName: string;
+        actorState: number;
+    }): Promise<void>;
+    finishRoomMinigame(roomName: string, result: number): Promise<void>;
+    reportSideScroll(at: Point, flags?: number): Promise<void>;
+    private forgetRun;
+    private plantOf;
+    private respawnPoint;
     private targetOf;
     private manager;
 }
@@ -3049,6 +4017,17 @@ declare class AssetsApi {
     loadMedia(mediaId: number, timeoutMs?: number): Promise<LoadedMediaInfo>;
     onLoaded(listener: (asset: LoadedAsset) => void): Unsubscribe;
 }
+type BuddySighting = {
+    userName: string;
+    online: boolean;
+    roomName: string;
+    displayName: string;
+    displayNameId: number;
+    otherServer: boolean;
+    node: string | null;
+    locked: boolean;
+    seenAt: number;
+};
 type Buddy = BuddyEntry;
 type BuddyUpdate = {
     type: "added" | "removed" | "online" | "offline" | "renamed" | "updated";
@@ -3078,6 +4057,23 @@ type SentBuddyRequest = {
     expiresAt: number;
     accepting: boolean;
 };
+type IncomingBuddyRequest = {
+    userName: string;
+    userNameModerationFlag: number;
+    receivedAt: number;
+    expiresAt: number;
+};
+type BuddyBlockChange = {
+    userName: string;
+    blocked: boolean;
+    success: boolean;
+};
+type BuddyCardTradeItem = {
+    defId: number;
+    invIdx: number;
+    itemType: number;
+    name: string;
+};
 type BuddyWhereabouts = {
     roomName: string;
     displayName: string;
@@ -3088,21 +4084,30 @@ type BuddyWhereabouts = {
 declare class BuddiesApi {
     readonly [STATE_FIELDS]: readonly [
         "buddies",
-        "blockedNames"
+        "blockedNames",
+        "incoming"
     ];
     private readonly flash;
     private readonly server;
     private readonly buddies;
     private readonly blockedNames;
+    private readonly incoming;
     private readonly listeners;
     private readonly locationListeners;
     private readonly blockInfoListeners;
+    private readonly sightings;
+    private readonly sightingListeners;
+    private readonly asked;
     constructor(game: GameContext);
+    get whereabouts(): BuddySighting[];
+    whereaboutsOf(userName: string): BuddySighting | null;
+    onWhereabouts(listener: (sighting: BuddySighting) => void): Unsubscribe;
     get list(): Buddy[];
     get online(): Buddy[];
     get blocked(): string[];
     get(userName: string): Buddy | null;
     isBlocked(userName: string): boolean;
+    get requests(): IncomingBuddyRequest[];
     refresh(timeoutMs?: number): Promise<Buddy[]>;
     add(userName: string): Promise<void>;
     remove(userName: string): Promise<void>;
@@ -3115,11 +4120,18 @@ declare class BuddiesApi {
     onUpdate(listener: (update: BuddyUpdate) => void): Unsubscribe;
     onLocation(listener: (location: PacketOf<typeof BuddyLocation>) => void): Unsubscribe;
     onBlockInfo(listener: (info: PacketOf<typeof BuddyBlockInfo>) => void): Unsubscribe;
+    onAddResult(listener: (result: PacketOf<typeof BuddyAddResult>) => void): Unsubscribe;
+    onBlockChange(listener: (change: BuddyBlockChange) => void): Unsubscribe;
+    onList(listener: (list: PacketOf<typeof BuddyList>) => void): Unsubscribe;
     private fromStatus;
     isBlockingMe(userName: string, timeoutMs?: number): Promise<boolean>;
     capacity(): Promise<BuddyCapacity>;
     knows(userName: string): Promise<boolean>;
     details(userName: string): Promise<BuddyDetails | null>;
+    clientList(): Promise<BuddyDetails[]>;
+    clientBlocked(): Promise<string[]>;
+    hasBlocked(userName: string): Promise<boolean>;
+    cardTradeList(): Promise<BuddyCardTradeItem[] | null>;
     showCard(userName: string, online?: boolean): Promise<void>;
     closeCard(): Promise<void>;
     joinBuddyQuest(): Promise<boolean>;
@@ -3156,12 +4168,16 @@ type ModerationEvent = {
 };
 declare class ChatApi {
     readonly [STATE_FIELDS]: readonly [
-        "history"
+        "history",
+        "adminNotice",
+        "moderationNotice"
     ];
     private readonly flash;
     private readonly server;
     private readonly history;
     private readonly listeners;
+    private adminNotice;
+    private moderationNotice;
     constructor(game: GameContext);
     get recent(): readonly ChatMessage[];
     say(text: string): Promise<void>;
@@ -3187,7 +4203,18 @@ declare class ChatApi {
     log(text: string, from?: string): Promise<void>;
     clearLog(): Promise<void>;
     onJamAGram(listener: (card: JamAGram) => void): Unsubscribe;
+    get lastAdminMessage(): AdminNotice | null;
+    get lastModeration(): ModerationEvent | null;
+    private phraseNodes;
 }
+declare const DIAMOND_TYPE: {
+    readonly item: 0;
+    readonly denItem: 1;
+    readonly pet: 2;
+    readonly avatar: 3;
+    readonly den: 4;
+};
+type DiamondType = keyof typeof DIAMOND_TYPE;
 type CurrencyKey = CurrencyKind | number;
 type CurrencyChange = {
     currency: number;
@@ -3243,6 +4270,8 @@ declare class CurrencyApi {
     exchangeDefinition(defId: number): Promise<CurrencyExchangeDefinition | null>;
     exchange(shopId: number, exchangeDefId: number, timeoutMs?: number): Promise<ExchangeResult>;
     canAfford(price: number | string, currency?: CurrencyKey): Promise<boolean>;
+    diamondsLoaded(): Promise<boolean>;
+    diamondDefinitionId(refDefId: number, type: DiamondType | number): Promise<number | null>;
     onChange(listener: (change: CurrencyChange) => void): () => void;
     onExchange(listener: (result: ExchangeResult) => void): () => void;
     onDonate(listener: (success: boolean) => void): () => void;
@@ -3259,9 +4288,10 @@ type OpenDailyGift = {
 };
 declare class DailyGiftApi {
     private readonly flash;
+    private readonly client;
     private readonly giftListeners;
     private statUserVarId;
-    constructor(game: GameContext);
+    constructor(game: GameContext, flash: PhantomFlash);
     daysInCycle(): Promise<number>;
     statId(): Promise<number>;
     received(): Promise<number>;
@@ -3273,6 +4303,12 @@ declare class DailyGiftApi {
     reject(): Promise<void>;
     close(): Promise<void>;
     onGift(listener: (received: number) => void): Unsubscribe;
+    unwrap(): Promise<void>;
+    onOpen(listener: () => void): Unsubscribe;
+    wheelOpen(): Promise<boolean>;
+    spinWheel(): Promise<boolean>;
+    onWheelOpen(listener: () => void): Unsubscribe;
+    private hookExit;
     private press;
     private popup;
 }
@@ -3340,9 +4376,12 @@ declare const OWN_POPUPS: {
     readonly emailConfirmation: "_emailConfirmation";
 };
 type OwnPopupName = keyof typeof OWN_POPUPS;
+type LoginPopup = "newspaper" | "holidayBanner" | "adoptAPetIntro";
 declare class PopupsApi {
     private readonly flash;
     private readonly client;
+    private readonly loginSkips;
+    private readonly skippedListeners;
     constructor(game: GameContext, flash: PhantomFlash);
     list(): Promise<Popup[]>;
     read(match?: string): Promise<Popup | null>;
@@ -3351,6 +4390,11 @@ declare class PopupsApi {
     onClose(listener: (popup: PopupClosed) => void): () => void;
     isOpen(popup: OwnPopupName): Promise<boolean>;
     close(popup: OwnPopupName): Promise<boolean>;
+    skipAtLogin(popups?: readonly LoginPopup[]): Promise<LoginPopup[]>;
+    stopSkippingAtLogin(): Promise<void>;
+    get skippingAtLogin(): LoginPopup[];
+    onSkipped(listener: (popup: LoginPopup) => void): () => void;
+    private skipLoginPopup;
     private ownPopup;
     private describe;
     private textOf;
@@ -3419,6 +4463,10 @@ type DenShopPurchase = {
     currency: DenShopCurrency;
     balance: number;
 };
+type DenShopOfferingEvent = DenShopContents & {
+    ownerUserName: string | null;
+    ok: boolean;
+};
 type DenShopPurchaseEvent = {
     status: number;
     ownerUserName: string;
@@ -3428,21 +4476,75 @@ type DenShopPurchaseEvent = {
     currency: DenShopCurrency | null;
     balance: number | null;
 };
+type DenShopSale = {
+    storeInvId: number;
+    item: DenShopItem;
+    defId: number;
+    cost: number;
+    currency: DenShopCurrency;
+    balance: number;
+};
+type DenShopStand = {
+    ownerUserName: string;
+    storeInvId: number;
+    defId: number;
+};
+type DenShopUpdate = {
+    list?: Array<{
+        item: DenShopItem;
+        cost: number;
+        currency?: DenShopCurrency;
+    }>;
+    unlist?: DenShopItem[];
+};
 declare class DenShopApi {
     private readonly flash;
     private readonly server;
+    private readonly asked;
+    private readonly offeringListeners;
+    private telling;
     constructor(game: GameContext);
     offering(userName: string, storeInvId: number, timeoutMs?: number): Promise<DenShopContents>;
     list(storeInvId: number, state: string, item: DenShopItem, cost: number, currency?: DenShopCurrency, timeoutMs?: number): Promise<DenShopChange>;
     reprice(storeInvId: number, state: string, item: DenShopItem, cost: number, currency?: DenShopCurrency, timeoutMs?: number): Promise<DenShopChange>;
     unlist(storeInvId: number, state: string, item: DenShopItem, timeoutMs?: number): Promise<DenShopChange>;
     buy(ownerUserName: string, storeInvId: number, state: string, listing: DenShopListing, timeoutMs?: number): Promise<DenShopPurchase>;
+    onOffering(listener: (offering: DenShopOfferingEvent) => void): Unsubscribe;
+    private offeringOf;
     onChange(listener: (change: DenShopChange) => void): Unsubscribe;
     onBuy(listener: (purchase: DenShopPurchaseEvent) => void): Unsubscribe;
-    private update;
+    onSale(listener: (sale: DenShopSale) => void): Unsubscribe;
+    inDen(): Promise<DenShopStand[]>;
+    update(storeInvId: number, state: string, { list, unlist }: DenShopUpdate, timeoutMs?: number): Promise<DenShopChange>;
+    private isMe;
+    private send;
     private myShopItem;
 }
 type DenVisitors = Omit<PacketOf<typeof DenVisitorCount>, "room">;
+type DenVisit = {
+    userName: string;
+    entering: boolean;
+    count: number;
+    home: boolean;
+    at: number;
+};
+type DenGuest = {
+    userId: number;
+    userName: string;
+    avatarName: string;
+    uuid: string;
+    arrivedAt: number;
+    alreadyHere: boolean;
+};
+type DenGuestLeft = DenGuest & {
+    leftAt: number;
+};
+type DenPlacement = {
+    placed: number;
+    limit: number;
+    warningAt: number;
+    ownDen: boolean;
+};
 type DenPlacedItem = {
     defId: number;
     invIdx: number;
@@ -3513,17 +4615,114 @@ type EcoState = {
     unredeemedEcoCredits: number;
     secondsUntilNextEcoCredit: number;
 };
+type DenPurchaseAnswer = DenPurchase & {
+    currencyType: number;
+};
+type DenSale = {
+    invIdxs: number[];
+    gems: number | null;
+};
+type DenEcoConsumers = {
+    ecoPointsConsumed: number;
+    ecoScore: number;
+    consumers: DenEcoConsumer[];
+};
+type DenEcoRedemption = {
+    redeemed: boolean;
+    secondsUntilNextEcoCredit: number | null;
+};
+type DenPhantomChange = {
+    userId: number;
+    phantom: boolean;
+};
+type DenOwnedItems = {
+    activeDenIdx: number;
+    items: DenOwnedItem[];
+    petsInDen: number[];
+};
+type DenServerState = {
+    forceReload: boolean;
+    items: DenStateEntry[];
+    pets: DenStatePet[];
+};
+type DenItemSave = {
+    invIdx: number;
+    refId?: number;
+    placed?: boolean;
+    x?: number;
+    y?: number;
+    flipped?: number;
+    userNameLink?: string;
+};
+type HeldDenShop = {
+    storeInvId: number;
+    state: string;
+    listings: HeldDenShopListing[];
+};
+type HeldDenShopListing = {
+    itemType: number;
+    invIdx: number;
+    defId: number;
+    cost: number;
+    currencyType: number;
+    shopInvIdx: number;
+};
+type DenRoomChange = {
+    denRoomDefId: number;
+    perUserAvId: number | null;
+    activePetInvId: number | null;
+};
 declare class DensApi {
     readonly [STATE_FIELDS]: readonly [
-        "visitorCount"
+        "visitorCount",
+        "ownName",
+        "home",
+        "guestsById",
+        "roomChangeHeard",
+        "kickedAtHeard",
+        "purchaseHeard",
+        "saleHeard",
+        "emptiedAtHeard",
+        "ecoStateHeard",
+        "ecoRedemptionHeard",
+        "ecoConsumerStates",
+        "activeDenIdxHeard",
+        "stateHeard"
     ];
     private visitorCount;
     private readonly visitorListeners;
+    private readonly visitListeners;
     private readonly kickListeners;
+    private ownName;
+    private home;
+    private readonly guestsById;
+    private guestWork;
+    private settlingSince;
+    private readonly arriveListeners;
+    private readonly leaveListeners;
+    private readonly homeListeners;
     private readonly flash;
     private readonly client;
     private readonly server;
+    private readonly clientSide;
+    private roomChangeHeard;
+    private kickedAtHeard;
+    private purchaseHeard;
+    private saleHeard;
+    private emptiedAtHeard;
+    private ecoStateHeard;
+    private ecoRedemptionHeard;
+    private readonly ecoConsumerStates;
+    private activeDenIdxHeard;
+    private stateHeard;
+    private readonly specialTypes;
+    private defWork;
     constructor(game: GameContext, flash: PhantomFlash);
+    get inOwnDen(): boolean;
+    get guests(): readonly DenGuest[];
+    onGuestArrive(listener: (guest: DenGuest) => void): Unsubscribe;
+    onGuestLeave(listener: (guest: DenGuestLeft) => void): Unsubscribe;
+    onOwnDen(listener: (inside: boolean) => void): Unsubscribe;
     join(owner: string): Promise<void>;
     joinOwn(): Promise<void>;
     isOwnDen(): Promise<boolean>;
@@ -3534,6 +4733,7 @@ declare class DensApi {
     switchRoom(invIdx: number): Promise<void>;
     get visitors(): DenVisitors | null;
     onVisitors(listener: (visitors: DenVisitors) => void): () => void;
+    onVisit(listener: (visit: DenVisit) => void): Unsubscribe;
     onKicked(listener: () => void): () => void;
     onEntered(listener: (den: {
         ownerName: string;
@@ -3572,6 +4772,7 @@ declare class DensApi {
         ecoScore: number;
     }>;
     items(): Promise<DenPlacedItem[]>;
+    placement(): Promise<DenPlacement | null>;
     moveItem(item: Pick<DenPlacedItem, "refId" | "invIdx">, placement: DenItemPlacement): Promise<boolean>;
     inventory(timeoutMs?: number): Promise<DenInventoryItem[]>;
     itemDefinition(defId: number): Promise<DenItemDefinition | null>;
@@ -3586,13 +4787,54 @@ declare class DensApi {
     recycleItems(...invIdxs: number[]): Promise<number[]>;
     empty(): Promise<void>;
     saveLayout(): Promise<void>;
+    get roomChange(): DenRoomChange | null;
+    get kickedAt(): number | null;
+    get lastPurchase(): DenPurchaseAnswer | null;
+    onPurchase(listener: (purchase: DenPurchaseAnswer) => void): Unsubscribe;
+    get lastSale(): DenSale | null;
+    onSale(listener: (sale: DenSale) => void): Unsubscribe;
+    get emptiedAt(): number | null;
+    onEmptied(listener: () => void): Unsubscribe;
+    epicDens(timeoutMs?: number): Promise<string[]>;
+    onEpicDens(listener: (userNames: string[]) => void): Unsubscribe;
+    setPhantom(phantom: boolean, timeoutMs?: number): Promise<DenPhantomChange | null>;
+    onPhantom(listener: (change: DenPhantomChange) => void): Unsubscribe;
+    get lastEcoState(): EcoState | null;
+    onEcoState(listener: (state: EcoState) => void): Unsubscribe;
+    get lastEcoRedemption(): DenEcoRedemption | null;
+    onEcoCreditsRedeemed(listener: (redemption: DenEcoRedemption) => void): Unsubscribe;
+    get ecoConsumers(): ReadonlyMap<number, number>;
+    onEcoConsumers(listener: (consumers: DenEcoConsumers) => void): Unsubscribe;
+    get activeDenIdx(): number | null;
+    onItemList(listener: (items: DenOwnedItems) => void): Unsubscribe;
+    serverState(): Promise<DenServerState | null>;
+    onState(listener: (state: DenServerState) => void): Unsubscribe;
+    saveItems(changes: DenItemSave[], timeoutMs?: number): Promise<number[]>;
+    onSaved(listener: (invIdxs: number[]) => void): Unsubscribe;
+    onSaving(listener: (changes: DenStateChange[]) => void): Unsubscribe;
+    isChangePending(): Promise<boolean>;
+    openDenShopId(): Promise<number | null>;
+    heldDenShop(storeInvId: number): Promise<HeldDenShop | null>;
     private placedItems;
     private placedItem;
     private ownedItems;
     private findOwnedItem;
     private readOwnedItem;
     private readPlacementFields;
+    private saveRow;
+    private findPlaced;
+    private readWithDefs;
+    private lookUpSpecialType;
+    private queueDefs;
+    private holder;
+    private editorOpen;
+    private saveWithoutEditor;
+    private heldStateItems;
+    private markSaved;
     private playerName;
+    private queueGuests;
+    private isOwnDenName;
+    private isOwnName;
 }
 type JamAGramDraft = {
     message: string;
@@ -3603,13 +4845,38 @@ type JamAGramDraft = {
     giftInvId?: number;
     specialType?: number;
 };
+type JamAGramBuddyAnswerOutcome = {
+    messageId: number | null;
+    accept: boolean | null;
+    result: number;
+    refused: boolean;
+    heardAt: number;
+};
+type ClientJamAGram = {
+    messageId: number;
+    senderUserName: string;
+    senderModeratedUserName: string;
+    read: boolean;
+    message: string;
+    type: number;
+    giftId: number;
+    giftName: string;
+    isGift: boolean;
+    cardMediaId: number;
+    stampMediaId: number;
+    specialType: number;
+};
 declare class ECardsApi {
     readonly [STATE_FIELDS]: readonly [
-        "cards"
+        "cards",
+        "buddyAnswer"
     ];
     private readonly flash;
     private readonly server;
     private readonly cards;
+    private buddyAnswer;
+    private readonly answering;
+    private readonly buddyAnswerListeners;
     private readonly receivedListeners;
     private readonly updatedListeners;
     private readonly removedListeners;
@@ -3638,6 +4905,11 @@ declare class ECardsApi {
     acceptGift(messageId: number, colorIndex?: number, timeoutMs?: number): Promise<void>;
     discardGift(messageId: number, timeoutMs?: number): Promise<void>;
     respondToBuddyRequest(messageId: number, accept: boolean): Promise<void>;
+    get lastBuddyAnswer(): JamAGramBuddyAnswerOutcome | null;
+    onBuddyAnswer(listener: (answer: JamAGramBuddyAnswerOutcome) => void): Unsubscribe;
+    onInbox(listener: (cards: JamAGram[]) => void): Unsubscribe;
+    clientInbox(): Promise<ClientJamAGram[]>;
+    clientInboxLoaded(): Promise<boolean>;
     openComposer(userName: string, moderatedUserName?: string): Promise<void>;
     closeInbox(): Promise<void>;
     isComposerOpen(): Promise<boolean>;
@@ -3864,6 +5136,7 @@ type GameScreenToClose = keyof typeof CLOSERS;
 declare class GuiApi {
     private readonly bridge;
     private readonly flash;
+    private currencyPin;
     constructor(game: GameContext, flash: PhantomFlash);
     tree(options?: {
         from?: GuiRoot | GuiTarget;
@@ -3911,6 +5184,10 @@ declare class GuiApi {
     grayHudAvatar(gray?: boolean): Promise<void>;
     toggleHud(): Promise<void>;
     isDarkened(): Promise<boolean>;
+    pinCurrency(): Promise<void>;
+    unpinCurrency(): Promise<void>;
+    get currencyPinned(): boolean;
+    private rollCurrency;
     private chatField;
     private setFieldText;
     private counter;
@@ -3949,6 +5226,18 @@ type PurchaseResult = {
     balance: number | null;
     currencyType: number;
 };
+type AvatarSlot = {
+    perUserAvId: number;
+    avInvId: number;
+};
+type ItemPrizeOffer = {
+    defId: number;
+    isClothing: boolean;
+    color: number;
+    userVarId: number;
+    nameStrId: number;
+    descStrId: number;
+};
 type RecycleResult = {
     recycled: number[];
     gems: number | null;
@@ -3956,13 +5245,17 @@ type RecycleResult = {
 declare class InventoryApi {
     readonly [STATE_FIELDS]: readonly [
         "inventory",
-        "slots"
+        "slots",
+        "prize"
     ];
     private readonly flash;
     private readonly server;
     private inventory;
     private readonly slots;
     private readonly changeListeners;
+    private readonly slotListeners;
+    private readonly prizeListeners;
+    private prize;
     constructor(game: GameContext);
     items({ refresh }?: {
         refresh?: boolean;
@@ -3981,6 +5274,10 @@ declare class InventoryApi {
     }>;
     onChange(listener: (change: InventoryChange) => void): () => void;
     onUse(listener: (success: boolean) => void): () => void;
+    avatarSlots(): AvatarSlot[];
+    onAvatarSlot(listener: (slot: AvatarSlot) => void): Unsubscribe;
+    get latestPrize(): ItemPrizeOffer | null;
+    onPrize(listener: (prize: ItemPrizeOffer) => void): Unsubscribe;
     wear(...invIds: number[]): Promise<boolean>;
     takeOff(...invIds: number[]): Promise<boolean>;
     change({ wear, remove, }: {
@@ -3993,6 +5290,7 @@ declare class InventoryApi {
         diamond?: boolean;
     }): Promise<PurchaseResult>;
     recycle(...invIds: number[]): Promise<RecycleResult>;
+    private keepSlot;
     private keep;
     private apply;
 }
@@ -4009,6 +5307,11 @@ declare class LocalizationApi {
     private codes;
     constructor(game: GameContext, flash: PhantomFlash);
     currentLanguage(): Promise<Language>;
+    accountLanguage(): Promise<Language>;
+    languageForLocale(locale: string): Promise<Language | null>;
+    sortingLocale(): Promise<string>;
+    numberLocale(): Promise<string>;
+    countryCode(): Promise<string>;
     hasLocalizations(): Promise<boolean>;
     translate(id: number): Promise<string>;
     translatePreferred(id: number): Promise<string>;
@@ -4024,12 +5327,48 @@ declare class LocalizationApi {
     private languageCodes;
 }
 type Masterpiece = DenMasterpieceItem;
+type MasterpieceList = {
+    userName: string | null;
+    items: Masterpiece[];
+};
+type MasterpieceCreator = {
+    denUserName: string | null;
+    uniqueImageId: string | null;
+    creatorName: string;
+};
+type MasterpieceLikes = {
+    count: number;
+    liked: boolean;
+};
+type MasterpieceLikesEvent = MasterpieceLikes & {
+    uniqueImageId: string;
+    ok: boolean;
+};
+type MasterpieceLiked = {
+    uniqueImageId: string;
+    ok: boolean;
+};
+type LikeableMasterpiece = Pick<Masterpiece, "uniqueImageId" | "uniqueImageCreatorUUID" | "uniqueImageCreatorDbId" | "version">;
 declare class MasterpiecesApi {
     private readonly flash;
     private readonly server;
+    private readonly itemsAsked;
+    private readonly creatorsAsked;
+    private readonly likesAsked;
+    private readonly likesGiven;
+    private readonly itemsListeners;
+    private readonly creatorListeners;
+    private readonly likesListeners;
+    private readonly likedListeners;
     constructor(game: GameContext);
     itemsOf(userName: string, timeoutMs?: number): Promise<Masterpiece[]>;
     creatorOf(denUserName: string, uniqueImageId: string, timeoutMs?: number): Promise<string>;
+    likes(uniqueImageId: string, timeoutMs?: number): Promise<MasterpieceLikes>;
+    like(masterpiece: LikeableMasterpiece, timeoutMs?: number): Promise<boolean>;
+    onItems(listener: (list: MasterpieceList) => void): Unsubscribe;
+    onCreator(listener: (creator: MasterpieceCreator) => void): Unsubscribe;
+    onLikes(listener: (likes: MasterpieceLikesEvent) => void): Unsubscribe;
+    onLiked(listener: (liked: MasterpieceLiked) => void): Unsubscribe;
 }
 type ConnectFourMark = "me" | "opponent" | null;
 type ConnectFourBoard = ReadonlyArray<ReadonlyArray<ConnectFourMark>>;
@@ -4223,6 +5562,7 @@ type MinigameStatus = {
     fullRoomGame: boolean;
     roomName: string;
     pending: PendingMinigame | null;
+    roomEnvironment: number | null;
 };
 type PendingMinigame = {
     gameDefId: number;
@@ -4245,6 +5585,50 @@ type CachedLeaderboard = {
     thisWeek: LeaderboardEntry[];
     buddies: LeaderboardEntry[];
 };
+type ClientLeaderboard = {
+    gameDefId: number;
+    cachedAt: number;
+    allTime: LeaderboardEntry[];
+    thisWeek: LeaderboardEntry[];
+    buddies: LeaderboardEntry[];
+};
+type MinigameJoinRecord = MinigameJoinAnswer & {
+    gameDefId: number | null;
+    heardAt: number;
+};
+type PendingPvpInvite = {
+    gameDefId: number;
+    userName: string;
+    nameVisible: boolean;
+    heardAt: number;
+};
+type MinigameSerials = {
+    gems: number | null;
+    score: number | null;
+    mastery: number | null;
+};
+type MinigameGemSerial = {
+    serial: number;
+    forScore: boolean;
+};
+type MinigameMasterySerial = {
+    serial: number;
+    showPopup: boolean;
+};
+type MinigameAwardSent = {
+    serial: number | null;
+    award: MinigameAward | null;
+    sums: MinigameAwardSums;
+};
+type MinigameScoreSent = {
+    serial: number | null;
+    score: MinigameScore | null;
+    sums: MinigameScoreSums;
+};
+type MinigamePlayerInfo = {
+    activePetName: string;
+    member: boolean;
+};
 type MinigameJoinOptions = {
     multiplayer?: boolean;
     proModeId?: number;
@@ -4256,6 +5640,9 @@ declare class MinigamesApi {
         "requested",
         "session",
         "boards",
+        "joinAnswer",
+        "invite",
+        "serialsHeard",
         "ticTacToe",
         "connectFour",
         "rockPaperScissors",
@@ -4269,6 +5656,14 @@ declare class MinigamesApi {
     private requested;
     private session;
     private readonly boards;
+    private joinAnswer;
+    private invite;
+    private serialsHeard;
+    private readonly gemSerialListeners;
+    private readonly masterySerialListeners;
+    private readonly gemAwardListeners;
+    private readonly masteryAwardListeners;
+    private readonly scoreListeners;
     readonly ticTacToe: MinigameTicTacToeApi;
     readonly connectFour: MinigameConnectFourApi;
     readonly rockPaperScissors: MinigameRockPaperScissorsApi;
@@ -4315,6 +5710,20 @@ declare class MinigamesApi {
     chat(text: string): Promise<void>;
     onPlayerLeft(listener: (left: PacketOf<typeof MinigameLeft>) => void): () => void;
     onRoomRemoved(listener: (removed: PacketOf<typeof MinigameRoomRemoved>) => void): () => void;
+    onLeaderboard(listener: (board: MinigameLeaderboardAnswer) => void): Unsubscribe;
+    clientLeaderboard(gameDefId: number): Promise<ClientLeaderboard | null>;
+    get lastJoin(): MinigameJoinRecord | null;
+    get pvpInvite(): PendingPvpInvite | null;
+    get serials(): MinigameSerials;
+    onGemSerial(listener: (serial: MinigameGemSerial) => void): Unsubscribe;
+    onMasterySerial(listener: (serial: MinigameMasterySerial) => void): Unsubscribe;
+    onGemAward(listener: (sent: MinigameAwardSent) => void): Unsubscribe;
+    onPetMasteryAward(listener: (sent: MinigameAwardSent) => void): Unsubscribe;
+    onScore(listener: (sent: MinigameScoreSent) => void): Unsubscribe;
+    quit(): Promise<void>;
+    playerInfo(): Promise<MinigamePlayerInfo>;
+    gameNameId(gameDefId: number): Promise<number | null>;
+    isMemberAccountType(accountType: number): Promise<boolean>;
     private pendingGame;
     private infoCache;
     private lookUp;
@@ -4322,6 +5731,56 @@ declare class MinigamesApi {
     private manager;
     private comm;
 }
+type Membership = {
+    userName: string;
+    accountType: number;
+    member: boolean;
+    daysLeft: number;
+    endsAt: number | null;
+    sourceType: string | null;
+    heardAt: number;
+    cause: "login" | "redeemed";
+};
+type MembershipLook = {
+    accountType: number;
+    daysLeft: number;
+};
+type MembershipLookOptions = {
+    accountType?: number;
+    daysLeft?: number;
+};
+type ShownMembership = {
+    accountType: number;
+    member: boolean;
+    daysLeft: number;
+};
+declare class MembershipApi {
+    readonly [STATE_FIELDS]: readonly [
+        "heard"
+    ];
+    private heard;
+    private current;
+    private hooks;
+    private questRoom;
+    private readonly changeListeners;
+    private readonly lookListeners;
+    private readonly flash;
+    private readonly server;
+    private readonly client;
+    constructor(game: GameContext);
+    get real(): Membership | null;
+    onChange(listener: (membership: Membership) => void): Unsubscribe;
+    shown(): Promise<ShownMembership>;
+    get showing(): MembershipLook | null;
+    onShowing(listener: (look: MembershipLook | null) => void): Unsubscribe;
+    show(options?: MembershipLookOptions): Promise<MembershipLook>;
+    stopShowing(): Promise<void>;
+    private hear;
+    private hook;
+    private rewriteLogin;
+    private tellGame;
+    private isOwn;
+}
 type NewspaperIssue = {
     defId: number;
     title: string;
@@ -4345,6 +5804,7 @@ declare class NewspaperApi {
     private readonly seenListeners;
     constructor(game: GameContext);
     definitions(): Promise<NewspaperIssue[]>;
+    definition(defId: number): Promise<NewspaperIssue | null>;
     dataOf(defId: number): Promise<NewspaperReadState | null>;
     hasUnseenPages(): Promise<boolean>;
     hasSeenFirstPage(): Promise<boolean>;
@@ -4463,14 +5923,64 @@ type AdoptionTier = {
     complete: boolean;
     thresholds: number[];
 };
+type AdoptionChecklist = {
+    success: boolean;
+    cards: AdoptAPetCard[];
+};
+type PetRestyle = {
+    success: boolean;
+    gems: number;
+    invId: number;
+    lBits: number;
+    uBits: number;
+    eBits: number;
+};
+type PetWornSlots = {
+    cat9: number;
+    cat10: number;
+    cat11: number;
+};
+type PetEnviroType = number;
+type PetAsItem = {
+    invId: number;
+    defId: number;
+    name: string;
+    type: number;
+    enviroType: PetEnviroType;
+    recycleValue: number;
+    currencyType: number;
+    membersOnly: boolean;
+    isEgg: boolean;
+    isHatched: boolean;
+    isAvailable: boolean;
+    isInDenShop: boolean;
+    isDiamond: boolean;
+    isRare: boolean;
+};
+type PetPictureOptions = {
+    scale?: number;
+    background?: number | null;
+    maxSize?: number;
+    timeoutMs?: number;
+};
 declare class PetsApi {
     private readonly flash;
     private readonly server;
     private readonly switchListeners;
     private readonly listListeners;
     private readonly dismissListeners;
-    constructor(game: GameContext);
+    private readonly createdListeners;
+    private readonly eggNamedListeners;
+    private readonly masteryListeners;
+    private readonly restyleListeners;
+    private readonly unlockListeners;
+    private readonly checklistListeners;
+    private readonly adoptionCountListeners;
+    private unlockedField;
+    private readonly hooks;
+    constructor(game: GameContext, flash?: PhantomFlash);
     list(): Promise<PlayerPet[]>;
+    private petRecord;
     activeInvId(): Promise<number>;
     active(): Promise<PlayerPet | null>;
     activeName(): Promise<string>;
@@ -4524,9 +6034,67 @@ declare class PetsApi {
         uBits: number;
         eBits: number;
     }>;
+    buy(shopId: number, itemDefId: number, bits: {
+        lBits: number;
+        uBits: number;
+        eBits: number;
+    }, name: {
+        firstNameLocId: number;
+        secondNameLocId: number;
+    }, options?: {
+        fromRedemption?: boolean;
+        timeoutMs?: number;
+    }): Promise<CreatedPet>;
+    restyle(worn: PetWornSlots, options?: {
+        enviroType?: PetEnviroType;
+        timeoutMs?: number;
+    }): Promise<PetRestyle>;
+    adoptionChecklistOf(userName: string, timeoutMs?: number): Promise<AdoptionChecklist>;
+    adoptionCountOf(userName: string, timeoutMs?: number): Promise<number>;
+    adoptionCardDefs(): Promise<AdoptionCardDef[]>;
+    adoptionCardTotal(): Promise<number>;
+    hasAdoptionCards(): Promise<boolean>;
+    definitions(): Promise<PetDefinition[]>;
+    unlockedKinds(): Promise<number[]>;
+    goesOnLandAndInOcean(pet: {
+        defId: number;
+        createdTs: number;
+    }): Promise<boolean>;
+    goesWith(pet: {
+        defId: number;
+        createdTs: number;
+    }, enviroTypeFlag?: number): Promise<boolean>;
+    enviroTypeOf(pet: {
+        defId: number;
+        createdTs: number;
+    }, enviroTypeFlag?: number): Promise<PetEnviroType>;
+    isGroundType(type: number): Promise<boolean>;
+    kindOfBits(lBits: number): Promise<number>;
+    listAsItems(): Promise<PetAsItem[]>;
+    picture(pet: {
+        lBits: number;
+        uBits: number;
+        eBits: number;
+        createdTs?: number;
+        invId?: number;
+        name?: string;
+        personalityDefId?: number;
+        favoriteFoodDefId?: number;
+        favoriteToyDefId?: number;
+    }, options?: PetPictureOptions): Promise<string>;
+    private playerEnviroTypeFlag;
+    private withDefinition;
     onSwitch(listener: (change: PetSwitch) => void): () => void;
     onList(listener: (list: PacketOf<typeof PetList>) => void): () => void;
     onDismissed(listener: (dismissed: PacketOf<typeof PetDismissed>) => void): () => void;
+    onCreated(listener: (created: CreatedPet) => void): () => void;
+    onEggNamed(listener: (named: NamedEggPet) => void): () => void;
+    onMasteryBadge(listener: (result: PetMasteryResult) => void): () => void;
+    onRestyled(listener: (restyle: PetRestyle) => void): () => void;
+    onUnlocked(listener: (defIds: number[]) => void): () => void;
+    onAdoptionChecklist(listener: (checklist: AdoptionChecklist) => void): () => void;
+    onAdoptionCount(listener: (count: number) => void): () => void;
+    onDefinitionsLoaded(listener: () => void): () => void;
 }
 type CachedWall = {
     posts: WallPost[];
@@ -4568,10 +6136,67 @@ type WallContents = {
     notifications: WallPost[];
     parameters: WallValue;
 };
+type WallAccess = {
+    userName: string | null;
+    granted: boolean;
+    result: string;
+    read: boolean;
+    write: boolean;
+};
+type WallPrivacyAnswer = {
+    userName: string | null;
+    setting: number;
+};
+type WallPrivacyChange = {
+    setting: number | null;
+    ok: boolean;
+};
+type WallParametersChange = {
+    changes: WallValue;
+    ok: boolean;
+};
+type WallVisit = {
+    userName: string | null;
+    ok: boolean;
+};
+type WallLikes = {
+    count: number;
+    liked: boolean;
+};
+type WallLikesEvent = WallLikes & {
+    ownerUuid: string;
+    ok: boolean;
+};
+type WallLiked = {
+    ownerUuid: string;
+    ok: boolean;
+};
+type WallServiceRequest = {
+    command: string;
+    fields: {
+        [key: string]: WallValue;
+    };
+};
 declare class PlayerWallApi {
     private readonly flash;
+    private readonly hooks;
+    private readonly server;
     private readonly postsListeners;
-    constructor(game: GameContext);
+    private readonly tokensAsked;
+    private readonly privacyAsked;
+    private readonly privacySet;
+    private readonly parametersSent;
+    private readonly visitsCounted;
+    private readonly likesAsked;
+    private readonly likesGiven;
+    private readonly accessListeners;
+    private readonly privacyListeners;
+    private readonly privacyChangeListeners;
+    private readonly parametersListeners;
+    private readonly visitListeners;
+    private readonly likesListeners;
+    private readonly likedListeners;
+    constructor(game: GameContext, hooks: PhantomFlash);
     posts(userName?: string, timeoutMs?: number): Promise<WallContents>;
     check(userName?: string, timeoutMs?: number): Promise<WallValue>;
     post(userName: string, message: string, options?: WallPostOptions, timeoutMs?: number): Promise<void>;
@@ -4594,6 +6219,19 @@ declare class PlayerWallApi {
     isOwnWallOpen(): Promise<boolean>;
     openWallOwner(): Promise<string | null>;
     onPosts(listener: (wall: WallContents) => void): Unsubscribe;
+    requestPermissions(userName: string, timeoutMs?: number): Promise<WallPermissions>;
+    likes(ownerUuid: string, timeoutMs?: number): Promise<WallLikes>;
+    like(ownerUuid: string, timeoutMs?: number): Promise<boolean>;
+    hasOpenedOwnWall(): Promise<boolean>;
+    hasCountedVisit(userName: string): Promise<boolean>;
+    onAccess(listener: (access: WallAccess) => void): Unsubscribe;
+    onPrivacy(listener: (answer: WallPrivacyAnswer) => void): Unsubscribe;
+    onPrivacyChange(listener: (change: WallPrivacyChange) => void): Unsubscribe;
+    onParametersChange(listener: (change: WallParametersChange) => void): Unsubscribe;
+    onVisitCounted(listener: (visit: WallVisit) => void): Unsubscribe;
+    onLikes(listener: (likes: WallLikesEvent) => void): Unsubscribe;
+    onLiked(listener: (liked: WallLiked) => void): Unsubscribe;
+    onServiceRequest(listener: (request: WallServiceRequest) => void): () => void;
     private request;
     myPrivacy(): Promise<number | null>;
     cached(): Promise<CachedWall>;
@@ -4655,15 +6293,131 @@ type DisciplineEvent = {
     disconnects: boolean;
     extra: readonly string[];
 };
+type PlayerPrivacy = {
+    den: number;
+    eCards: number;
+    playerWall: number;
+    webPlayerWall: number;
+};
+type PlayerState = {
+    userName: string;
+    uuid: string;
+    avatarId: number;
+    accountType: number;
+    member: boolean;
+    moderator: boolean;
+    guide: boolean;
+    silenced: boolean;
+    chat: PlayerChatType;
+    loginCount: number;
+    createdAt: number;
+    worldMapRoom: string;
+    pendingFlags: number;
+    tourDone: boolean;
+    needsFirstAnimal: boolean;
+    privacy: PlayerPrivacy;
+    animalDefsLoaded: boolean;
+    hostingParty: boolean;
+};
+type PlayerStateChange = {
+    state: PlayerState;
+    changed: Array<keyof PlayerState>;
+};
+type PlayerRecord = {
+    userName: string;
+    uuid: string;
+    accountType: number;
+    member: boolean;
+    guide: boolean;
+    nameApproved: boolean;
+    shownName: string;
+    currentAvatarId: number;
+    avatarIds: number[];
+    daysSinceLastLogin: number;
+    hostingParty: boolean;
+    lastAchievementRequest: number;
+    achievementsByType: Record<number, number>;
+};
+type KnownAvatar = {
+    userName: string;
+    perUserAvId: number;
+    avInvId: number;
+    avName: string;
+    avTypeId: number;
+    customAvId: number;
+    colors: number[];
+    enviroType: number;
+    questLevel: number;
+    questXp: number;
+    questHealthPercentage: number;
+    dead: boolean;
+};
+type ClothingItem = {
+    invIdx: number;
+    defId: number;
+    name: string;
+    color: number;
+    layerId: number;
+    enviroType: number;
+    membersOnly: boolean;
+    inDenShop: boolean;
+};
+type AnimalDefaults = {
+    colors: [
+        number,
+        number,
+        number
+    ];
+    eyes: number;
+    enviroTypeFlag: number;
+};
+type AnimalKind = {
+    defId: number;
+    titleStrId: number;
+    membersOnly: boolean;
+    enviroTypeFlag: number;
+    defEyes: number;
+    defPattern: number;
+    colors: [
+        number,
+        number,
+        number
+    ];
+    custom: {
+        avatarRefId: number;
+        iconRefId: number;
+        particleRefId: number;
+        patternRefIds: number[];
+    } | null;
+};
+type DenRoomDefinition = {
+    defId: number;
+    name: string;
+    titleStrId: number;
+    cost: number;
+    enviroType: number;
+    roomDefId: number;
+    status: number;
+    membersOnly: boolean;
+    mediaId: number;
+    mediaIdLarge: number;
+    availabilityStartTime: number;
+    availabilityEndTime: number;
+};
+type PartyHosting = {
+    userName: string;
+    secondsLeft: number;
+};
 declare class PlayerApi {
     readonly [STATE_FIELDS]: readonly [
         "player"
     ];
     private readonly flash;
+    private readonly client;
     private readonly server;
     private player;
     private readonly listeners;
-    constructor(game: GameContext);
+    constructor(game: GameContext, flash: PhantomFlash);
     get login(): LoginPlayer | null;
     onLogin(listener: (player: LoginPlayer) => void): Unsubscribe;
     userName(): Promise<string>;
@@ -4690,7 +6444,37 @@ declare class PlayerApi {
     setInvisible(on: boolean, timeoutMs?: number): Promise<boolean>;
     discipline(): Promise<PlayerDiscipline>;
     onDiscipline(listener: (event: DisciplineEvent) => void): Unsubscribe;
+    onInvisibleChange(listener: (invisible: boolean) => void): Unsubscribe;
+    state(): Promise<PlayerState>;
+    onChange(listener: (change: PlayerStateChange) => void, options?: {
+        everyFrames?: number;
+    }): Unsubscribe;
+    record(userName?: string): Promise<PlayerRecord | null>;
+    avatars(userName?: string): Promise<KnownAvatar[]>;
+    avatarOf(userName: string, perUserAvId?: number): Promise<KnownAvatar | null>;
+    partyTimeLeft(userName?: string): Promise<number>;
+    onPartyHosting(listener: (hosting: PartyHosting) => void): Unsubscribe;
+    onTradeListChange(listener: () => void): Unsubscribe;
+    clothing(options?: {
+        avTypeId?: number;
+        bodyMods?: boolean;
+    }): Promise<ClothingItem[]>;
+    denItemsForRoom(): Promise<DenInventoryItem[]>;
+    petsInDen(world: "land" | "ocean"): Promise<DenInventoryItem[]>;
+    animalKindCount(): Promise<number>;
+    animalDefaults(avTypeId: number): Promise<AnimalDefaults>;
+    customAnimal(customAvId: number): Promise<AnimalKind | null>;
+    customAnimalsOf(avTypeId: number): Promise<AnimalKind[]>;
+    animalOf(userName?: string): Promise<AnimalKind | null>;
+    denRoomDefinitions(): Promise<DenRoomDefinition[]>;
+    denRoomDefinition(defId: number): Promise<DenRoomDefinition | null>;
+    private hear;
+    private stateSources;
+    private recordOf;
+    private avatarHandles;
+    private readCollection;
     private userInfo;
+    private playerUserInfo;
 }
 declare const REPORT_REASONS: {
     readonly mean: 1;
@@ -4712,12 +6496,23 @@ declare const CONTENT_DATA_TYPE: {
     readonly masterpiece: 8;
 };
 type ReportedContent = keyof typeof CONTENT_DATA_TYPE;
+type SentReport = {
+    userName: string;
+    reason: ReportReason | null;
+    reasonId: number;
+    dataType: number | null;
+    data: string | null;
+};
 declare class ReportsApi {
     private readonly flash;
     private readonly server;
+    private readonly client;
     constructor(game: GameContext);
     report(userName: string, reason: ReportReason, timeoutMs?: number): Promise<boolean>;
     reportContent(userName: string, kind: ReportedContent, reason: ReportReason, data: string, timeoutMs?: number): Promise<boolean>;
+    onReportResult(listener: (taken: boolean) => void): Unsubscribe;
+    onContentReportResult(listener: (taken: boolean) => void): Unsubscribe;
+    onReportSent(listener: (report: SentReport) => void): Unsubscribe;
 }
 declare const WORLD_ITEM_GIFTS: readonly [
     "denItem",
@@ -4756,6 +6551,25 @@ type WorldItemTaken = {
     taken: boolean;
     balance: number | null;
 };
+type WorldItemTakenEvent = WorldItemTaken & {
+    defId: number | null;
+};
+type RoomDarkArea = {
+    x: number;
+    y: number;
+    rotation: number;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+type RoomObjectAt = {
+    name: string;
+    className: string;
+    isJourneyBookItem: boolean;
+};
 type RoomSpawn = {
     name: string;
     x: number;
@@ -4874,12 +6688,15 @@ declare class RoomApi {
     private roomLayout;
     private readonly listeners;
     private readonly failureListeners;
+    private readonly giftsAsked;
+    private readonly giftListeners;
     private readonly server;
     private readonly flash;
     constructor(game: GameContext);
     get current(): RoomInfo | null;
     get details(): RoomDetails | null;
     get layout(): RoomLayout | null;
+    onLayout(listener: (layout: RoomLayout) => void): () => void;
     toScreen(point: {
         x: number;
         y: number;
@@ -4896,6 +6713,7 @@ declare class RoomApi {
     }>;
     worldItem(defId: number): Promise<WorldItem | null>;
     takeWorldItem(defId: number, options?: WorldItemTakeOptions, timeoutMs?: number): Promise<WorldItemTaken>;
+    onWorldItemTaken(listener: (gift: WorldItemTakenEvent) => void): () => void;
     private hasTakenGift;
     onJoin(listener: (room: RoomInfo) => void): () => void;
     focusCamera(at: {
@@ -4959,6 +6777,25 @@ declare class RoomApi {
     setPathDepth(cells: number): Promise<void>;
     reload(): Promise<boolean>;
     showAvatars(show: boolean): Promise<void>;
+    joiningInvisibly(): Promise<boolean>;
+    darkAreas(): Promise<RoomDarkArea[]>;
+    nearestEmptyCell(point: {
+        x: number;
+        y: number;
+    }): Promise<{
+        x: number;
+        y: number;
+    } | null>;
+    journeyBookItemsLeft(): Promise<number>;
+    objectAt(point: {
+        x: number;
+        y: number;
+    }, options?: {
+        journeyBookOnly?: boolean;
+    }): Promise<RoomObjectAt | null>;
+    setJamaaTime(milliseconds: number): Promise<void>;
+    setDenKickNotice(show: boolean): Promise<void>;
+    private darkArea;
     private actors;
     private number;
     private convert;
@@ -4991,9 +6828,11 @@ type RoomPlayerView = {
 declare class RoomPlayers {
     readonly [STATE_FIELDS]: readonly [
         "byId",
-        "selfId"
+        "selfId",
+        "paths"
     ];
     private readonly byId;
+    private readonly paths;
     private readonly enterListeners;
     private readonly leaveListeners;
     private readonly moveListeners;
@@ -5008,6 +6847,10 @@ declare class RoomPlayers {
     onEnter(listener: (player: RoomPlayer) => void): () => void;
     onLeave(listener: (player: RoomPlayer) => void): () => void;
     onMove(listener: (player: RoomPlayer) => void): () => void;
+    pathOf(userId: number): Array<{
+        x: number;
+        y: number;
+    }> | null;
     refresh(): Promise<readonly RoomPlayer[]>;
     viewOf(userId: number): Promise<RoomPlayerView | null>;
     views(): Promise<RoomPlayerView[]>;
@@ -5023,9 +6866,15 @@ type ConnectionOutcome = {
     connected: boolean;
 };
 declare class SessionApi {
+    readonly [STATE_FIELDS]: readonly [
+        "validated"
+    ];
     private readonly bridge;
     private readonly flash;
     private readonly serverSide;
+    private readonly clientSide;
+    private validated;
+    private keepActiveTimer;
     constructor(game: GameContext, flash: PhantomFlash);
     connected(): Promise<boolean>;
     mode(): Promise<ConnectionMode>;
@@ -5038,6 +6887,18 @@ declare class SessionApi {
     }): Promise<void>;
     requestList(listId: number, timeoutMs?: number): Promise<ShopListFields>;
     onList(listener: (list: ShopListFields) => void): Unsubscribe;
+    inMinigame(): Promise<boolean>;
+    settingsUserName(): Promise<string>;
+    sendEmailActivation(email: string, timeoutMs?: number): Promise<boolean>;
+    onEmailActivation(listener: (sent: boolean) => void): Unsubscribe;
+    onEmailActivationRequest(listener: (email: string) => void): Unsubscribe;
+    get emailValidated(): boolean;
+    onEmailValidated(listener: () => void): Unsubscribe;
+    markActive(): Promise<void>;
+    keepActive(): Promise<void>;
+    stopKeepingActive(): Promise<void>;
+    get keepingActive(): boolean;
+    onIdleWarning(listener: () => void): Unsubscribe;
     private hookVoid;
 }
 type ItemDefinition = {
@@ -5086,6 +6947,21 @@ type ShopListing = {
     listType: number;
     defIds: number[];
 };
+type ItemPictureKind = "clothing" | "den-item";
+type ItemPictureItem = number | {
+    defId: number;
+    kind?: ItemPictureKind;
+    color?: number;
+};
+type ItemPictureOptions = {
+    scale?: number;
+    background?: number | null;
+    maxSize?: number;
+    large?: boolean;
+    version?: number;
+    timeoutMs?: number;
+    cache?: boolean;
+};
 type DenShopOffering = {
     shopId: number;
     listType: number;
@@ -5143,6 +7019,7 @@ declare class ShopsApi {
     private readonly client;
     private readonly server;
     private readonly lists;
+    private readonly pictures;
     constructor(game: GameContext, flash: PhantomFlash);
     offering(shopId: number, { refresh, timeoutMs, }?: {
         refresh?: boolean;
@@ -5154,6 +7031,7 @@ declare class ShopsApi {
     }): Promise<DenShopOffering>;
     definition(defId: number): Promise<ItemDefinition | null>;
     definitionsReady(): Promise<boolean>;
+    picture(item: ItemPictureItem, options?: ItemPictureOptions): Promise<string>;
     isAvailable(window: {
         availabilityStartTime: number;
         availabilityEndTime: number;
@@ -5165,6 +7043,10 @@ declare class ShopsApi {
     }): Promise<DiamondDefinition | null>;
     diamondList(defIds: number[]): Promise<DiamondShopList>;
     listType(shopId: number): Promise<number | null>;
+    knownShops(): Promise<Array<{
+        shopId: number;
+        listType: number;
+    }>>;
     open(shopId: number): Promise<void>;
     close(): Promise<void>;
     isOpen(): Promise<boolean>;
@@ -5190,7 +7072,13 @@ declare class ShopsApi {
     onBuy(listener: (purchase: Purchase) => void): Unsubscribe;
     onSell(listener: (sale: Sale) => void): Unsubscribe;
     onList(listener: (listing: ShopListing) => void): Unsubscribe;
+    onDiamondBundleBuy(listener: (result: {
+        bought: boolean;
+        balance: number | null;
+    }) => void): Unsubscribe;
     private definitionsLoaded;
+    private drawClothing;
+    private drawDenItem;
     private listFor;
 }
 declare const BANKS: {
@@ -5319,6 +7207,24 @@ type TradeEnd = {
     userName: string | null;
     roomName: string | null;
 };
+type TradeDraftItem = TradeItemRef & {
+    defId: number;
+};
+type TradeCounts = {
+    myList: {
+        clothing: number;
+        den: number;
+        pets: number;
+    };
+    draft: {
+        clothing: number;
+        den: number;
+    };
+};
+type TradeListEdit = {
+    added: InventoryRef[];
+    removed: InventoryRef[];
+};
 type TradeListing = Omit<PacketOf<typeof TradeList>, "room">;
 declare class TradesApi {
     readonly [STATE_FIELDS]: readonly [
@@ -5326,6 +7232,7 @@ declare class TradesApi {
     ];
     private readonly flash;
     private readonly server;
+    private readonly clientSide;
     private pending;
     constructor(game: GameContext);
     get offer(): TradeOffer | null;
@@ -5347,6 +7254,11 @@ declare class TradesApi {
     heldList(): Promise<TradeItemRef[]>;
     list(userName: string, timeoutMs?: number): Promise<TradeListing>;
     onList(listener: (listing: TradeListing) => void): Unsubscribe;
+    onListChanged(listener: (edit: TradeListEdit) => void): Unsubscribe;
+    offerDraft(): Promise<TradeDraftItem[]>;
+    counts(): Promise<TradeCounts>;
+    listEntry(item: TradeItemRef): Promise<TradeItemRef | null>;
+    private ownCollection;
     private comm;
     private changeList;
     private endInClient;
@@ -5472,10 +7384,17 @@ type UiOptions = {
     height?: number;
     visible?: boolean;
 };
+type UiReadiness = {
+    art: boolean;
+    palettes: boolean;
+};
 type UiWindow = UiWidget & {
     readonly body: OverlayNode;
     readonly width: number;
     readonly height: number;
+    readonly bodyWidth: number;
+    readonly bodyHeight: number;
+    readonly framed: boolean;
     setTitle(title: string): Promise<void>;
     onClose(listener: () => void): UiRemove;
     onMove(listener: (position: {
@@ -5599,6 +7518,7 @@ type UiTooltip = UiWidget & {
 type UiTooltipOptions = UiOptions & {
     text?: string;
     visible?: boolean;
+    target?: UiWidget | OverlayNode;
 };
 type UiProgress = UiWidget & {
     value(): number;
@@ -5667,10 +7587,14 @@ declare class UiApi {
     private symbolMaker;
     private gameFont;
     private defaultSkin;
+    private readonly known;
+    readyTimeoutMs: number;
     readonly popup: UiPopups;
     constructor(game: GameContext, flash: PhantomFlash);
     get skin(): UiSkin;
     set skin(skin: UiSkin);
+    status(): Promise<UiReadiness>;
+    ready(timeoutMs?: number): Promise<UiReadiness>;
     theme(skin?: UiSkin): Promise<UiTheme>;
     symbols(): Array<[
         UiSymbolName,
@@ -5689,6 +7613,8 @@ declare class UiApi {
     grid(options: UiGridOptions): Promise<UiGrid>;
     scroll(options?: UiScrollOptions): Promise<UiScroll>;
     tooltip(options?: UiTooltipOptions): Promise<UiTooltip>;
+    private bubble;
+    private explain;
     progress(options?: UiProgressOptions): Promise<UiProgress>;
     colors(options?: UiColorsOptions): Promise<UiColors>;
     paletteValues(which?: 1 | 2 | "game"): Promise<number[]>;
@@ -5711,9 +7637,16 @@ declare class UiApi {
     private placeOf;
     private maker;
     private nodeObject;
+    private adopt;
+    private waitFor;
+    private artLoaded;
+    private palettesLoaded;
     private clientFont;
     private frameOnly;
     private dressWindow;
+    private frameClose;
+    private boundsOf;
+    private parchmentOf;
     private clientTooltip;
     private palette;
     private clientColorTable;
@@ -5766,6 +7699,23 @@ type PartyRules = {
     canSwitchPet: boolean;
 };
 type PartyHostOutcome = PacketOf<typeof CustomPartyHostResult>;
+type PartyJoinAnswer = {
+    kind: "party" | "custom";
+    joined: boolean;
+    reason: string | null;
+    extra: readonly string[];
+};
+type HostingStatus = {
+    state: "hosting";
+    secondsLeft: number | null;
+} | {
+    state: "refused";
+    reason: string | null;
+} | {
+    state: "ended";
+    diamondsRefunded: number;
+};
+type PartyMasterpiece = PoolMasterpiece;
 type CustomPartyWhereabouts = {
     creatorUuid: string;
     node: string;
@@ -5778,11 +7728,23 @@ type GoToPlayerResult = {
     switchingNode: boolean;
 };
 declare class WorldApi {
+    readonly [STATE_FIELDS]: readonly [
+        "listedRooms",
+        "loginKey",
+        "hopHost",
+        "partyJoin",
+        "hostingStatus"
+    ];
     private readonly partyFailureListeners;
     private readonly partyListListeners;
     private readonly partyNodeListeners;
     private readonly flash;
     private readonly server;
+    private readonly listedRooms;
+    private loginKey;
+    private hopHost;
+    private partyJoin;
+    private hostingStatus;
     constructor(game: GameContext);
     serverNode(): Promise<ServerNode>;
     shardId(): Promise<number>;
@@ -5803,7 +7765,9 @@ declare class WorldApi {
     onParties(listener: (parties: ScheduledParty[]) => void): () => void;
     onPartyNode(listener: (node: PacketOf<typeof CustomPartyNode>) => void): () => void;
     partyDefinition(defId: number): Promise<PartyDefinition | null>;
+    partyDefinitions(): Promise<PartyDefinition[]>;
     partyRules(): Promise<PartyRules>;
+    canUseAvatarHere(perUserAvId: number): Promise<boolean>;
     shardName(shardId: number): Promise<string>;
     hostParty(partyDefId: number, nameStrIds: readonly [
         number,
@@ -5813,11 +7777,441 @@ declare class WorldApi {
     onHostingEnded(listener: (ended: PacketOf<typeof CustomPartyKilled>) => void): () => void;
     partyNode(creatorUuid: string, timeoutMs?: number): Promise<CustomPartyWhereabouts | null>;
     hostingTimeLeft(creatorUuid: string, userName?: string, timeoutMs?: number): Promise<number>;
+    onHostingTimeLeft(listener: (secondsLeft: number) => void): () => void;
     showParties(open?: boolean): Promise<void>;
     onRoomList(listener: (rooms: readonly ListedRoom[]) => void): () => void;
     onRandomKey(listener: (key: string) => void): () => void;
+    get rooms(): readonly ListedRoom[];
+    get randomKey(): string | null;
+    get lastNodeHop(): string | null;
+    get lastPartyJoin(): PartyJoinAnswer | null;
+    get hosting(): HostingStatus | null;
+    onHostResult(listener: (outcome: PartyHostOutcome) => void): () => void;
+    onCustomParties(listener: (parties: CustomParty[]) => void): () => void;
+    onShards(listener: (nodes: ShardNode[]) => void): () => void;
+    partyMasterpieces(timeoutMs?: number): Promise<PartyMasterpiece[]>;
+    onPartyMasterpieces(listener: (pool: PartyMasterpiece[]) => void): () => void;
+    requestFirstFiveMinutesRoom(timeoutMs?: number): Promise<boolean>;
+    onFirstFiveMinutesRoom(listener: (ready: boolean) => void): () => void;
+    joinNamedRoom(roomName: string): Promise<void>;
+    roomDefinitions(): Promise<RoomDefinition[]>;
     private partyFailed;
 }
+type JourneyBookCounts = {
+    unseenPages: number;
+    unclaimedGifts: number;
+};
+declare class JourneyBookApi {
+    private readonly flash;
+    private readonly client;
+    constructor(game: GameContext, flash: PhantomFlash);
+    counts(): Promise<JourneyBookCounts>;
+    unseenPages(): Promise<number>;
+    unclaimedGifts(): Promise<number>;
+    open(factDefId?: number): Promise<void>;
+    onChange(listener: (counts: JourneyBookCounts) => void): Unsubscribe;
+}
+type ReferralCodeInfo = {
+    code: string;
+    link: string;
+};
+type ReferredPlayer = Referral & {
+    member: boolean;
+};
+type ReferralPage = {
+    referrals: ReferredPlayer[];
+    more: boolean;
+    status: number;
+};
+type ReferrerOutcome = "recorded" | "refused" | "failed";
+declare class ReferralsApi {
+    readonly [STATE_FIELDS]: readonly [
+        "heardCode"
+    ];
+    private readonly flash;
+    private readonly server;
+    private heardCode;
+    constructor(game: GameContext);
+    get code(): string | null;
+    fetchCode(timeoutMs?: number): Promise<ReferralCodeInfo>;
+    clientCode(): Promise<string | null>;
+    hasReferrer(timeoutMs?: number): Promise<boolean>;
+    nameReferrer(userName: string, timeoutMs?: number): Promise<ReferrerOutcome>;
+    list(options?: {
+        page?: number;
+        pageSize?: number;
+        timeoutMs?: number;
+    }): Promise<ReferralPage>;
+    onCode(listener: (code: ReferralCodeInfo | null) => void): Unsubscribe;
+    onHasReferrer(listener: (hasReferrer: boolean) => void): Unsubscribe;
+    onReferrerNamed(listener: (outcome: ReferrerOutcome) => void): Unsubscribe;
+    onList(listener: (page: ReferralPage) => void): Unsubscribe;
+}
+type ShortcutOptions = {
+    release?: boolean;
+    repeat?: boolean;
+    consume?: boolean;
+    anyModifiers?: boolean;
+};
+type Shortcut = Required<ShortcutOptions> & {
+    shortcut: string;
+};
+type ShortcutPress = {
+    shortcut: string;
+    phase: "down" | "up";
+    code: number;
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    consumed: boolean;
+};
+declare class InputApi {
+    private readonly flash;
+    private readonly bindings;
+    private readonly listeners;
+    private readonly held;
+    constructor(game: GameContext);
+    bind(shortcut: string, options?: ShortcutOptions): Promise<Shortcut>;
+    unbind(shortcut: string): Promise<boolean>;
+    get bound(): Shortcut[];
+    onShortcut(listener: (press: ShortcutPress) => void): Unsubscribe;
+    private listen;
+    private tell;
+}
+type ViewState = {
+    zoom: number | null;
+    zoomChanged: boolean;
+    interfaceShown: boolean;
+    ownAvatarShown: boolean;
+    ownNameTagShown: boolean;
+};
+declare class ViewApi {
+    private readonly bridge;
+    private readonly flash;
+    private readonly hidden;
+    private readonly listeners;
+    private natural;
+    private following;
+    private zoomHooks;
+    private last;
+    constructor(game: GameContext, flash: PhantomFlash);
+    state(): Promise<ViewState>;
+    zoom(): Promise<number | null>;
+    get zoomLimits(): {
+        min: number;
+        max: number;
+    };
+    setZoom(percent: number): Promise<number | null>;
+    resetZoom(): Promise<number | null>;
+    showInterface(show: boolean): Promise<boolean>;
+    showOwnAvatar(show: boolean): Promise<boolean>;
+    showOwnNameTag(show: boolean): Promise<boolean>;
+    onChange(listener: (state: ViewState) => void): Unsubscribe;
+    private set;
+    private hide;
+    private follow;
+    private hideAgain;
+    private stopFollowing;
+    private hookZoom;
+    private changed;
+}
+type LookItem = {
+    defId: number;
+    color: number;
+};
+type Look = {
+    avTypeId: number;
+    colors: Record<AvatarColorPart, number>;
+    eyes: number;
+    pattern: number;
+    items: LookItem[];
+};
+type LookItemPlan = {
+    item: LookItem;
+    invId: number | null;
+    status: "worn" | "put-on" | "other-colour" | "not-owned" | "not-wearable";
+};
+type LookPlan = {
+    items: LookItemPlan[];
+    eyes: "same" | "change" | "not-wearable";
+    pattern: "same" | "change" | "not-wearable";
+    wear: number[];
+    remove: number[];
+    colors: AvatarColors | null;
+};
+type LookOptions = {
+    replace?: boolean;
+    otherColours?: boolean;
+    keepColors?: boolean;
+};
+type LookResult = {
+    plan: LookPlan;
+    items: boolean | null;
+    colors: boolean | null;
+};
+type LookChange = {
+    kind: "clothing";
+    userName: string;
+    perUserAvId: number;
+    added: number[];
+    removed: number[];
+} | {
+    kind: "colors";
+    success: boolean;
+};
+declare class LooksApi {
+    private readonly areas;
+    private readonly flash;
+    private readonly server;
+    constructor(game: GameContext, areas: () => {
+        avatar: AvatarApi;
+        inventory: InventoryApi;
+    });
+    private get avatar();
+    private get inventory();
+    current(): Promise<Look>;
+    of(userName: string): Promise<Look | null>;
+    plan(look: Look, options?: LookOptions): Promise<LookPlan>;
+    putOn(look: Look, options?: LookOptions): Promise<LookResult>;
+    onChange(listener: (change: LookChange) => void): () => void;
+    private player;
+    private holding;
+}
+type ArtImage = {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+};
+type ArtPictureInput = ArtImage | Uint8Array | ArrayBuffer | string;
+type ArtFit = "contain" | "cover" | "stretch";
+type ArtPlanOptions = {
+    colors?: number;
+    palette?: readonly number[];
+    dither?: boolean;
+    fit?: ArtFit;
+    background?: number;
+};
+type ArtPaintingPlan = {
+    columns: number;
+    rows: number;
+    cellSize: number;
+    palette: number[];
+    cells: Uint16Array;
+    preview: {
+        width: number;
+        height: number;
+        data: Uint8ClampedArray;
+    };
+    runs: ArtRun[][];
+};
+type ArtRun = {
+    row: number;
+    from: number;
+    to: number;
+};
+type CanvasPoint = {
+    x: number;
+    y: number;
+};
+type CanvasShape = "line" | "rectangle" | "ellipse" | "triangle";
+declare const SWF_NAMES: {
+    readonly painting: "ArtStudioPainting";
+    readonly grid: "ArtStudioGridDrawing";
+    readonly pottery: "ArtStudioPottery";
+    readonly print: "ArtStudioPrint";
+};
+type ArtStudioKind = keyof typeof SWF_NAMES;
+type ArtCanvasKind = "painting" | "grid";
+type ArtStudioTool = "brush" | "line" | "airbrush" | "rectangle" | "fill" | "ellipse" | "smudge" | "triangle" | "pencil";
+type ArtPaintSpeed = "instant" | "fast" | "steady" | "slow";
+type ArtCanvasState = {
+    kind: ArtCanvasKind;
+    ready: boolean;
+    width: number;
+    height: number;
+    tool: ArtStudioTool | null;
+    brushSize: number;
+    brushWidth: number;
+    cellSize: number | null;
+    color: number;
+    hasDrawn: boolean;
+    needsSave: boolean;
+    undoable: boolean;
+};
+type ArtPotteryState = {
+    kind: "pottery";
+    ready: boolean;
+    design: number;
+    designs: number;
+    colouring: boolean;
+};
+type ArtPrintState = {
+    kind: "print";
+    ready: boolean;
+    picture: number;
+    pictures: number;
+    loading: boolean;
+};
+type ArtStudioState = ArtCanvasState | ArtPotteryState | ArtPrintState;
+type ArtStudioPalette = {
+    kind: ArtCanvasKind;
+    brushWidths: number[];
+    swatches: number[];
+    anyColor: boolean;
+};
+type ArtStroke = {
+    kind: ArtCanvasKind;
+    tool: ArtStudioTool | null;
+    color: number;
+    brushSize: number;
+    by: "player" | "plugin";
+};
+type ArtToolChange = {
+    kind: ArtCanvasKind | null;
+    tool: ArtStudioTool | null;
+    brushSize: number;
+};
+type ArtColorChange = {
+    kind: ArtCanvasKind | null;
+    color: number;
+};
+type ArtSubmitTarget = "animal-jam" | "masterpiece";
+type ArtSubmitStart = {
+    kind: ArtCanvasKind;
+    target: ArtSubmitTarget;
+};
+type ArtSubmitResult = {
+    kind: ArtCanvasKind;
+    target: ArtSubmitTarget;
+    ok: boolean;
+    masterpieceId: string | null;
+    refused: boolean;
+};
+type ArtMasterpieceBought = {
+    kind: ArtCanvasKind;
+    ok: boolean;
+    diamonds: number;
+    denItemInvId: number;
+};
+type ArtBrowsed = {
+    kind: "pottery" | "print";
+    index: number;
+    count: number;
+};
+type ArtPaintOptions = ArtPlanOptions & {
+    brushSize?: number;
+    speed?: ArtPaintSpeed;
+    clearFirst?: boolean;
+};
+type ArtPaintProgress = {
+    color: number;
+    colors: number;
+    strokes: number;
+    totalStrokes: number;
+};
+type ArtPaintResult = ArtPaintProgress & {
+    completed: boolean;
+    error: string | null;
+};
+type ArtPaintStart = {
+    columns: number;
+    rows: number;
+    cellSize: number;
+    colors: number;
+    totalStrokes: number;
+};
+declare class ArtStudioApi {
+    private readonly flash;
+    private readonly client;
+    private job;
+    private finished;
+    private readonly strokeListeners;
+    private readonly progressListeners;
+    private readonly doneListeners;
+    constructor(game: GameContext, flash: PhantomFlash);
+    isOpen(): Promise<boolean>;
+    current(): Promise<ArtStudioKind | null>;
+    state(): Promise<ArtStudioState | null>;
+    palette(): Promise<ArtStudioPalette | null>;
+    picture(options?: {
+        scale?: number;
+        maxSize?: number;
+    }): Promise<string | null>;
+    open(kind: ArtStudioKind, options?: {
+        gameDefId?: number;
+    }): Promise<void>;
+    close(options?: {
+        confirm?: boolean;
+    }): Promise<boolean>;
+    setTool(tool: ArtStudioTool): Promise<void>;
+    setBrushSize(size: number): Promise<void>;
+    setColor(color: number): Promise<void>;
+    stroke(points: readonly CanvasPoint[], options?: {
+        tool?: "brush" | "airbrush";
+        color?: number;
+        size?: number;
+    }): Promise<number>;
+    shape(shape: CanvasShape, from: CanvasPoint, to: CanvasPoint, options?: {
+        color?: number;
+        size?: number;
+    }): Promise<void>;
+    fill(point: CanvasPoint, options?: {
+        color?: number;
+    }): Promise<void>;
+    setCells(cells: ReadonlyArray<{
+        column: number;
+        row: number;
+        color: number;
+    }>): Promise<number>;
+    clear(options?: {
+        confirm?: boolean;
+    }): Promise<void>;
+    undo(): Promise<void>;
+    planPainting(image: ArtPictureInput, options?: ArtPaintOptions & {
+        canvas?: {
+            width: number;
+            height: number;
+            cellSize?: number;
+        };
+    }): Promise<ArtPaintingPlan>;
+    paintImage(image: ArtPictureInput, options?: ArtPaintOptions): Promise<ArtPaintResult>;
+    startPainting(image: ArtPictureInput, options?: ArtPaintOptions): Promise<ArtPaintStart>;
+    stopPainting(): Promise<ArtPaintResult | null>;
+    painting(): ArtPaintProgress | null;
+    submit(options?: {
+        confirm?: boolean;
+    }): Promise<boolean>;
+    createMasterpiece(): Promise<boolean>;
+    openStorage(): Promise<void>;
+    print(): Promise<boolean>;
+    browse(step: number): Promise<boolean>;
+    startColouring(): Promise<boolean>;
+    onOpen(listener: (kind: ArtStudioKind) => void): Unsubscribe;
+    onClose(listener: (kind: ArtStudioKind) => void): Unsubscribe;
+    onStroke(listener: (stroke: ArtStroke) => void): Unsubscribe;
+    onToolChange(listener: (change: ArtToolChange) => void): Unsubscribe;
+    onColorChange(listener: (change: ArtColorChange) => void): Unsubscribe;
+    onClear(listener: (kind: ArtCanvasKind) => void): Unsubscribe;
+    onSubmit(listener: (start: ArtSubmitStart) => void): Unsubscribe;
+    onSubmitted(listener: (result: ArtSubmitResult) => void): Unsubscribe;
+    onMasterpieceBought(listener: (bought: ArtMasterpieceBought) => void): Unsubscribe;
+    onSaved(listener: (kind: ArtCanvasKind) => void): Unsubscribe;
+    onBrowse(listener: (browsed: ArtBrowsed) => void): Unsubscribe;
+    onPaintProgress(listener: (progress: ArtPaintProgress) => void): Unsubscribe;
+    onPaintDone(listener: (result: ArtPaintResult) => void): Unsubscribe;
+    private openStudio;
+    private canvas;
+    private read;
+    private gameDefIdOf;
+    private brushSizeOf;
+    private cellSizeFor;
+    private paint;
+    private tellStroke;
+    private tell;
+    private hear;
+    private follow;
+    private manager;
+}
 type Phantom = {
     readonly avatar: AvatarApi;
     readonly player: PlayerApi;
@@ -5838,6 +8232,7 @@ type Phantom = {
     readonly adventures: AdventuresApi;
     readonly minigames: MinigamesApi;
     readonly achievements: AchievementsApi;
+    readonly membership: MembershipApi;
     readonly currency: CurrencyApi;
     readonly dailyGift: DailyGiftApi;
     readonly sound: SoundApi;
@@ -5853,6 +8248,14 @@ type Phantom = {
     readonly localization: LocalizationApi;
     readonly ui: UiApi;
     readonly community: CommunityApi;
+    readonly customRooms: CustomRoomsApi;
+    readonly realtime: RealtimeApi;
+    readonly journeyBook: JourneyBookApi;
+    readonly referrals: ReferralsApi;
+    readonly input: InputApi;
+    readonly view: ViewApi;
+    readonly looks: LooksApi;
+    readonly artStudio: ArtStudioApi;
     readonly server: Side;
     readonly client: Side;
     readonly flash: PhantomFlash;
@@ -6031,7 +8434,8 @@ declare const NOT_FOR_PLUGINS: readonly [
     "avatar.view",
     "adventures.record",
     "content.replaceOnScreen",
-    "content.load"
+    "content.load",
+    "realtime.join"
 ];
 type SdkPath = Exclude<SdkPathOfSdk, (typeof NOT_FOR_PLUGINS)[number]>;
 type RemoteMember<Member> = Member extends (...args: infer Args) => infer Result ? Result extends Unsubscribe ? (...args: Args) => Unsubscribe : (...args: Args) => Promise<Awaited<Result>> : () => Promise<Member>;
@@ -6091,7 +8495,7 @@ type PluginContext = {
     openUrl(url: string): Promise<void>;
     log(...values: unknown[]): void;
 };
-type PluginPhantom = Omit<RemoteSdk, "avatar" | "adventures" | "content" | "ui"> & {
+type PluginPhantom = Omit<RemoteSdk, "avatar" | "adventures" | "content" | "ui" | "realtime"> & {
     readonly avatar: RemoteSdk["avatar"] & {
         view(): Promise<FlashHandle>;
     };
@@ -6099,6 +8503,9 @@ type PluginPhantom = Omit<RemoteSdk, "avatar" | "adventures" | "content" | "ui">
         record(): AdventureRecorder;
     };
     readonly content: RemoteSdk["content"] & Pick<ContentApi, "load" | "replaceOnScreen">;
+    readonly realtime: RemoteSdk["realtime"] & {
+        join<Data = unknown, State extends RealtimeObject = RealtimeObject, Presence extends RealtimeObject = RealtimeObject>(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions<Presence>): Promise<RealtimeChannel<Data, State, Presence>>;
+    };
     readonly ui: UiApi;
     readonly recipes: PluginRecipes;
     readonly id: string;
@@ -6135,37 +8542,37 @@ declare function usePhantom(id?: string): PluginPhantom;
 declare function useGames(): ComputedRef<readonly PluginGameView[]>;
 declare function usePreferences(): ComputedRef<Readonly<Record<string, PreferenceValue>>>;
 declare function useThemeMode(): ComputedRef<"light" | "dark">;
-type __VLS_Props$a = {
+type __VLS_Props$b = {
     name: string;
     imageUrl?: string | null | undefined;
     size?: "sm" | "md" | "lg" | "xl";
 };
-declare const __VLS_export$c: vue.DefineComponent<__VLS_Props$a, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$a> & Readonly<{}>, {
+declare const __VLS_export$e: vue.DefineComponent<__VLS_Props$b, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$b> & Readonly<{}>, {
     size: "sm" | "md" | "lg" | "xl";
     imageUrl: string | null | undefined;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$c: typeof __VLS_export$c;
+declare const _default$e: typeof __VLS_export$e;
 type BadgeTone = "neutral" | "success" | "warning" | "danger" | "info";
 type BadgeHue = "blue" | "violet" | "aqua" | "orange" | "magenta";
-type __VLS_Props$9 = {
+type __VLS_Props$a = {
     tone?: BadgeTone | BadgeHue;
     dot?: boolean;
     size?: "sm" | "md";
     quiet?: boolean;
 };
 declare var __VLS_1$1: {};
-type __VLS_Slots$5 = {} & {
+type __VLS_Slots$6 = {} & {
     default?: (props: typeof __VLS_1$1) => any;
 };
-declare const __VLS_base$5: vue.DefineComponent<__VLS_Props$9, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$9> & Readonly<{}>, {
+declare const __VLS_base$6: vue.DefineComponent<__VLS_Props$a, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$a> & Readonly<{}>, {
     size: "sm" | "md";
     tone: BadgeTone | BadgeHue;
     dot: boolean;
     quiet: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$b: __VLS_WithSlots$6<typeof __VLS_base$5, __VLS_Slots$5>;
-declare const _default$b: typeof __VLS_export$b;
-type __VLS_WithSlots$6<T, S> = T & {
+declare const __VLS_export$d: __VLS_WithSlots$7<typeof __VLS_base$6, __VLS_Slots$6>;
+declare const _default$d: typeof __VLS_export$d;
+type __VLS_WithSlots$7<T, S> = T & {
     new (): {
         $slots: S;
     };
@@ -6184,10 +8591,10 @@ type ButtonProps = {
     href?: string | undefined;
 };
 declare var __VLS_15: {};
-type __VLS_Slots$4 = {} & {
+type __VLS_Slots$5 = {} & {
     default?: (props: typeof __VLS_15) => any;
 };
-declare const __VLS_base$4: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {} & {
+declare const __VLS_base$5: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {} & {
     click: (e: MouseEvent) => any;
 }, string, vue.PublicProps, Readonly<ButtonProps> & Readonly<{
     onClick?: (e: MouseEvent) => any;
@@ -6199,33 +8606,33 @@ declare const __VLS_base$4: vue.DefineComponent<ButtonProps, {}, {}, {}, {}, vue
     type: "button" | "submit" | "reset";
     fullWidth: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$a: __VLS_WithSlots$5<typeof __VLS_base$4, __VLS_Slots$4>;
-declare const _default$a: typeof __VLS_export$a;
-type __VLS_WithSlots$5<T, S> = T & {
+declare const __VLS_export$c: __VLS_WithSlots$6<typeof __VLS_base$5, __VLS_Slots$5>;
+declare const _default$c: typeof __VLS_export$c;
+type __VLS_WithSlots$6<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_Props$8 = {
+type __VLS_Props$9 = {
     tone?: BadgeTone;
     icon?: Component | undefined;
 };
 declare var __VLS_6$1: {};
-type __VLS_Slots$3 = {} & {
+type __VLS_Slots$4 = {} & {
     default?: (props: typeof __VLS_6$1) => any;
 };
-declare const __VLS_base$3: vue.DefineComponent<__VLS_Props$8, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$8> & Readonly<{}>, {
+declare const __VLS_base$4: vue.DefineComponent<__VLS_Props$9, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$9> & Readonly<{}>, {
     icon: Component | undefined;
     tone: BadgeTone;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$9: __VLS_WithSlots$4<typeof __VLS_base$3, __VLS_Slots$3>;
-declare const _default$9: typeof __VLS_export$9;
-type __VLS_WithSlots$4<T, S> = T & {
+declare const __VLS_export$b: __VLS_WithSlots$5<typeof __VLS_base$4, __VLS_Slots$4>;
+declare const _default$b: typeof __VLS_export$b;
+type __VLS_WithSlots$5<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_Props$7 = {
+type __VLS_Props$8 = {
     title: string;
     description?: string | undefined;
     icon?: Component | undefined;
@@ -6233,24 +8640,24 @@ type __VLS_Props$7 = {
     plain?: boolean;
 };
 declare var __VLS_6: {};
-type __VLS_Slots$2 = {} & {
+type __VLS_Slots$3 = {} & {
     default?: (props: typeof __VLS_6) => any;
 };
-declare const __VLS_base$2: vue.DefineComponent<__VLS_Props$7, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$7> & Readonly<{}>, {
+declare const __VLS_base$3: vue.DefineComponent<__VLS_Props$8, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$8> & Readonly<{}>, {
     size: "sm" | "lg";
     icon: Component | undefined;
     description: string | undefined;
     plain: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$8: __VLS_WithSlots$3<typeof __VLS_base$2, __VLS_Slots$2>;
-declare const _default$8: typeof __VLS_export$8;
-type __VLS_WithSlots$3<T, S> = T & {
+declare const __VLS_export$a: __VLS_WithSlots$4<typeof __VLS_base$3, __VLS_Slots$3>;
+declare const _default$a: typeof __VLS_export$a;
+type __VLS_WithSlots$4<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-declare const _default$7: typeof __VLS_export$7;
-declare const __VLS_export$7: __VLS_WithSlots$2<vue.DefineComponent<{
+declare const _default$9: typeof __VLS_export$9;
+declare const __VLS_export$9: __VLS_WithSlots$3<vue.DefineComponent<{
     for: string;
     label?: string | undefined;
     info?: string | undefined;
@@ -6278,19 +8685,19 @@ declare const __VLS_export$7: __VLS_WithSlots$2<vue.DefineComponent<{
 } & {
     default?: (props: {}) => any;
 }>;
-type __VLS_WithSlots$2<T, S> = T & {
+type __VLS_WithSlots$3<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_Props$6 = {
+type __VLS_Props$7 = {
     text: string;
     label?: string | undefined;
 };
-declare const __VLS_export$6: vue.DefineComponent<__VLS_Props$6, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$6> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$6: typeof __VLS_export$6;
+declare const __VLS_export$8: vue.DefineComponent<__VLS_Props$7, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$7> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$8: typeof __VLS_export$8;
 type InputValue = string | number;
-type __VLS_Props$5 = {
+type __VLS_Props$6 = {
     modelValue?: InputValue;
     id?: string | undefined;
     label?: string | undefined;
@@ -6308,14 +8715,14 @@ type __VLS_Props$5 = {
 };
 declare var __VLS_9: {};
 declare var __VLS_16: {};
-type __VLS_Slots$1 = {} & {
+type __VLS_Slots$2 = {} & {
     label?: (props: typeof __VLS_9) => any;
 } & {
     trailing?: (props: typeof __VLS_16) => any;
 };
-declare const __VLS_base$1: vue.DefineComponent<__VLS_Props$5, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+declare const __VLS_base$2: vue.DefineComponent<__VLS_Props$6, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     "update:modelValue": (value: InputValue) => any;
-}, string, vue.PublicProps, Readonly<__VLS_Props$5> & Readonly<{
+}, string, vue.PublicProps, Readonly<__VLS_Props$6> & Readonly<{
     "onUpdate:modelValue"?: (value: InputValue) => any;
 }>, {
     size: "xs" | "sm" | "md" | "lg";
@@ -6329,33 +8736,33 @@ declare const __VLS_base$1: vue.DefineComponent<__VLS_Props$5, {}, {}, {}, {}, v
     error: string | null | undefined;
     optional: boolean;
     hint: string | undefined;
-    modelValue: InputValue;
     placeholder: string | undefined;
+    modelValue: InputValue;
     suggestions: readonly string[] | undefined;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$5: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
-declare const _default$5: typeof __VLS_export$5;
-type __VLS_WithSlots$1<T, S> = T & {
+declare const __VLS_export$7: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
+declare const _default$7: typeof __VLS_export$7;
+type __VLS_WithSlots$2<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_Props$4 = {
+type __VLS_Props$5 = {
     title: string;
     eyebrow?: string | undefined;
     description?: string | undefined;
 };
 declare var __VLS_1: {};
-type __VLS_Slots = {} & {
+type __VLS_Slots$1 = {} & {
     actions?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: vue.DefineComponent<__VLS_Props$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$4> & Readonly<{}>, {
+declare const __VLS_base$1: vue.DefineComponent<__VLS_Props$5, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$5> & Readonly<{}>, {
     description: string | undefined;
     eyebrow: string | undefined;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$4: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default$4: typeof __VLS_export$4;
-type __VLS_WithSlots<T, S> = T & {
+declare const __VLS_export$6: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$6: typeof __VLS_export$6;
+type __VLS_WithSlots$1<T, S> = T & {
     new (): {
         $slots: S;
     };
@@ -6366,7 +8773,7 @@ type SegmentedOption = {
     badge?: string | number | undefined;
     icon?: Component | undefined;
 };
-type __VLS_Props$3 = {
+type __VLS_Props$4 = {
     modelValue: string;
     options: SegmentedOption[];
     variant?: "pill" | "underline";
@@ -6374,9 +8781,9 @@ type __VLS_Props$3 = {
     track?: boolean;
     block?: boolean;
 };
-declare const __VLS_export$3: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+declare const __VLS_export$5: vue.DefineComponent<__VLS_Props$4, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
-}, string, vue.PublicProps, Readonly<__VLS_Props$3> & Readonly<{
+}, string, vue.PublicProps, Readonly<__VLS_Props$4> & Readonly<{
     "onUpdate:modelValue"?: (value: string) => any;
 }>, {
     variant: "pill" | "underline";
@@ -6384,14 +8791,89 @@ declare const __VLS_export$3: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {},
     track: boolean;
     block: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
-declare const _default$3: typeof __VLS_export$3;
-type __VLS_Props$2 = {
+declare const _default$5: typeof __VLS_export$5;
+type SelectValue = string | number | null;
+type SelectOption<T extends SelectValue = SelectValue> = {
+    value: T;
+    label: string;
+    description?: string | undefined;
+    detail?: string | undefined;
+    icon?: Component | undefined;
+    disabled?: boolean | undefined;
+};
+declare const __VLS_export$4: <T extends SelectValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: vue.PublicProps & __VLS_PrettifyLocal<{
+        modelValue: T;
+        options?: ReadonlyArray<SelectOption<T>> | undefined;
+        ariaLabel?: string | undefined;
+        label?: string | undefined;
+        info?: string | undefined;
+        hint?: string | undefined;
+        error?: string | null | undefined;
+        optional?: boolean;
+        icon?: Component | undefined;
+        disabled?: boolean;
+        placeholder?: string;
+        size?: "sm" | "md" | "lg";
+        variant?: "default" | "ghost";
+        id?: string | undefined;
+    } & {
+        "onUpdate:modelValue"?: (value: T) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: T) => void;
+}>) => vue.VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$4: typeof __VLS_export$4;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};
+type __VLS_Props$3 = {
     size?: number;
 };
-declare const __VLS_export$2: vue.DefineComponent<__VLS_Props$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$2> & Readonly<{}>, {
+declare const __VLS_export$3: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props$3> & Readonly<{}>, {
     size: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_Props$2 = {
+    modelValue: boolean;
+    label?: string | undefined;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    block?: boolean;
+    align?: "center" | "start";
+    id?: string | undefined;
+};
+declare var __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: vue.DefineComponent<__VLS_Props$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, vue.PublicProps, Readonly<__VLS_Props$2> & Readonly<{
+    "onUpdate:modelValue"?: (value: boolean) => any;
+}>, {
+    disabled: boolean;
+    label: string | undefined;
+    id: string | undefined;
+    block: boolean;
+    indeterminate: boolean;
+    align: "center" | "start";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$2: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default$2: typeof __VLS_export$2;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
 type __VLS_Props$1 = {
     modelValue: boolean;
     label?: string | undefined;
@@ -6414,12 +8896,17 @@ type __VLS_Props = {
     title: string;
     description?: string | undefined;
     note?: string | undefined;
+    place?: "beside" | "below";
 };
-declare const __VLS_export: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    description: string | undefined;
+    note: string | undefined;
+    place: "beside" | "below";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 declare function tooltipBeside(element: Element, gap?: number): {
     top: number;
     left: number;
 };
-export { _default$c as Avatar, _default$b as Badge, _default$a as Button, _default$9 as Callout, _default$8 as EmptyState, _default$7 as FieldFrame, _default$6 as InfoTip, _default$5 as Input, _default$4 as PageHeader, _default$3 as SegmentedControl, _default$2 as Spinner, _default$1 as Switch, _default as Tooltip, tooltipBeside, useGames, usePhantom, usePlugin, usePreferences, useThemeMode };
-export type { BadgeHue, BadgeTone, SegmentedOption };
+export { _default$e as Avatar, _default$d as Badge, _default$c as Button, _default$b as Callout, _default$2 as Checkbox, _default$a as EmptyState, _default$9 as FieldFrame, _default$8 as InfoTip, _default$7 as Input, _default$6 as PageHeader, _default$5 as SegmentedControl, _default$4 as Select, _default$3 as Spinner, _default$1 as Switch, _default as Tooltip, tooltipBeside, useGames, usePhantom, usePlugin, usePreferences, useThemeMode };
+export type { BadgeHue, BadgeTone, SegmentedOption, SelectOption, SelectValue };