@phantomclient/plugin 0.1.1 → 0.1.2

package/dist/types/vue.d.ts

@@ -2477,15 +2477,37 @@ declare class Side {
     private read;
     private checked;
 }
+type LicensePlan = "monthly" | "lifetime";
+type PhantomPerks = {
+    mark: boolean;
+    planMark: boolean;
+    title: string[];
+    accent: string;
+    phantomLook: boolean;
+    tint: number;
+    pet: PerkPet | null;
+};
+type PerkPet = {
+    name: string[];
+    animal: number | null;
+    tint: number;
+};
 type HiddenPlayer = {
     screenName: string;
 };
+type NearbyPhantomUser = {
+    screenName: string;
+    perks: PhantomPerks;
+    plan: LicensePlan | null;
+};
 type CommunityChannel = {
     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>;
+    nearby(): readonly NearbyPhantomUser[];
+    onNearby(listener: (nearby: readonly NearbyPhantomUser[]) => void): Unsubscribe;
 };
 declare class CommunityApi {
     private readonly channel;
@@ -2493,9 +2515,12 @@ declare class CommunityApi {
     get available(): boolean;
     hidden(): Promise<readonly HiddenPlayer[]>;
     onHidden(listener: (hidden: readonly HiddenPlayer[]) => void): Unsubscribe;
+    watchHidden(listener: (hidden: readonly HiddenPlayer[]) => void): Unsubscribe;
     hide(screenName: string): Promise<void>;
     unhide(screenName: string): Promise<void>;
     report(screenName: string, reason?: string): Promise<void>;
+    nearby(): readonly NearbyPhantomUser[];
+    onNearby(listener: (nearby: readonly NearbyPhantomUser[]) => void): Unsubscribe;
     private reach;
 }
 type ContentMatch = {
@@ -2599,6 +2624,24 @@ declare class ContentApi {
     private whenLoaded;
     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 CustomRoomPicture = string | Uint8Array;
 type CustomRoomMotion = {
     pulse?: {
@@ -2643,7 +2686,10 @@ type CustomRoomProp = {
     y: number;
     width?: number;
     height?: number;
-    layer?: "floor" | "standing" | "front";
+    layer?: "floor" | "standing" | "front" | "top";
+    sortHeight?: number;
+    scaleX?: number;
+    scaleY?: number;
     motion?: CustomRoomMotion;
     frames?: CustomRoomFrames;
     solid?: boolean;
@@ -2651,6 +2697,8 @@ type CustomRoomProp = {
     clickable?: boolean;
     nearDistance?: number;
     bounce?: boolean;
+    changeable?: boolean;
+    shared?: boolean;
 };
 type CustomRoomExit = {
     id: string;
@@ -2658,6 +2706,73 @@ type CustomRoomExit = {
     y: number;
     radius: number;
 };
+type CustomRoomDestination = {
+    room: string;
+} | {
+    jamaa: string;
+};
+type CustomRoomDoorway = {
+    id: string;
+    x: number;
+    y: number;
+    radius: number;
+    to: CustomRoomDestination;
+    spawn?: string;
+};
+type CustomRoomSpawn = {
+    name: string;
+    x: number;
+    y: number;
+    radius?: number;
+    walkTo?: string;
+};
+type CustomRoomVolume = {
+    name: string;
+    area: CustomRoomArea;
+    kind?: number;
+    message?: string;
+    walkTo?: boolean;
+};
+type CustomRoomScroll = {
+    xmin: number;
+    xmax: number;
+    ymin: number;
+    ymax: number;
+};
+type CustomRoomCharacterLook = {
+    animal?: number;
+    customAnimal?: number;
+    colors?: [
+        number,
+        number,
+        number
+    ];
+    eyes?: number;
+    pattern?: number;
+    wearing?: Array<{
+        defId: number;
+        color?: number;
+    }>;
+    member?: boolean;
+    phantom?: boolean;
+    tint?: number;
+};
+type CustomRoomCharacter = {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    flipped?: boolean;
+    look?: CustomRoomCharacterLook;
+    greeting?: string;
+    says?: string[];
+    path?: Array<{
+        x: number;
+        y: number;
+    }>;
+    pace?: number;
+    clickable?: boolean;
+};
 type CustomRoomSpec = {
     name: string;
     width: number;
@@ -2665,16 +2780,136 @@ type CustomRoomSpec = {
     background: CustomRoomPicture;
     walkable?: CustomRoomArea[];
     blocked?: CustomRoomArea[];
+    landWalls?: CustomRoomArea[];
+    airWalls?: CustomRoomArea[];
     spawn: {
         x: number;
         y: number;
     };
     props?: CustomRoomProp[];
     exits?: CustomRoomExit[];
+    characters?: CustomRoomCharacter[];
     music?: {
         track: string;
         volume?: number;
     };
+    spawns?: CustomRoomSpawn[];
+    doorways?: CustomRoomDoorway[];
+    volumes?: CustomRoomVolume[];
+    scroll?: CustomRoomScroll;
+};
+type CustomRoomPropState = {
+    id: string;
+    room: string;
+    x: number;
+    y: number;
+    shown: boolean;
+    changed: boolean;
+};
+type CustomRoomPropChange = {
+    x?: number;
+    y?: number;
+    shown?: boolean;
+    art?: CustomRoomPicture | null;
+    reset?: boolean;
+};
+type CustomRoomPropHandle = {
+    readonly id: string;
+    move(x: number, y: number): Promise<CustomRoomPropState | null>;
+    hide(): Promise<CustomRoomPropState | null>;
+    show(): Promise<CustomRoomPropState | null>;
+    art(picture: CustomRoomPicture | null): Promise<CustomRoomPropState | null>;
+    change(change: CustomRoomPropChange): Promise<CustomRoomPropState | null>;
+    reset(): Promise<CustomRoomPropState | null>;
+    now(): Promise<CustomRoomPropState | null>;
+};
+type CustomRoomPropCalls = {
+    changeProp(propId: string, change: CustomRoomPropChange, roomId?: string): Promise<CustomRoomPropState | null>;
+    propState(propId: string, roomId?: string): Promise<CustomRoomPropState | null>;
+};
+type CustomRoomCharacterState = {
+    id: string;
+    room: string;
+    name: string;
+    x: number;
+    y: number;
+    shown: boolean;
+    said: number;
+};
+type CustomRoomCharacterChange = {
+    say?: string;
+    x?: number;
+    y?: number;
+    walk?: boolean;
+    shown?: boolean;
+};
+type CustomRoomCharacterHandle = {
+    readonly id: string;
+    say(text: string): Promise<CustomRoomCharacterState | null>;
+    walk(x: number, y: number): Promise<CustomRoomCharacterState | null>;
+    put(x: number, y: number): Promise<CustomRoomCharacterState | null>;
+    hide(): Promise<CustomRoomCharacterState | null>;
+    show(): Promise<CustomRoomCharacterState | null>;
+    change(change: CustomRoomCharacterChange): Promise<CustomRoomCharacterState | null>;
+    now(): Promise<CustomRoomCharacterState | null>;
+};
+type CustomRoomCharacterCalls = {
+    changeCharacter(characterId: string, change: CustomRoomCharacterChange, roomId?: string): Promise<CustomRoomCharacterState | null>;
+    characterState(characterId: string, roomId?: string): Promise<CustomRoomCharacterState | null>;
+};
+type CustomRoomLimits = {
+    objects: number;
+    objectTag: number;
+};
+type CustomRoomObjectState = {
+    id: string;
+    room: string;
+    holder: string | null;
+    mine: boolean;
+    x: number;
+    y: number;
+    shown: boolean;
+    tag: string | null;
+    changed: boolean;
+};
+type CustomRoomObjectChange = {
+    take?: boolean;
+    drop?: boolean;
+    reset?: boolean;
+    x?: number;
+    y?: number;
+    shown?: boolean;
+    tag?: string | null;
+};
+type CustomRoomObjectEvent = {
+    room: CustomRoomInfo;
+    objects: CustomRoomObjectState[];
+    by: string | null;
+    yours: boolean;
+    took: boolean;
+    dropped: boolean;
+};
+type CustomRoomObjectHandle = {
+    readonly id: string;
+    take(change?: CustomRoomObjectChange): Promise<CustomRoomObjectState>;
+    drop(change?: CustomRoomObjectChange): Promise<CustomRoomObjectState>;
+    move(x: number, y: number): Promise<CustomRoomObjectState>;
+    hide(): Promise<CustomRoomObjectState>;
+    show(): Promise<CustomRoomObjectState>;
+    mark(word: string | null): Promise<CustomRoomObjectState>;
+    reset(): Promise<CustomRoomObjectState>;
+    change(change: CustomRoomObjectChange): Promise<CustomRoomObjectState>;
+    now(): Promise<CustomRoomObjectState | null>;
+    onTaken(listener: (event: CustomRoomObjectTurn) => void): Unsubscribe;
+    onDropped(listener: (event: CustomRoomObjectTurn) => void): Unsubscribe;
+    onChanged(listener: (event: CustomRoomObjectTurn) => void): Unsubscribe;
+};
+type CustomRoomObjectTurn = {
+    object: CustomRoomObjectState;
+    by: string | null;
+    yours: boolean;
+    took: boolean;
+    dropped: boolean;
 };
 type CustomRoomEnterOptions = {
     shared?: boolean;
@@ -2706,13 +2941,24 @@ type CustomRoomEvent = {
     kind: "propEnter" | "propLeave" | "propNear" | "propClick";
     room: CustomRoomInfo;
     prop: string;
-};
+} | {
+    kind: "characterClick";
+    room: CustomRoomInfo;
+    character: string;
+    said: string | null;
+} | ({
+    kind: "objects";
+} & CustomRoomObjectEvent);
 type SharedRoomListing = {
     name: string;
     title: string;
     people: number;
 };
-type CustomRoomsChannel = {
+type CustomRoomsChannel = CustomRoomPropCalls & CustomRoomCharacterCalls & {
+    characters(roomId?: string): Promise<CustomRoomCharacterState[]>;
+    changeObject(objectId: string, change: CustomRoomObjectChange, roomId?: string): Promise<CustomRoomObjectState>;
+    objectState(objectId: string, roomId?: string): Promise<CustomRoomObjectState | null>;
+    objects(roomId?: string): Promise<CustomRoomObjectState[]>;
     define(spec: CustomRoomSpec): Promise<string>;
     shared(): Promise<SharedRoomListing[]>;
     remove(roomId: string): Promise<boolean>;
@@ -2729,7 +2975,27 @@ declare class CustomRoomsApi {
     remove(roomId: string): Promise<boolean>;
     enter(roomId: string, options?: CustomRoomEnterOptions): Promise<void>;
     shared(): Promise<SharedRoomListing[]>;
+    prop(id: string, roomId?: string): CustomRoomPropHandle;
+    changeProp(propId: string, change: CustomRoomPropChange, roomId?: string): Promise<CustomRoomPropState | null>;
+    propState(propId: string, roomId?: string): Promise<CustomRoomPropState | null>;
+    character(id: string, roomId?: string): CustomRoomCharacterHandle;
+    changeCharacter(characterId: string, change: CustomRoomCharacterChange, roomId?: string): Promise<CustomRoomCharacterState | null>;
+    characterState(characterId: string, roomId?: string): Promise<CustomRoomCharacterState | null>;
+    characters(roomId?: string): Promise<CustomRoomCharacterState[]>;
+    onCharacterClick(listener: (event: {
+        room: CustomRoomInfo;
+        character: string;
+        said: string | null;
+    }) => void): Unsubscribe;
+    get limits(): CustomRoomLimits;
+    object(id: string, roomId?: string): CustomRoomObjectHandle;
+    changeObject(objectId: string, change: CustomRoomObjectChange, roomId?: string): Promise<CustomRoomObjectState>;
+    objectState(objectId: string, roomId?: string): Promise<CustomRoomObjectState | null>;
+    objects(roomId?: string): Promise<CustomRoomObjectState[]>;
+    onObject(listener: (event: CustomRoomObjectEvent) => void): Unsubscribe;
     leave(): Promise<boolean>;
+    private readonly opened;
+    open(spec: CustomRoomSpec, options?: CustomRoomEnterOptions): Promise<string>;
     get current(): CustomRoomInfo | null;
     onEnter(listener: (room: CustomRoomInfo) => void): Unsubscribe;
     onLeave(listener: (event: {
@@ -2766,24 +3032,16 @@ declare class CustomRoomsApi {
     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 RealtimeLimits = {
+    messageBytes: number;
+    stateBytes: number;
+    presenceBytes: number;
+    messagesPerSecond: number;
+    updatesPerSecond: number;
+    members: number;
+    channels: number;
+    nameLength: number;
 };
-type RealtimeCloseReason = "left" | "banned" | "killed" | "rate-limited" | "offline";
-type RealtimeAskFailure = "no-handler" | "failed";
 type RealtimeState = "off" | "connecting" | "online" | "offline" | "refused";
 type RealtimeStatus = {
     state: RealtimeState;
@@ -2830,6 +3088,12 @@ type RealtimeHostEvent<Presence extends RealtimeObject = RealtimeObject> = {
     you: boolean;
     hosted: boolean;
 };
+type RealtimeHosting<Presence extends RealtimeObject = RealtimeObject> = {
+    host: RealtimeMember<Presence> | null;
+    you: boolean;
+    hosted: boolean;
+    hidden: boolean;
+};
 type RealtimeAsk<Question = unknown> = {
     channel: string;
     id: string;
@@ -2926,8 +3190,19 @@ declare class RealtimeChannel<Data = unknown, State extends RealtimeObject = Rea
     private hostAt;
     private hostIsHidden;
     private closedWith;
+    private queued;
+    private waiting;
+    private publishing;
+    private publishTimer;
+    private publishedAt;
     private answers;
     private readonly heard;
+    private queuedPresence;
+    private presenceWaiting;
+    private publishingPresence;
+    private presenceTimer;
+    private presencePublishedAt;
+    private watchingClose;
     private stop;
     constructor(info: RealtimeChannelInfo, calls: RealtimeCalls);
     get you(): RealtimeMember<Presence>;
@@ -2936,11 +3211,17 @@ declare class RealtimeChannel<Data = unknown, State extends RealtimeObject = Rea
     host(): RealtimeMember<Presence> | null;
     get isHost(): boolean;
     get hosted(): boolean;
+    get hostHidden(): boolean;
+    hosting(): RealtimeHosting<Presence>;
     giveHost(memberId: string): Promise<void>;
     state(): State | null;
     setState(state: State | null): Promise<void>;
+    publish(state: State | null): Promise<void>;
+    private pump;
     presence(): Presence | null;
     setPresence(presence: Presence | null): Promise<void>;
+    publishPresence(presence: Presence | null): Promise<void>;
+    private pumpPresence;
     send(data: Data): Promise<void>;
     sendTo(memberId: string, data: Data): Promise<void>;
     ask<Answer = unknown>(memberId: string, question: unknown, options?: RealtimeAskOptions): Promise<Answer>;
@@ -2951,6 +3232,7 @@ declare class RealtimeChannel<Data = unknown, State extends RealtimeObject = Rea
     onLeave(listener: (member: RealtimeMember<Presence>) => void): Unsubscribe;
     onState(listener: (event: RealtimeStateEvent<State>) => void): Unsubscribe;
     onPresence(listener: (member: RealtimeMember<Presence>) => void): Unsubscribe;
+    onMembers(listener: (members: readonly RealtimeMember<Presence>[]) => void): Unsubscribe;
     onHost(listener: (event: RealtimeHostEvent<Presence>) => void): Unsubscribe;
     onClose(listener: (close: RealtimeClose) => void): Unsubscribe;
     hear(event: Heard): void;
@@ -2961,13 +3243,18 @@ declare class RealtimeChannel<Data = unknown, State extends RealtimeObject = Rea
     private tell;
     private refuse;
 }
+type RealtimeStayOptions<Presence extends RealtimeObject = RealtimeObject> = RealtimeJoinOptions<Presence> & {
+    onProblem?: (error: unknown) => void;
+};
 declare class RealtimeApi {
     private readonly link;
     constructor(game: GameContext);
     get available(): boolean;
+    get limits(): RealtimeLimits;
     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>>;
+    stayIn<Data = unknown, State extends RealtimeObject = RealtimeObject, Presence extends RealtimeObject = RealtimeObject>(spec: RealtimeChannelSpec, ready: (channel: RealtimeChannel<Data, State, Presence>) => void, options?: RealtimeStayOptions<Presence>): Promise<Unsubscribe>;
     open(spec: RealtimeChannelSpec, options?: RealtimeJoinOptions): Promise<RealtimeChannelInfo>;
     leave(channelId: string): Promise<boolean>;
     send(channelId: string, data: unknown): Promise<void>;
@@ -3038,6 +3325,45 @@ type CachedStat = {
     value: number;
     type: number;
 };
+type AchievementBookEntry = {
+    defId: number;
+    name: string;
+    description: string;
+    type: number;
+    typeName: string;
+    userVarId: number;
+    target: number;
+    value: number;
+    earned: boolean;
+    fraction: number;
+    iconMediaId: number;
+    baseMediaId: number;
+};
+type AchievementBookGroup = {
+    type: number;
+    name: string;
+    total: number;
+    earned: number;
+    left: number;
+    entries: AchievementBookEntry[];
+};
+type AchievementBook = {
+    total: number;
+    earned: number;
+    left: number;
+    fraction: number;
+    entries: AchievementBookEntry[];
+    groups: AchievementBookGroup[];
+};
+type AchievementProgress = {
+    defId: number;
+    name: string;
+    userVarId: number;
+    target: number;
+    value: number;
+    earned: boolean;
+    fraction: number;
+};
 type EarnAnswer = {
     defId: number;
     userVarId: number;
@@ -3085,6 +3411,8 @@ declare class AchievementsApi {
     readStats(): Promise<CachedStat[]>;
     statBit(userVarId: number, bit: number): Promise<boolean>;
     statType(userVarId: number): Promise<number>;
+    progress(): Promise<AchievementProgress[]>;
+    book(): Promise<AchievementBook>;
     private translate;
     private typeName;
     private achievementsOf;
@@ -3107,6 +3435,17 @@ type AvatarColorGridOptions = {
     width?: number;
     height?: number;
 };
+type NameBar = {
+    data: number;
+    color: number;
+    badge: number;
+    showLevel: boolean;
+};
+type NameBarLook = {
+    color?: number;
+    badge?: number;
+    showLevel?: boolean;
+};
 type Point = {
     x: number;
     y: number;
@@ -3157,6 +3496,11 @@ type AvatarSummary = {
     userId: number;
     enviroTypeFlag: number;
 };
+type RoomPlayerProfile = AvatarSummary & {
+    self: boolean;
+    standing: AvatarStanding | null;
+    nameBar: NameBar | null;
+};
 type NewAvatar = {
     avTypeId: number;
     nameIds: AvatarNameIds;
@@ -3208,6 +3552,12 @@ declare class AvatarApi {
     teleport(x: number, y: number): Promise<void>;
     userId(): Promise<number>;
     view(): Promise<FlashHandle>;
+    viewOf(userId: number): Promise<FlashHandle | null>;
+    tintOf(userId: number, color: number | null, options?: {
+        amount?: number;
+        keep?: boolean;
+    }): Promise<boolean>;
+    asPhantom(userId: number, on?: boolean): Promise<boolean>;
     standing(): Promise<AvatarStanding | null>;
     private standingOfView;
     placeAt(position: Point, options?: {
@@ -3275,6 +3625,7 @@ declare class AvatarApi {
     private summarise;
     private summaryOf;
     inRoom(userId: number): Promise<AvatarSummary | null>;
+    whoIs(userId: number): Promise<RoomPlayerProfile | null>;
     findInRoom(query: {
         userName: string;
         perUserAvId?: number;
@@ -3291,6 +3642,8 @@ declare class AvatarApi {
     isHostingAdventure(): Promise<boolean>;
     suitsEnvironment(enviroType: number): Promise<boolean>;
     roomState(): Promise<AvatarRoomState>;
+    nameBar(): Promise<NameBar>;
+    setNameBar(look?: NameBarLook): Promise<boolean>;
     lastNameBar(userId: number): number | null;
     onList(listener: (list: PacketOf<typeof AvatarList>) => void): () => void;
     onRemoved(listener: (result: PacketOf<typeof AvatarKilled>) => void): () => void;
@@ -3332,6 +3685,7 @@ type AdventureActorChange = {
     kind: AdventureActorChangeKind;
     actor: AdventureActor;
 };
+type AdventureActorKind = "attacker" | "bouncer" | "camera" | "circleClocker" | "circleTrigger" | "destructible" | "droppedTreasure" | "factory" | "groupItem" | "gui" | "item" | "lightBeam" | "npc" | "placedTreasure" | "plant" | "platform" | "spawn" | "speaker" | "tile" | "timer" | "variable" | "volumeBlocker" | "volumeFallingPhantom" | "volumeHealth" | "volumeInteraction" | "volumePlacement" | "volumeTrigger";
 type RewardPreference = "item" | "gems" | "none" | readonly AdventurePrizeKind[];
 type AdventureDefinition = {
     defId: number;
@@ -3466,6 +3820,26 @@ type AdventureEnd = {
     scriptDefId: number;
     reason: AdventureEndReason;
 };
+type AdventurePhase = "idle" | "lobby" | "playing" | "rewards" | "ended";
+type AdventurePhaseChange = {
+    phase: AdventurePhase;
+    was: AdventurePhase;
+    scriptDefId: number | null;
+    reason: AdventureEndReason | null;
+    offer: AdventureRewardOffer | null;
+    at: number;
+};
+type AdventureContents = {
+    scriptDefId: number | null;
+    treasure: AdventureActor[];
+    items: AdventureActor[];
+    crystals: CrystalActor[];
+    fighters: AdventureActor[];
+    npcs: AdventureActor[];
+    plants: AdventureActor[];
+    byKind: Partial<Record<AdventureActorKind, AdventureActor[]>>;
+    goals: CrystalGoal[];
+};
 type AdventureStepAction = "trigger" | "pickUp" | "treasureChoice";
 type AdventureStep = {
     action: AdventureStepAction;
@@ -3633,6 +4007,16 @@ type AdventureClientStatus = {
     crystalCount: number;
     maxGoals: number;
 };
+type AdventureRunning = {
+    scriptDefId: number;
+    difficulty: number;
+    startingPlayerCount: number;
+    timeStamp: string;
+};
+type AdventureObjective = {
+    stringId: number;
+    text: string;
+};
 declare class AdventuresApi {
     readonly [STATE_FIELDS]: readonly [
         "lobbyState",
@@ -3705,6 +4089,7 @@ declare class AdventuresApi {
     private readonly defeatedUserIds;
     private readonly awardList;
     private readonly givenItemIds;
+    private actorKindsRead;
     private exitAnswered;
     private lastBundleMessages;
     private readonly iconByActor;
@@ -3831,6 +4216,10 @@ declare class AdventuresApi {
     onRewardChoice(listener: (offer: AdventureRewardOffer) => void): () => void;
     onComplete(listener: (offer: AdventureRewardOffer) => void): () => void;
     onEnd(listener: (end: AdventureEnd) => void): () => void;
+    get phase(): AdventurePhase;
+    onPhase(listener: (change: AdventurePhaseChange) => void): () => void;
+    contents(): Promise<AdventureContents>;
+    private actorKinds;
     onStep(listener: (step: AdventureStep) => void): () => void;
     private comm;
     private questActor;
@@ -3972,12 +4361,24 @@ declare class AdventuresApi {
     }): Promise<void>;
     finishRoomMinigame(roomName: string, result: number): Promise<void>;
     reportSideScroll(at: Point, flags?: number): Promise<void>;
+    running(): Promise<AdventureRunning | null>;
+    objective(): Promise<string>;
+    onObjective(listener: (objective: AdventureObjective) => void): () => void;
+    openList(): Promise<void>;
+    actorTypeNames(): Promise<Record<number, AdventureActorKind>>;
+    private translate;
     private forgetRun;
     private plantOf;
     private respawnPoint;
     private targetOf;
     private manager;
 }
+type MediaPictureOptions = {
+    scale?: number;
+    background?: number | null;
+    maxSize?: number;
+    timeoutMs?: number;
+};
 declare const DEF_PACK_IDS: {
     readonly item: 1000;
     readonly avatar: 1003;
@@ -4013,8 +4414,16 @@ declare class AssetsApi {
     constructor(game: GameContext, flash: PhantomFlash);
     deployVersion(): Promise<string>;
     buildVersion(): Promise<string>;
+    url(assetPath: string, options?: {
+        cdnRoot?: string;
+        deployVersion?: boolean;
+    }): Promise<string>;
     requestDefPack(packId: DefPackId, timeoutMs?: number): Promise<unknown>;
     loadMedia(mediaId: number, timeoutMs?: number): Promise<LoadedMediaInfo>;
+    picture(mediaId: number, options?: MediaPictureOptions): Promise<string>;
+    whenLoaded(id: string | number, options?: {
+        timeoutMs?: number;
+    }): Promise<LoadedAsset>;
     onLoaded(listener: (asset: LoadedAsset) => void): Unsubscribe;
 }
 type BuddySighting = {
@@ -4074,6 +4483,31 @@ type BuddyCardTradeItem = {
     itemType: number;
     name: string;
 };
+type OpenBuddyCard = {
+    userName: string;
+    moderatedUserName: string;
+    accountType: number;
+    isBuddy: boolean;
+    isBlocked: boolean;
+    isOnline: boolean;
+    isArchived: boolean;
+    roomName: string;
+    roomDisplayName: string;
+    node: string;
+};
+type BuddiesOnline = {
+    online: Buddy[];
+    cameOnline: Buddy[];
+    wentOffline: Buddy[];
+};
+type PersonSeen = {
+    userName: string;
+    how: "room" | "online" | "located";
+    userId: number | null;
+    avatarName: string | null;
+    where: BuddySighting | null;
+    at: number;
+};
 type BuddyWhereabouts = {
     roomName: string;
     displayName: string;
@@ -4134,8 +4568,18 @@ declare class BuddiesApi {
     cardTradeList(): Promise<BuddyCardTradeItem[] | null>;
     showCard(userName: string, online?: boolean): Promise<void>;
     closeCard(): Promise<void>;
+    openCard(): Promise<OpenBuddyCard | null>;
+    isListOpen(): Promise<boolean>;
+    closeList(): Promise<void>;
     joinBuddyQuest(): Promise<boolean>;
     pendingSent(): Promise<SentBuddyRequest[]>;
+    watchOnline(listener: (change: BuddiesOnline) => void, options?: {
+        refresh?: boolean;
+        timeoutMs?: number;
+    }): Unsubscribe;
+    watchFor(userName: string, listener: (seen: PersonSeen) => void, options?: {
+        quietMs?: number;
+    }): Unsubscribe;
     private emit;
 }
 declare const PHRASE_TREES: {
@@ -4166,6 +4610,25 @@ type ModerationEvent = {
     action: string;
     extra: string[];
 };
+type Said = {
+    room: number;
+    userId: number;
+    userName: string;
+    avatarName: string;
+    text: string;
+    raw: string;
+    kind: number;
+    level: number | null;
+    at: {
+        x: number;
+        y: number;
+    } | null;
+};
+type BalloonOptions = {
+    colour?: number;
+    seconds?: number;
+    most?: number;
+};
 declare class ChatApi {
     readonly [STATE_FIELDS]: readonly [
         "history",
@@ -4173,12 +4636,14 @@ declare class ChatApi {
         "moderationNotice"
     ];
     private readonly flash;
+    private readonly client;
+    private readonly balloons;
     private readonly server;
     private readonly history;
     private readonly listeners;
     private adminNotice;
     private moderationNotice;
-    constructor(game: GameContext);
+    constructor(game: GameContext, typed?: PhantomFlash);
     get recent(): readonly ChatMessage[];
     say(text: string): Promise<void>;
     emote(id: number): Promise<void>;
@@ -4199,12 +4664,26 @@ declare class ChatApi {
     petAction(action: number, value?: number): Promise<void>;
     attachmentEmote(id: number, extra?: string): Promise<void>;
     isEmote(text: string): Promise<boolean>;
+    balloon(userId: number, text: string, options?: BalloonOptions): Promise<Unsubscribe>;
+    private hushBalloon;
     showBalloon(userId: number, text: string, level?: number): Promise<void>;
     log(text: string, from?: string): Promise<void>;
     clearLog(): Promise<void>;
     onJamAGram(listener: (card: JamAGram) => void): Unsubscribe;
     get lastAdminMessage(): AdminNotice | null;
     get lastModeration(): ModerationEvent | null;
+    typed(): Promise<string>;
+    setTyped(text: string): Promise<void>;
+    isTyping(): Promise<boolean>;
+    clearTyped(): Promise<void>;
+    onTyped(listener: (text: string) => void): Unsubscribe;
+    onSaid(listener: (said: Said) => void): Unsubscribe;
+    transcript(options?: {
+        room?: number;
+    }): Promise<Said[]>;
+    private wordsOf;
+    private roomSpeakers;
+    private chatBar;
     private phraseNodes;
 }
 declare const DIAMOND_TYPE: {
@@ -4228,9 +4707,17 @@ type CurrencyRef = {
     currency: number;
     name: CurrencyKind | null;
 };
+type CurrencyAmountSet = CurrencyRef & {
+    amount: number;
+};
 type CurrencyAmount = CurrencyRef & {
     amount: number | null;
 };
+type Purse = Record<CurrencyKind, number | null>;
+type PurseChange = {
+    currency: number;
+    name: CurrencyKind;
+};
 type PricePart = CurrencyRef & {
     amount: number;
 };
@@ -4255,10 +4742,13 @@ declare class CurrencyApi {
         "balances"
     ];
     private readonly flash;
+    private readonly typedFlash;
     private readonly server;
     private readonly balances;
     private readonly listeners;
-    constructor(game: GameContext);
+    private readonly clientListeners;
+    private clientHook;
+    constructor(game: GameContext, flash: PhantomFlash);
     get gems(): number | null;
     get tickets(): number | null;
     get diamonds(): number | null;
@@ -4273,12 +4763,15 @@ declare class CurrencyApi {
     diamondsLoaded(): Promise<boolean>;
     diamondDefinitionId(refDefId: number, type: DiamondType | number): Promise<number | null>;
     onChange(listener: (change: CurrencyChange) => void): () => void;
+    watch(listener: (purse: Purse, moved: PurseChange | null) => void): Unsubscribe;
     onExchange(listener: (result: ExchangeResult) => void): () => void;
     onDonate(listener: (success: boolean) => void): () => void;
     donateGems(amount: number, timeoutMs?: number): Promise<boolean>;
     redeemCode(code: string, timeoutMs?: number): Promise<RedeemCodeAnswer>;
     onRedeemResult(listener: (answer: RedeemCodeAnswer) => void): () => void;
     onMembershipRedeemed(listener: (membership: PacketOf<typeof MembershipRedeemed>) => void): () => void;
+    onClientBalance(listener: (balance: CurrencyAmountSet) => void): Unsubscribe;
+    private tellClientListeners;
     private update;
 }
 type OpenDailyGift = {
@@ -4286,6 +4779,17 @@ type OpenDailyGift = {
     gems: number;
     diamonds: number;
 };
+type DailyGiftStatus = {
+    ready: boolean;
+    gift: OpenDailyGift | null;
+    wheel: boolean;
+    taken: number;
+    daysInCycle: number;
+    nextDay: number | null;
+};
+type DailyGiftReady = {
+    kind: "gift" | "wheel";
+};
 declare class DailyGiftApi {
     private readonly flash;
     private readonly client;
@@ -4308,6 +4812,8 @@ declare class DailyGiftApi {
     wheelOpen(): Promise<boolean>;
     spinWheel(): Promise<boolean>;
     onWheelOpen(listener: () => void): Unsubscribe;
+    status(): Promise<DailyGiftStatus>;
+    onReady(listener: (ready: DailyGiftReady) => void): Unsubscribe;
     private hookExit;
     private press;
     private popup;
@@ -4315,6 +4821,15 @@ declare class DailyGiftApi {
 type AvatarEditorColorTab = "colors" | "patterns" | "eyes";
 type PetCreatorTab = "colors" | "traits" | "eyes";
 type PetCreatorColorWheel = "color1" | "color2";
+type PetCreatorPet = {
+    defId: number;
+    index: number;
+    eye: number;
+};
+type PetCreatorLook = PetCreatorPet & {
+    color1: number;
+    color2: number;
+};
 type PetCreatorColorState = {
     current: number;
     indexes: readonly number[];
@@ -4338,9 +4853,13 @@ declare class EditorApi {
     isPetCreatorOpen(): Promise<boolean>;
     petCreatorTab(): Promise<PetCreatorTab | null>;
     openPetCreatorTab(tab: PetCreatorTab): Promise<boolean>;
+    petCreatorPet(): Promise<PetCreatorPet | null>;
     petCreatorColor(wheel: PetCreatorColorWheel): Promise<PetCreatorColorState | null>;
     pickPetCreatorColor(wheel: PetCreatorColorWheel, index: number): Promise<boolean>;
     onPetCreatorColorChange(listener: (tableId: number, index: number) => void): () => void;
+    onPetCreatorPet(listener: (pet: PetCreatorPet) => void): () => void;
+    petCreatorLook(): Promise<PetCreatorLook | null>;
+    onPetCreatorLook(listener: (look: PetCreatorLook) => void): () => void;
     onPetCreatorOpen(listener: () => void): () => void;
     onPetCreatorClose(listener: (created: boolean) => void): () => void;
     private avatarEditor;
@@ -4369,6 +4888,20 @@ type PopupClosed = {
     message: string | null;
     modal: boolean;
 };
+type AutoAnswerRule = {
+    choice: PopupAnswer;
+    match: string | null;
+    times: number | null;
+};
+type AutoAnswer = {
+    match?: string;
+    when?: (popup: Popup) => boolean;
+    times?: number;
+};
+type PopupWait = {
+    timeoutMs?: number;
+    everyMs?: number;
+};
 declare const OWN_POPUPS: {
     readonly barrier: "_barrierPopup";
     readonly daysRemaining: "_expiringDaysPopup";
@@ -4378,6 +4911,8 @@ declare const OWN_POPUPS: {
 type OwnPopupName = keyof typeof OWN_POPUPS;
 type LoginPopup = "newspaper" | "holidayBanner" | "adoptAPetIntro";
 declare class PopupsApi {
+    private readonly answering;
+    private nextRule;
     private readonly flash;
     private readonly client;
     private readonly loginSkips;
@@ -4388,8 +4923,14 @@ declare class PopupsApi {
     answer(choice: PopupAnswer, match?: string): Promise<boolean>;
     onOpen(listener: (popup: Popup) => void): () => void;
     onClose(listener: (popup: PopupClosed) => void): () => void;
+    waitFor(match?: string, options?: PopupWait): Promise<Popup | null>;
+    autoAnswer(choice: PopupAnswer, options?: AutoAnswer): Promise<void>;
+    stopAutoAnswering(choice?: PopupAnswer): Promise<number>;
+    get autoAnswering(): AutoAnswerRule[];
+    private endRule;
     isOpen(popup: OwnPopupName): Promise<boolean>;
     close(popup: OwnPopupName): Promise<boolean>;
+    onOwn(popup: OwnPopupName, listener: (open: boolean) => void): () => void;
     skipAtLogin(popups?: readonly LoginPopup[]): Promise<LoginPopup[]>;
     stopSkippingAtLogin(): Promise<void>;
     get skippingAtLogin(): LoginPopup[];
@@ -4429,10 +4970,14 @@ declare class ScreensApi {
     private readonly flash;
     private readonly client;
     constructor(game: GameContext, flash: PhantomFlash);
+    list(): ScreenName[];
     isOpen(screen: ScreenName): Promise<boolean>;
     close(screen: ScreenName): Promise<boolean>;
     onOpen(screen: ScreenName, listener: () => void): () => void;
     onClose(screen: ScreenName, listener: () => void): () => void;
+    waitFor(screen: ScreenName, options?: {
+        timeoutMs?: number;
+    }): Promise<boolean>;
     denSwitcherIndex(): Promise<number | null>;
     serverName(shardId: number): Promise<string>;
     private hookVoid;
@@ -4489,6 +5034,11 @@ type DenShopStand = {
     storeInvId: number;
     defId: number;
 };
+type DenShopLine = DenShopListing & {
+    ownerUserName: string;
+    storeInvId: number;
+    state: string;
+};
 type DenShopUpdate = {
     list?: Array<{
         item: DenShopItem;
@@ -4515,6 +5065,7 @@ declare class DenShopApi {
     onBuy(listener: (purchase: DenShopPurchaseEvent) => void): Unsubscribe;
     onSale(listener: (sale: DenShopSale) => void): Unsubscribe;
     inDen(): Promise<DenShopStand[]>;
+    forSale(timeoutMs?: number): Promise<DenShopLine[]>;
     update(storeInvId: number, state: string, { list, unlist }: DenShopUpdate, timeoutMs?: number): Promise<DenShopChange>;
     private isMe;
     private send;
@@ -4772,6 +5323,10 @@ declare class DensApi {
         ecoScore: number;
     }>;
     items(): Promise<DenPlacedItem[]>;
+    itemAt(point: {
+        x: number;
+        y: number;
+    }): Promise<DenPlacedItem | null>;
     placement(): Promise<DenPlacement | null>;
     moveItem(item: Pick<DenPlacedItem, "refId" | "invIdx">, placement: DenItemPlacement): Promise<boolean>;
     inventory(timeoutMs?: number): Promise<DenInventoryItem[]>;
@@ -4817,6 +5372,7 @@ declare class DensApi {
     heldDenShop(storeInvId: number): Promise<HeldDenShop | null>;
     private placedItems;
     private placedItem;
+    private denItemFrom;
     private ownedItems;
     private findOwnedItem;
     private readOwnedItem;
@@ -4866,6 +5422,16 @@ type ClientJamAGram = {
     stampMediaId: number;
     specialType: number;
 };
+type JamAGramComposing = {
+    toUserName: string;
+    toModeratedUserName: string;
+    message: string;
+    messageType: number;
+    cardMediaId: number;
+    stampMediaId: number;
+    type: number;
+    giftInvId: number;
+};
 declare class ECardsApi {
     readonly [STATE_FIELDS]: readonly [
         "cards",
@@ -4911,6 +5477,8 @@ declare class ECardsApi {
     clientInbox(): Promise<ClientJamAGram[]>;
     clientInboxLoaded(): Promise<boolean>;
     openComposer(userName: string, moderatedUserName?: string): Promise<void>;
+    draft(): Promise<JamAGramComposing | null>;
+    reading(): Promise<JamAGram | null>;
     closeInbox(): Promise<void>;
     isComposerOpen(): Promise<boolean>;
     onReceived(listener: (card: JamAGram) => void): Unsubscribe;
@@ -4948,11 +5516,27 @@ declare const TYPES: {
     readonly work: "TYPE_WORK";
 };
 type FeedbackType = keyof typeof TYPES;
+type FeedbackTopic = {
+    id: number;
+    type: FeedbackType | null;
+    title: string;
+    prompt: string;
+    thanks: string;
+    allowsImage: boolean;
+    seen: boolean;
+};
 declare class FeedbackApi {
     private readonly flash;
-    constructor(game: GameContext);
+    private readonly typed;
+    constructor(game: GameContext, typed?: PhantomFlash);
     types(): Promise<Record<FeedbackType, number>>;
     maxLength(type: FeedbackType | number): Promise<number>;
+    topics(): Promise<FeedbackTopic[]>;
+    open(type: FeedbackType | number): Promise<void>;
+    onOpen(listener: (opened: {
+        id: number;
+        type: FeedbackType | null;
+    }) => void): () => void;
     isOpen(): Promise<boolean>;
     close(): Promise<void>;
 }
@@ -5007,6 +5591,16 @@ type GuiClick = {
     dispatched: readonly string[];
     handled: boolean;
 };
+type GuiWait = {
+    timeoutMs?: number;
+    everyMs?: number;
+};
+type GuiEvent = {
+    type: string;
+    stageX: number;
+    stageY: number;
+    raw: Record<string, FlashValue>;
+};
 declare const SCREENS: {
     readonly avatarEditor: {
         readonly method: "openAvatarEditor";
@@ -5166,6 +5760,9 @@ declare class GuiApi {
     clickHud(part: HudPart | string): Promise<GuiClick>;
     chatBox(): Promise<string>;
     setChatBox(text: string): Promise<void>;
+    onChatBox(listener: (text: string) => void, options?: {
+        everyFrames?: number;
+    }): () => void;
     chatHistory(): Promise<string[]>;
     closeChatPanel(): Promise<void>;
     freeChatEnabled(): Promise<boolean>;
@@ -5187,6 +5784,9 @@ declare class GuiApi {
     pinCurrency(): Promise<void>;
     unpinCurrency(): Promise<void>;
     get currencyPinned(): boolean;
+    waitFor(query: GuiQuery, options?: GuiWait): Promise<GuiElement | null>;
+    on(target: GuiTarget, event: string, listener: (event: GuiEvent) => void): () => void;
+    hover(target: GuiTarget, over?: boolean): Promise<boolean>;
     private rollCurrency;
     private chatField;
     private setFieldText;
@@ -5201,16 +5801,252 @@ declare class GuiApi {
     private onElement;
     private rootPlace;
 }
-type InventoryItem = {
-    invId: number;
+type ItemDefinition = {
     defId: number;
-    color: number;
-    wornOn: number[];
-    denStoreInvId: number;
-};
-type ItemPlace = "worn" | "den-shop" | "inventory";
-type OwnedItem = InventoryItem & {
-    where: ItemPlace;
+    name: string;
+    titleStrId: number;
+    cost: number;
+    currencyType: number;
+    combinedCost: string;
+    membersOnly: boolean;
+    recycleValue: number;
+    type: number;
+    enviroType: number;
+    colors: number[];
+    layerId: number;
+    accId: number;
+    avatarUseFlag: number;
+    itemStatus: number;
+    isNew: boolean;
+    isOnSale: boolean;
+    isGiftable: boolean;
+    availabilityStartTime: number;
+    availabilityEndTime: number;
+    combat: ItemCombat;
+};
+type ItemCombat = {
+    attack: number;
+    defense: number;
+    attackMediaRefId: number;
+    combatType: number;
+    modifierType: number;
+    modifierValue: number;
+    criticalHit: number;
+};
+type ShopOffering = {
+    shopId: number;
+    listType: number;
+    titleStrId: number | null;
+    diamondBundle: boolean;
+    diamondCost: number;
+    items: ItemDefinition[];
+    unknownDefIds: number[];
+};
+type ShopListing = {
+    shopId: number;
+    listType: number;
+    defIds: number[];
+};
+type OpenShop = {
+    shopId: number;
+    listType: number;
+    windowClass: string;
+    itemCount: number;
+    selectedIndex: number | null;
+    selectedDefId: number | null;
+    selectedDiamond: boolean | null;
+    selectedColorIndex: number;
+};
+type ShopLimits = {
+    items: number;
+    denItems: number;
+    audioItems: number;
+    warnItems: number;
+    warnDenItems: number;
+    warnAudioItems: number;
+    warnDenRooms: number;
+    denShopItems: 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 ItemRarity = "normal" | "new" | "sale" | "clearance" | "rare";
+type ItemSummary = {
+    defId: number;
+    kind: ItemPictureKind;
+    name: string;
+    rarity: ItemRarity;
+    cost: number;
+    currencyType: number;
+    membersOnly: boolean;
+    forSale: boolean;
+    picture: string | null;
+};
+type ItemSummaryOptions = {
+    kind?: ItemPictureKind;
+    picture?: boolean | ItemPictureOptions;
+};
+type ItemSummariesOptions = ItemSummaryOptions & {
+    atOnce?: number;
+};
+type DenShopOffering = {
+    shopId: number;
+    listType: number;
+    items: DenItemDefinition[];
+    unknownDefIds: number[];
+};
+type DiamondItem = {
+    defId: number;
+    value: number;
+    type: number;
+    refDefId: number;
+    status: number;
+    isNew: boolean;
+    isOnSale: boolean;
+    isOnClearance: boolean;
+    isRare: boolean;
+    isAvailable: boolean;
+    availabilityEndTime: number;
+    startTime: number;
+};
+type DiamondDefinition = {
+    defId: number;
+    value: number;
+    refDefId: number;
+    type: number;
+    status: number;
+    availabilityStartTime: number;
+    availabilityEndTime: number;
+};
+type DiamondShopItem = {
+    diamondDefId: number;
+    defId: number | null;
+    itemClass: string | null;
+};
+type DiamondShopList = {
+    items: DiamondShopItem[];
+    unknownDefIds: number[];
+};
+type Purchase = {
+    defId: number;
+    shopId: number;
+    status: number;
+    balance: number | null;
+    currencyType: number;
+};
+type Sale = {
+    invIds: number[];
+    gems: number | null;
+};
+declare class ShopsApi {
+    readonly [STATE_FIELDS]: readonly [
+        "lists"
+    ];
+    private readonly flash;
+    private readonly client;
+    private readonly server;
+    private readonly lists;
+    private readonly pictures;
+    constructor(game: GameContext, flash: PhantomFlash);
+    offering(shopId: number, { refresh, timeoutMs, }?: {
+        refresh?: boolean;
+        timeoutMs?: number;
+    }): Promise<ShopOffering>;
+    denOffering(shopId: number, { refresh, timeoutMs, }?: {
+        refresh?: boolean;
+        timeoutMs?: number;
+    }): Promise<DenShopOffering>;
+    definition(defId: number): Promise<ItemDefinition | null>;
+    definitionsReady(): Promise<boolean>;
+    picture(item: ItemPictureItem, options?: ItemPictureOptions): Promise<string>;
+    isAvailable(window: {
+        availabilityStartTime: number;
+        availabilityEndTime: number;
+    }): Promise<boolean>;
+    item(defId: number, options?: ItemSummaryOptions): Promise<ItemSummary | null>;
+    items(defIds: readonly number[], options?: ItemSummariesOptions): Promise<Array<ItemSummary | null>>;
+    forSale(shopId: number, options?: {
+        refresh?: boolean;
+        timeoutMs?: number;
+    }): Promise<ItemDefinition[]>;
+    whenDefinitionsReady(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    diamondItem(defId: number): Promise<DiamondItem | null>;
+    diamondDefinition(entry: number | {
+        refDefId: number;
+        type: number;
+    }): 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>;
+    openShop(): Promise<OpenShop | null>;
+    limits(): Promise<ShopLimits>;
+    onOpen(listener: (opened: {
+        shopId: number;
+        listType: number;
+    }) => void): () => void;
+    onClose(listener: (closed: {
+        bought: boolean;
+    }) => void): () => void;
+    buyDiamondBundle(timeoutMs?: number): Promise<{
+        bought: boolean;
+        balance: number | null;
+    }>;
+    buy(defId: number, { shopId, colorIndex, diamond, forDenItem, timeoutMs, }: {
+        shopId: number;
+        colorIndex?: number;
+        diamond?: boolean;
+        forDenItem?: {
+            invId: number;
+            userName: string;
+        };
+        timeoutMs?: number;
+    }): Promise<Purchase>;
+    sell(...invIds: number[]): Promise<Sale>;
+    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;
+}
+type InventoryItem = {
+    invId: number;
+    defId: number;
+    color: number;
+    wornOn: number[];
+    denStoreInvId: number;
+};
+type ItemPlace = "worn" | "den-shop" | "inventory";
+type OwnedItem = InventoryItem & {
+    where: ItemPlace;
+};
+type DescribedItem = OwnedItem & {
+    definition: ItemDefinition | null;
 };
 type OwnedFilter = {
     defId?: number | number[];
@@ -5238,11 +6074,19 @@ type ItemPrizeOffer = {
     nameStrId: number;
     descStrId: number;
 };
+type ItemHolding = {
+    owned: boolean;
+    count: number;
+    worn: number;
+    spare: number;
+    items: OwnedItem[];
+};
 type RecycleResult = {
     recycled: number[];
     gems: number | null;
 };
 declare class InventoryApi {
+    private readonly areas;
     readonly [STATE_FIELDS]: readonly [
         "inventory",
         "slots",
@@ -5256,14 +6100,22 @@ declare class InventoryApi {
     private readonly slotListeners;
     private readonly prizeListeners;
     private prize;
-    constructor(game: GameContext);
+    constructor(game: GameContext, areas: () => {
+        shops: ShopsApi;
+    });
     items({ refresh }?: {
         refresh?: boolean;
     }): Promise<InventoryItem[]>;
     owned({ defId, color, where, refresh }?: OwnedFilter): Promise<OwnedItem[]>;
+    describe(filter?: OwnedFilter): Promise<DescribedItem[]>;
+    private shops;
     worn({ refresh }?: {
         refresh?: boolean;
     }): Promise<OwnedItem[]>;
+    have(defId: number, { color, refresh }?: {
+        color?: number;
+        refresh?: boolean;
+    }): Promise<ItemHolding>;
     canWear(defId: number, { custom }?: {
         custom?: boolean;
     }): Promise<boolean>;
@@ -5295,6 +6147,19 @@ declare class InventoryApi {
     private apply;
 }
 type Language = "english" | "spanish" | "portuguese" | "french" | "german" | "none";
+declare const WORDS: {
+    readonly gems: "GEMS_CAPITALIZED";
+    readonly gem: "GEM_CAPITALIZED";
+    readonly diamonds: "DIAMONDS_CAPITALIZED";
+    readonly diamond: "DIAMOND_CAPITALIZED";
+    readonly crystals: "CRYSTALS_CAPITALIZED";
+    readonly crystal: "CRYSTAL_CAPITALIZED";
+    readonly tickets: "TICKETS_CAPITALIZED";
+    readonly ticket: "TICKET_CAPITALIZED";
+    readonly members: "MEMBERS";
+    readonly newJammerName: "NEW_JAMMER_USERNAME";
+};
+type GameWord = keyof typeof WORDS;
 type LocalizedText = {
     text: string;
     isHtmlNormal: boolean;
@@ -5305,6 +6170,7 @@ declare class LocalizationApi {
     private readonly bridge;
     private readonly flash;
     private codes;
+    private wordCodes;
     constructor(game: GameContext, flash: PhantomFlash);
     currentLanguage(): Promise<Language>;
     accountLanguage(): Promise<Language>;
@@ -5314,6 +6180,9 @@ declare class LocalizationApi {
     countryCode(): Promise<string>;
     hasLocalizations(): Promise<boolean>;
     translate(id: number): Promise<string>;
+    translateAll(ids: readonly number[]): Promise<string[]>;
+    word(name: GameWord): Promise<string>;
+    words(): GameWord[];
     translatePreferred(id: number): Promise<string>;
     translateWithValues(id: number, ...values: string[]): Promise<string>;
     translateAvatarName(name: string): Promise<string>;
@@ -5324,8 +6193,16 @@ declare class LocalizationApi {
     languageId(language: Language): Promise<number>;
     onLanguageChange(listener: (language: Language) => void): () => void;
     onReady(listener: () => void): () => void;
+    private wordIds;
     private languageCodes;
 }
+type MasterpiecePictureOptions = {
+    scale?: number;
+    background?: number | null;
+    maxSize?: number;
+    timeoutMs?: number;
+    cache?: boolean;
+};
 type Masterpiece = DenMasterpieceItem;
 type MasterpieceList = {
     userName: string | null;
@@ -5356,6 +6233,7 @@ declare class MasterpiecesApi {
     private readonly creatorsAsked;
     private readonly likesAsked;
     private readonly likesGiven;
+    private readonly pictures;
     private readonly itemsListeners;
     private readonly creatorListeners;
     private readonly likesListeners;
@@ -5365,6 +6243,8 @@ declare class MasterpiecesApi {
     creatorOf(denUserName: string, uniqueImageId: string, timeoutMs?: number): Promise<string>;
     likes(uniqueImageId: string, timeoutMs?: number): Promise<MasterpieceLikes>;
     like(masterpiece: LikeableMasterpiece, timeoutMs?: number): Promise<boolean>;
+    picture(uniqueImageId: string, options?: MasterpiecePictureOptions): Promise<string>;
+    private draw;
     onItems(listener: (list: MasterpieceList) => void): Unsubscribe;
     onCreator(listener: (creator: MasterpieceCreator) => void): Unsubscribe;
     onLikes(listener: (likes: MasterpieceLikesEvent) => void): Unsubscribe;
@@ -5629,6 +6509,18 @@ type MinigamePlayerInfo = {
     activePetName: string;
     member: boolean;
 };
+type MinigameRound = {
+    gameDefId: number | null;
+    name: string;
+    score: number | null;
+    gems: number | null;
+    ended: boolean;
+    data: readonly string[];
+    at: number;
+};
+type MinigameRoundOptions = {
+    settleMs?: number;
+};
 type MinigameJoinOptions = {
     multiplayer?: boolean;
     proModeId?: number;
@@ -5720,6 +6612,7 @@ declare class MinigamesApi {
     onGemAward(listener: (sent: MinigameAwardSent) => void): Unsubscribe;
     onPetMasteryAward(listener: (sent: MinigameAwardSent) => void): Unsubscribe;
     onScore(listener: (sent: MinigameScoreSent) => void): Unsubscribe;
+    onRound(listener: (round: MinigameRound) => void, options?: MinigameRoundOptions): Unsubscribe;
     quit(): Promise<void>;
     playerInfo(): Promise<MinigamePlayerInfo>;
     gameNameId(gameDefId: number): Promise<number | null>;
@@ -5754,6 +6647,12 @@ type ShownMembership = {
     member: boolean;
     daysLeft: number;
 };
+type MembershipUpsell = {
+    page: string;
+    reason: string;
+    subject: string | null;
+    roomName: string | null;
+};
 declare class MembershipApi {
     readonly [STATE_FIELDS]: readonly [
         "heard"
@@ -5764,17 +6663,28 @@ declare class MembershipApi {
     private questRoom;
     private readonly changeListeners;
     private readonly lookListeners;
+    private readonly upsellListeners;
+    private upsellHook;
+    private upsellsOff;
     private readonly flash;
+    private readonly typedFlash;
     private readonly server;
     private readonly client;
-    constructor(game: GameContext);
+    constructor(game: GameContext, flash: PhantomFlash);
     get real(): Membership | null;
     onChange(listener: (membership: Membership) => void): Unsubscribe;
+    watch(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>;
+    onUpsell(listener: (upsell: MembershipUpsell) => void): Unsubscribe;
+    get upsellsHidden(): boolean;
+    hideUpsells(hide?: boolean): Promise<boolean>;
+    private upsellOptions;
+    private syncUpsellHook;
+    private tellUpsellListeners;
     private hear;
     private hook;
     private rewriteLogin;
@@ -5798,12 +6708,20 @@ type NewspaperReadState = {
     defId: number;
     timeSeen: number;
 };
+type AvailableNewspaperIssue = NewspaperIssue & {
+    available: boolean;
+    viewable: boolean;
+    inCountry: boolean;
+};
 declare class NewspaperApi {
     private readonly flash;
     private readonly server;
     private readonly seenListeners;
     constructor(game: GameContext);
     definitions(): Promise<NewspaperIssue[]>;
+    available(): Promise<AvailableNewspaperIssue[]>;
+    reading(): Promise<NewspaperIssue | null>;
+    close(): Promise<void>;
     definition(defId: number): Promise<NewspaperIssue | null>;
     dataOf(defId: number): Promise<NewspaperReadState | null>;
     hasUnseenPages(): Promise<boolean>;
@@ -5813,6 +6731,16 @@ declare class NewspaperApi {
     onPageSeen(listener: (seen: PacketOf<typeof NewspaperPageSeen>) => void): () => void;
     private readIssue;
 }
+type PetInWorld = {
+    name: string;
+    defId: number;
+    createdTs: number;
+    position: Point;
+    visible: boolean;
+    ground: boolean;
+    moving: boolean;
+    unhatchedEgg: boolean;
+};
 type PlayerPet = {
     invId: number;
     name: string;
@@ -5827,6 +6755,16 @@ type PlayerPet = {
     favoriteFoodDefId: number;
     denStoreInvId: number;
 };
+type OwnedPet = PlayerPet & {
+    kind: string;
+    out: boolean;
+};
+type PetRoster = {
+    pets: OwnedPet[];
+    out: OwnedPet | null;
+    max: number;
+    room: number;
+};
 type PetDefinition = {
     defId: number;
     title: string;
@@ -5986,6 +6924,7 @@ declare class PetsApi {
     activeName(): Promise<string>;
     get(invId: number): Promise<PlayerPet | null>;
     max(): Promise<number>;
+    mine(): Promise<PetRoster>;
     kindName(defId: number): Promise<string>;
     kindId(name: string): Promise<number>;
     definition(defId: number): Promise<PetDefinition | null>;
@@ -6095,6 +7034,7 @@ declare class PetsApi {
     onAdoptionChecklist(listener: (checklist: AdoptionChecklist) => void): () => void;
     onAdoptionCount(listener: (count: number) => void): () => void;
     onDefinitionsLoaded(listener: () => void): () => void;
+    inWorld(): Promise<PetInWorld | null>;
 }
 type CachedWall = {
     posts: WallPost[];
@@ -6130,6 +7070,10 @@ type WallPost = {
     patternId: number;
     localizationId: number;
 };
+type WallThreadPost = WallPost & {
+    text: string;
+    replies: WallThreadPost[];
+};
 type WallContents = {
     owner: string;
     posts: WallPost[];
@@ -6239,11 +7183,19 @@ declare class PlayerWallApi {
     hiddenPostIds(): Promise<string[]>;
     permissions(userName: string): Promise<WallPermissions>;
     showPostAs(msgId: string, text: string): Promise<void>;
+    serviceRequest(command: string, fields?: {
+        [key: string]: WallValue;
+    }, userName?: string): Promise<void>;
+    private tokenFor;
     private readPosts;
     private asList;
     private readPost;
     private buildPost;
     private withOwner;
+    thread(userName?: string, options?: {
+        timeoutMs?: number;
+    }): Promise<WallThreadPost[]>;
+    private wallPhrase;
     private playerName;
     private comm;
 }
@@ -6404,6 +7356,14 @@ type DenRoomDefinition = {
     availabilityStartTime: number;
     availabilityEndTime: number;
 };
+type BelongingKind = "clothing" | "den" | "pet";
+type Belonging = {
+    kind: BelongingKind;
+    invIdx: number;
+    defId: number;
+    name: string;
+    itemType: number;
+};
 type PartyHosting = {
     userName: string;
     secondsLeft: number;
@@ -6461,6 +7421,8 @@ declare class PlayerApi {
     }): Promise<ClothingItem[]>;
     denItemsForRoom(): Promise<DenInventoryItem[]>;
     petsInDen(world: "land" | "ocean"): Promise<DenInventoryItem[]>;
+    belongings(kind?: BelongingKind | readonly BelongingKind[]): Promise<Belonging[]>;
+    private ownPets;
     animalKindCount(): Promise<number>;
     animalDefaults(avTypeId: number): Promise<AnimalDefaults>;
     customAnimal(customAvId: number): Promise<AnimalKind | null>;
@@ -6468,6 +7430,10 @@ declare class PlayerApi {
     animalOf(userName?: string): Promise<AnimalKind | null>;
     denRoomDefinitions(): Promise<DenRoomDefinition[]>;
     denRoomDefinition(defId: number): Promise<DenRoomDefinition | null>;
+    activeDenId(): Promise<number>;
+    onActiveDenChange(listener: (invId: number) => void): Unsubscribe;
+    buddyCount(): Promise<number>;
+    onBuddyCountChange(listener: (count: number) => void): Unsubscribe;
     private hear;
     private stateSources;
     private recordOf;
@@ -6510,6 +7476,7 @@ declare class ReportsApi {
     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>;
+    alreadyReported(userName: string): Promise<boolean>;
     onReportResult(listener: (taken: boolean) => void): Unsubscribe;
     onContentReportResult(listener: (taken: boolean) => void): Unsubscribe;
     onReportSent(listener: (report: SentReport) => void): Unsubscribe;
@@ -6690,9 +7657,14 @@ declare class RoomApi {
     private readonly failureListeners;
     private readonly giftsAsked;
     private readonly giftListeners;
+    private readonly loadedListeners;
+    private builtHook;
+    private builtWanted;
+    private hidingPlayers;
     private readonly server;
     private readonly flash;
-    constructor(game: GameContext);
+    private readonly phantomFlash;
+    constructor(game: GameContext, flash?: PhantomFlash);
     get current(): RoomInfo | null;
     get details(): RoomDetails | null;
     get layout(): RoomLayout | null;
@@ -6716,6 +7688,10 @@ declare class RoomApi {
     onWorldItemTaken(listener: (gift: WorldItemTakenEvent) => void): () => void;
     private hasTakenGift;
     onJoin(listener: (room: RoomInfo) => void): () => void;
+    onLoaded(listener: (scene: RoomScene) => void): () => void;
+    whenLoaded(options?: {
+        timeoutMs?: number;
+    }): Promise<boolean>;
     focusCamera(at: {
         x: number;
         y: number;
@@ -6733,12 +7709,14 @@ declare class RoomApi {
     }): Promise<void>;
     respawn(): Promise<void>;
     spawns(): Promise<RoomSpawn[]>;
+    walkToSpawn(name: string): Promise<void>;
     portals(): Promise<RoomPortal[]>;
     volumes(): Promise<RoomVolume[]>;
     volumesAt(point: {
         x: number;
         y: number;
     }): Promise<RoomVolume[]>;
+    enableVolume(name: string, enabled: boolean): Promise<void>;
     bounds(): Promise<RoomBounds>;
     camera(): Promise<RoomCamera>;
     moveCamera(offset: {
@@ -6777,6 +7755,7 @@ declare class RoomApi {
     setPathDepth(cells: number): Promise<void>;
     reload(): Promise<boolean>;
     showAvatars(show: boolean): Promise<void>;
+    showPlayers(show: boolean): Promise<void>;
     joiningInvisibly(): Promise<boolean>;
     darkAreas(): Promise<RoomDarkArea[]>;
     nearestEmptyCell(point: {
@@ -6795,6 +7774,11 @@ declare class RoomApi {
     }): Promise<RoomObjectAt | null>;
     setJamaaTime(milliseconds: number): Promise<void>;
     setDenKickNotice(show: boolean): Promise<void>;
+    private wantBuiltHook;
+    private releaseBuiltHook;
+    private hookBuilt;
+    private tellLoaded;
+    private roomBuilt;
     private darkArea;
     private actors;
     private number;
@@ -6803,6 +7787,8 @@ declare class RoomApi {
     join(name: string, options?: {
         invisible?: boolean;
     }): Promise<void>;
+    onChange(listener: (change: RoomChange) => void): () => void;
+    surfaces(): Promise<RoomSurface[]>;
 }
 type RoomPlayer = {
     userId: number;
@@ -6854,14 +7840,59 @@ declare class RoomPlayers {
     refresh(): Promise<readonly RoomPlayer[]>;
     viewOf(userId: number): Promise<RoomPlayerView | null>;
     views(): Promise<RoomPlayerView[]>;
+    onList(listener: (event: RoomPlayerList) => void, options?: {
+        refresh?: boolean;
+    }): () => void;
+    onPosition(userId: number, listener: (where: RoomPlayerWhere) => void, options?: {
+        everyMs?: number;
+    }): () => void;
     private move;
 }
+declare const ROOM_SURFACES: {
+    readonly behind: "room_bkg_main";
+    readonly players: "room_avatars";
+    readonly front: "room_fg";
+    readonly over: "room_super_fg";
+    readonly chat: "room_chat";
+    readonly interface: "gui";
+};
+type RoomSurfaceName = keyof typeof ROOM_SURFACES;
+type RoomSurface = {
+    name: RoomSurfaceName;
+    layer: (typeof ROOM_LAYER_NAMES)[number];
+    ready: boolean;
+    children: number;
+    visible: boolean;
+    place: FlashReference;
+};
+type RoomChange = {
+    from: RoomInfo | null;
+    to: RoomInfo;
+};
+type RoomPlayerList = {
+    players: readonly RoomPlayer[];
+    arrived: RoomPlayer | null;
+    left: RoomPlayer | null;
+};
+type RoomPlayerWhere = {
+    userId: number;
+    x: number;
+    y: number;
+    here: boolean;
+    moving: boolean | null;
+};
 type ConnectionMode = "socket" | "http" | "disconnected";
 type ConnectionServer = {
     host: string;
     port: number;
     ips: readonly string[];
 };
+type SessionReady = {
+    connected: boolean;
+    loggedIn: boolean;
+    inWorld: boolean;
+    worldReady: boolean;
+};
 type ConnectionOutcome = {
     connected: boolean;
 };
@@ -6878,6 +7909,11 @@ declare class SessionApi {
     constructor(game: GameContext, flash: PhantomFlash);
     connected(): Promise<boolean>;
     mode(): Promise<ConnectionMode>;
+    ready(): Promise<SessionReady>;
+    whenReady(options?: {
+        step?: keyof SessionReady;
+        timeoutMs?: number;
+    }): Promise<SessionReady>;
     server(): Promise<ConnectionServer>;
     onConnectionLost(listener: () => void): Unsubscribe;
     onConnected(listener: (outcome: ConnectionOutcome) => void): Unsubscribe;
@@ -6901,186 +7937,6 @@ declare class SessionApi {
     onIdleWarning(listener: () => void): Unsubscribe;
     private hookVoid;
 }
-type ItemDefinition = {
-    defId: number;
-    name: string;
-    titleStrId: number;
-    cost: number;
-    currencyType: number;
-    combinedCost: string;
-    membersOnly: boolean;
-    recycleValue: number;
-    type: number;
-    enviroType: number;
-    colors: number[];
-    layerId: number;
-    accId: number;
-    avatarUseFlag: number;
-    itemStatus: number;
-    isNew: boolean;
-    isOnSale: boolean;
-    isGiftable: boolean;
-    availabilityStartTime: number;
-    availabilityEndTime: number;
-    combat: ItemCombat;
-};
-type ItemCombat = {
-    attack: number;
-    defense: number;
-    attackMediaRefId: number;
-    combatType: number;
-    modifierType: number;
-    modifierValue: number;
-    criticalHit: number;
-};
-type ShopOffering = {
-    shopId: number;
-    listType: number;
-    titleStrId: number | null;
-    diamondBundle: boolean;
-    diamondCost: number;
-    items: ItemDefinition[];
-    unknownDefIds: number[];
-};
-type ShopListing = {
-    shopId: number;
-    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;
-    items: DenItemDefinition[];
-    unknownDefIds: number[];
-};
-type DiamondItem = {
-    defId: number;
-    value: number;
-    type: number;
-    refDefId: number;
-    status: number;
-    isNew: boolean;
-    isOnSale: boolean;
-    isOnClearance: boolean;
-    isRare: boolean;
-    isAvailable: boolean;
-    availabilityEndTime: number;
-    startTime: number;
-};
-type DiamondDefinition = {
-    defId: number;
-    value: number;
-    refDefId: number;
-    type: number;
-    status: number;
-    availabilityStartTime: number;
-    availabilityEndTime: number;
-};
-type DiamondShopItem = {
-    diamondDefId: number;
-    defId: number | null;
-    itemClass: string | null;
-};
-type DiamondShopList = {
-    items: DiamondShopItem[];
-    unknownDefIds: number[];
-};
-type Purchase = {
-    defId: number;
-    shopId: number;
-    status: number;
-    balance: number | null;
-    currencyType: number;
-};
-type Sale = {
-    invIds: number[];
-    gems: number | null;
-};
-declare class ShopsApi {
-    readonly [STATE_FIELDS]: readonly [
-        "lists"
-    ];
-    private readonly flash;
-    private readonly client;
-    private readonly server;
-    private readonly lists;
-    private readonly pictures;
-    constructor(game: GameContext, flash: PhantomFlash);
-    offering(shopId: number, { refresh, timeoutMs, }?: {
-        refresh?: boolean;
-        timeoutMs?: number;
-    }): Promise<ShopOffering>;
-    denOffering(shopId: number, { refresh, timeoutMs, }?: {
-        refresh?: boolean;
-        timeoutMs?: number;
-    }): Promise<DenShopOffering>;
-    definition(defId: number): Promise<ItemDefinition | null>;
-    definitionsReady(): Promise<boolean>;
-    picture(item: ItemPictureItem, options?: ItemPictureOptions): Promise<string>;
-    isAvailable(window: {
-        availabilityStartTime: number;
-        availabilityEndTime: number;
-    }): Promise<boolean>;
-    diamondItem(defId: number): Promise<DiamondItem | null>;
-    diamondDefinition(entry: number | {
-        refDefId: number;
-        type: number;
-    }): 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>;
-    onOpen(listener: (opened: {
-        shopId: number;
-        listType: number;
-    }) => void): () => void;
-    buyDiamondBundle(timeoutMs?: number): Promise<{
-        bought: boolean;
-        balance: number | null;
-    }>;
-    buy(defId: number, { shopId, colorIndex, diamond, forDenItem, timeoutMs, }: {
-        shopId: number;
-        colorIndex?: number;
-        diamond?: boolean;
-        forDenItem?: {
-            invId: number;
-            userName: string;
-        };
-        timeoutMs?: number;
-    }): Promise<Purchase>;
-    sell(...invIds: number[]): Promise<Sale>;
-    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: {
     readonly gift: "hasLoadedGiftUnwrapSfx";
     readonly trade: "hasLoadedTradeSfx";
@@ -7140,6 +7996,9 @@ declare class SoundApi {
     private readonly bridge;
     private readonly flash;
     private readonly changeListeners;
+    private readonly audioListeners;
+    private audioHooks;
+    private audioReading;
     constructor(game: GameContext, flash: PhantomFlash);
     settings(): Promise<SoundSettings>;
     areSoundsMuted(): Promise<boolean>;
@@ -7150,6 +8009,8 @@ declare class SoundApi {
     muteMusic(muted: boolean): Promise<SoundSettings>;
     muteAll(muted: boolean): Promise<SoundSettings>;
     toggleMute(): Promise<SoundSettings>;
+    silence(): Promise<SoundSettings>;
+    restore(settings: SoundSettings): Promise<SoundSettings>;
     setVolume(volume: number): Promise<SoundSettings>;
     setSoundVolume(volume: number): Promise<SoundSettings>;
     setMusicVolume(volume: number): Promise<SoundSettings>;
@@ -7163,6 +8024,10 @@ declare class SoundApi {
     unpauseSounds(): Promise<void>;
     stopAll(): Promise<void>;
     onChange(listener: (settings: SoundSettings) => void): Unsubscribe;
+    onAudioChange(listener: (settings: SoundSettings) => void): Unsubscribe;
+    private watchAudio;
+    private unwatchAudio;
+    private audioChanged;
     onPlay(listener: (className: string, loops: number) => void): () => void;
     onStop(listener: (className: string) => void): () => void;
     private hookAudio;
@@ -7226,6 +8091,21 @@ type TradeListEdit = {
     removed: InventoryRef[];
 };
 type TradeListing = Omit<PacketOf<typeof TradeList>, "room">;
+type TradeStage = "none" | "asking" | "offered" | "accepted" | "completed" | "ended";
+type TradeState = {
+    stage: TradeStage;
+    trading: boolean;
+    userName: string | null;
+    theirOffer: TradeOffer | null;
+    theyWant: {
+        kind: number;
+        invIdx: number;
+    } | null;
+    myList: TradeItemRef[];
+    myDraft: TradeDraftItem[];
+    completion: TradeCompletion | null;
+    end: TradeEnd | null;
+};
 declare class TradesApi {
     readonly [STATE_FIELDS]: readonly [
         "pending"
@@ -7242,6 +8122,9 @@ declare class TradesApi {
     onEnd(listener: (end: TradeEnd) => void): Unsubscribe;
     onChange(listener: (change: TradeChange) => void): Unsubscribe;
     request(userName: string, wanted: TradeItemRef, { clothing, den, audio, pets }?: TradeOfferItems): Promise<void>;
+    openRequest(userName: string, wanted: TradeItemRef, { timeoutMs }?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     add(...items: TradeItemRef[]): Promise<void>;
     remove(...items: TradeItemRef[]): Promise<void>;
     myList(timeoutMs?: number): Promise<TradeListing>;
@@ -7258,6 +8141,9 @@ declare class TradesApi {
     offerDraft(): Promise<TradeDraftItem[]>;
     counts(): Promise<TradeCounts>;
     listEntry(item: TradeItemRef): Promise<TradeItemRef | null>;
+    state(): Promise<TradeState>;
+    onState(listener: (state: TradeState) => void): Unsubscribe;
+    private whenCardReady;
     private ownCollection;
     private comm;
     private changeList;
@@ -7409,13 +8295,17 @@ type UiWindowOptions = UiOptions & {
     closable?: boolean;
 };
 type UiButton = UiWidget & {
+    label(): string;
     setLabel(label: string): Promise<void>;
     setDisabled(disabled: boolean): Promise<void>;
+    setImage(image: string | null): Promise<void>;
     onClick(listener: () => void): UiRemove;
 };
 type UiButtonOptions = UiOptions & {
     disabled?: boolean;
     primary?: boolean;
+    image?: string;
+    imageOnly?: boolean;
 };
 type UiLabel = UiWidget & {
     setText(text: string): Promise<void>;
@@ -7501,6 +8391,16 @@ type UiGridOptions = UiOptions & {
     tileHeight?: number;
     gap?: number;
 };
+type UiImage = UiWidget & {
+    source(): string;
+    setSource(url: string): Promise<void>;
+    onFailed(listener: (message: string) => void): UiRemove;
+};
+type UiImageOptions = UiOptions & {
+    alt?: string;
+    centered?: boolean;
+    alpha?: number;
+};
 type UiScroll = UiWidget & {
     readonly body: OverlayNode;
     offset(): number;
@@ -7520,6 +8420,66 @@ type UiTooltipOptions = UiOptions & {
     visible?: boolean;
     target?: UiWidget | OverlayNode;
 };
+type UiPromptOptions = {
+    title?: string;
+    value?: string;
+    placeholder?: string;
+    maxLength?: number;
+    okLabel?: string;
+    cancelLabel?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    skin?: UiSkin;
+};
+type UiChooseOptions = {
+    title?: string;
+    cancelLabel?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    rows?: number;
+    skin?: UiSkin;
+};
+type UiNotice = UiWidget & {
+    setText(text: string): Promise<void>;
+    onClose(listener: () => void): UiRemove;
+};
+type UiNoticeOptions = {
+    title?: string;
+    seconds?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    closable?: boolean;
+    draggable?: boolean;
+    skin?: UiSkin;
+};
+type UiTagTarget = number | {
+    readonly place: FlashPlaceLike;
+} | UiPlace;
+type UiTag = UiWidget & {
+    setText(text: string): Promise<void>;
+};
+type UiTagOptions = {
+    offsetX?: number;
+    offsetY?: number;
+    colour?: number;
+    heading?: boolean;
+    background?: boolean;
+    seconds?: number;
+    key?: string;
+    skin?: UiSkin;
+};
+type UiTipOptions = {
+    offsetX?: number;
+    offsetY?: number;
+    skin?: UiSkin;
+};
+type UiStageSize = {
+    width: number;
+    height: number;
+};
 type UiProgress = UiWidget & {
     value(): number;
     setValue(value: number): Promise<void>;
@@ -7584,6 +8544,7 @@ declare class UiApi {
     private readonly flash;
     private readonly drawn;
     private readonly popups;
+    private readonly tags;
     private symbolMaker;
     private gameFont;
     private defaultSkin;
@@ -7611,6 +8572,7 @@ declare class UiApi {
     tabs(options: UiTabsOptions): Promise<UiTabs>;
     list(options?: UiListOptions): Promise<UiList>;
     grid(options: UiGridOptions): Promise<UiGrid>;
+    image(source: string, options?: UiImageOptions): Promise<UiImage>;
     scroll(options?: UiScrollOptions): Promise<UiScroll>;
     tooltip(options?: UiTooltipOptions): Promise<UiTooltip>;
     private bubble;
@@ -7618,6 +8580,13 @@ declare class UiApi {
     progress(options?: UiProgressOptions): Promise<UiProgress>;
     colors(options?: UiColorsOptions): Promise<UiColors>;
     paletteValues(which?: 1 | 2 | "game"): Promise<number[]>;
+    prompt(text: string, options?: UiPromptOptions): UiPopupAnswer<string | null>;
+    choose(text: string, choices: readonly (UiChoice | string)[], options?: UiChooseOptions): UiPopupAnswer<string | null>;
+    notice(text: string, options?: UiNoticeOptions): Promise<UiNotice>;
+    tag(target: UiTagTarget, text: string, options?: UiTagOptions): Promise<UiTag>;
+    tipOn(place: UiPlace, text: string | (() => string | Promise<string>), options?: UiTipOptions): Promise<UiRemove>;
+    stageSize(): Promise<UiStageSize>;
+    onStageResize(listener: (size: UiStageSize) => void): () => void;
     places(): UiSpot[];
     place(spot: UiSpot): FlashPlaceLike;
     attach(place: UiPlace, widget: UiWidget | OverlayNode): Promise<UiRemove>;
@@ -7633,7 +8602,10 @@ declare class UiApi {
     clear(): Promise<void>;
     private pieceOf;
     private widget;
+    private picture;
     private box;
+    private anchorOf;
+    private mouse;
     private placeOf;
     private maker;
     private nodeObject;
@@ -7801,6 +8773,10 @@ type JourneyBookCounts = {
     unseenPages: number;
     unclaimedGifts: number;
 };
+type JourneyBookPage = {
+    page: number;
+    pages: number;
+};
 declare class JourneyBookApi {
     private readonly flash;
     private readonly client;
@@ -7810,6 +8786,11 @@ declare class JourneyBookApi {
     unclaimedGifts(): Promise<number>;
     open(factDefId?: number): Promise<void>;
     onChange(listener: (counts: JourneyBookCounts) => void): Unsubscribe;
+    onGiftReady(listener: (gifts: number) => void): Unsubscribe;
+    unseenPageIds(): Promise<number[]>;
+    showing(): Promise<JourneyBookPage | null>;
+    turnTo(page: number): Promise<boolean>;
+    close(): Promise<boolean>;
 }
 type ReferralCodeInfo = {
     code: string;
@@ -7824,6 +8805,10 @@ type ReferralPage = {
     status: number;
 };
 type ReferrerOutcome = "recorded" | "refused" | "failed";
+type ReferralRewards = {
+    treasures: boolean[];
+    opened: number;
+};
 declare class ReferralsApi {
     readonly [STATE_FIELDS]: readonly [
         "heardCode"
@@ -7831,6 +8816,8 @@ declare class ReferralsApi {
     private readonly flash;
     private readonly server;
     private heardCode;
+    private firstTreasure;
+    private otherTreasures;
     constructor(game: GameContext);
     get code(): string | null;
     fetchCode(timeoutMs?: number): Promise<ReferralCodeInfo>;
@@ -7842,6 +8829,14 @@ declare class ReferralsApi {
         pageSize?: number;
         timeoutMs?: number;
     }): Promise<ReferralPage>;
+    everyone(options?: {
+        pageSize?: number;
+        pages?: number;
+        timeoutMs?: number;
+    }): Promise<ReferredPlayer[]>;
+    rewards(): Promise<ReferralRewards>;
+    onRewards(listener: (rewards: ReferralRewards) => void): Unsubscribe;
+    private stat;
     onCode(listener: (code: ReferralCodeInfo | null) => void): Unsubscribe;
     onHasReferrer(listener: (hasReferrer: boolean) => void): Unsubscribe;
     onReferrerNamed(listener: (outcome: ReferrerOutcome) => void): Unsubscribe;
@@ -7865,6 +8860,10 @@ type ShortcutPress = {
     alt: boolean;
     consumed: boolean;
 };
+type ShortcutTyping = "empty" | "always";
+type BoundShortcut = Shortcut & {
+    whileTyping: ShortcutTyping;
+};
 declare class InputApi {
     private readonly flash;
     private readonly bindings;
@@ -7872,9 +8871,13 @@ declare class InputApi {
     private readonly held;
     constructor(game: GameContext);
     bind(shortcut: string, options?: ShortcutOptions): Promise<Shortcut>;
+    bindAnywhere(shortcut: string, options?: ShortcutOptions): Promise<Shortcut>;
+    private bindWith;
     unbind(shortcut: string): Promise<boolean>;
     get bound(): Shortcut[];
+    get shortcuts(): BoundShortcut[];
     onShortcut(listener: (press: ShortcutPress) => void): Unsubscribe;
+    onAnyKey(listener: (press: KeyPress) => void): Unsubscribe;
     private listen;
     private tell;
 }
@@ -7907,6 +8910,13 @@ declare class ViewApi {
     showOwnAvatar(show: boolean): Promise<boolean>;
     showOwnNameTag(show: boolean): Promise<boolean>;
     onChange(listener: (state: ViewState) => void): Unsubscribe;
+    private cleaned;
+    clean(options?: {
+        interface?: boolean;
+        ownAvatar?: boolean;
+        ownNameTag?: boolean;
+    }): Promise<ViewState>;
+    restore(): Promise<ViewState>;
     private set;
     private hide;
     private follow;
@@ -7915,6 +8925,14 @@ declare class ViewApi {
     private hookZoom;
     private changed;
 }
+type BodyMod = {
+    kind: "eyes" | "pattern";
+    defId: number;
+    name: string;
+    titleStrId: number;
+    membersOnly: boolean;
+    inUse: boolean;
+};
 type LookItem = {
     defId: number;
     color: number;
@@ -7974,6 +8992,10 @@ declare class LooksApi {
     plan(look: Look, options?: LookOptions): Promise<LookPlan>;
     putOn(look: Look, options?: LookOptions): Promise<LookResult>;
     onChange(listener: (change: LookChange) => void): () => void;
+    watch(listener: (look: Look) => void): () => void;
+    bodyMods(): Promise<BodyMod[]>;
+    wearBodyMod(kind: "eyes" | "pattern", defId: number): Promise<boolean>;
+    private bodyModsWorn;
     private player;
     private holding;
 }
@@ -8432,10 +9454,16 @@ type SdkPathOfSdk = {
 }[SdkArea];
 declare const NOT_FOR_PLUGINS: readonly [
     "avatar.view",
+    "avatar.viewOf",
+    "room.surfaces",
     "adventures.record",
     "content.replaceOnScreen",
     "content.load",
-    "realtime.join"
+    "realtime.join",
+    "realtime.stayIn",
+    "customRooms.prop",
+    "customRooms.object",
+    "customRooms.character"
 ];
 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>;
@@ -8493,18 +9521,33 @@ type PluginContext = {
     }): Promise<void>;
     confirm(message: string, options?: ConfirmOptions): Promise<boolean | null>;
     openUrl(url: string): Promise<void>;
+    openPanel(panelId: string, options?: {
+        game?: string;
+    }): Promise<void>;
+    closePanel(panelId: string, options?: {
+        game?: string;
+    }): Promise<void>;
     log(...values: unknown[]): void;
 };
-type PluginPhantom = Omit<RemoteSdk, "avatar" | "adventures" | "content" | "ui" | "realtime"> & {
+type PluginPhantom = Omit<RemoteSdk, "avatar" | "adventures" | "content" | "ui" | "realtime" | "customRooms" | "room"> & {
     readonly avatar: RemoteSdk["avatar"] & {
         view(): Promise<FlashHandle>;
     };
+    readonly room: RemoteSdk["room"] & {
+        surfaces(): Promise<RoomSurface[]>;
+    };
     readonly adventures: RemoteSdk["adventures"] & {
         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>>;
+        stayIn<Data = unknown, State extends RealtimeObject = RealtimeObject, Presence extends RealtimeObject = RealtimeObject>(spec: RealtimeChannelSpec, ready: (channel: RealtimeChannel<Data, State, Presence>) => void, options?: RealtimeStayOptions<Presence>): Promise<Unsubscribe>;
+    };
+    readonly customRooms: RemoteSdk["customRooms"] & {
+        prop(id: string, roomId?: string): CustomRoomPropHandle;
+        object(id: string, roomId?: string): CustomRoomObjectHandle;
+        character(id: string, roomId?: string): CustomRoomCharacterHandle;
     };
     readonly ui: UiApi;
     readonly recipes: PluginRecipes;