@phantomclient/plugin 0.1.0 → 0.1.1

package/dist/types/index.d.ts

@@ -40,6 +40,10 @@ declare const Achievements: PacketDefinition<{
     archived: boolean;
     achievements: AchievementEntry[];
 }>;
+type AdoptAPetCard = {
+    defId: number;
+    invId: number;
+};
 type RoomPet = {
     lBits: number;
     uBits: number;
@@ -117,6 +121,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;
@@ -151,6 +167,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;
@@ -159,6 +208,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;
@@ -211,8 +270,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;
@@ -227,6 +286,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;
@@ -372,6 +515,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;
@@ -388,6 +553,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;
@@ -428,6 +601,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;
@@ -475,15 +654,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;
@@ -502,6 +785,9 @@ declare const QuestGiveItem: PacketDefinition<{
 declare const QuestPlayerDead: PacketDefinition<{
     userId: number;
 }>;
+declare const QuestCrystals: PacketDefinition<{
+    crystals: number;
+}>;
 declare const QuestExited: PacketDefinition<{
     extra: string[];
 }>;
@@ -542,6 +828,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;
@@ -764,6 +1119,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;
 }
@@ -1037,7 +1398,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";
@@ -1404,6 +1765,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 {
@@ -1855,6 +2217,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>;
@@ -1960,7 +2323,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 = {
@@ -1970,6 +2333,7 @@ type KeyPress = {
     shift: boolean;
     alt: boolean;
     phase: "down" | "up";
+    consumed: boolean;
 };
 declare class FlashNotes<Value extends FlashData = FlashData> {
     private readonly bridge;
@@ -2092,6 +2456,9 @@ type PacketProblem = {
     error: Error;
     text: string;
 };
+type PacketWatchOptions = {
+    original?: boolean;
+};
 type MessageHook = (message: Message) => void | Promise<void>;
 declare class Side {
     private readonly channel;
@@ -2103,156 +2470,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 = {
@@ -2356,30 +2597,434 @@ 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 CustomRoomPicture = string | Uint8Array;
+type CustomRoomMotion = {
+    pulse?: {
+        seconds: number;
+        min?: number;
+    };
+    spin?: {
+        seconds: number;
+    };
+    bob?: {
+        seconds: number;
+        height: number;
+    };
 };
-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 CustomRoomFrames = {
+    count: number;
+    fps: number;
 };
-type AchievementType = {
-    type: number;
-    name: string;
+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 RealtimeAskReason = "timeout" | "gone" | "closed" | "no-handler" | "failed";
+declare class RealtimeAskError extends Error {
+    readonly reason: RealtimeAskReason;
+    readonly code: string;
+    constructor(reason: RealtimeAskReason, message: string);
+}
+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;
@@ -2397,6 +3042,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;
@@ -2411,17 +3064,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;
@@ -2492,6 +3149,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;
@@ -2500,9 +3198,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;
@@ -2513,6 +3213,7 @@ declare class AvatarApi {
     userId(): Promise<number>;
     view(): Promise<FlashHandle>;
     standing(): Promise<AvatarStanding | null>;
+    private standingOfView;
     placeAt(position: Point, options?: {
         instant?: boolean;
     }): Promise<void>;
@@ -2540,6 +3241,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>;
@@ -2556,9 +3258,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 = {
@@ -2814,6 +3560,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",
@@ -2823,7 +3646,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;
@@ -2849,6 +3703,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;
@@ -3005,6 +3890,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;
 }
@@ -3047,6 +4021,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";
@@ -3076,6 +4061,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;
@@ -3086,21 +4088,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>;
@@ -3113,11 +4124,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>;
@@ -3154,12 +4172,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>;
@@ -3185,7 +4207,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;
@@ -3241,6 +4274,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;
@@ -3257,9 +4292,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>;
@@ -3271,6 +4307,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;
 }
@@ -3338,9 +4380,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>;
@@ -3349,6 +4394,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;
@@ -3417,6 +4467,10 @@ type DenShopPurchase = {
     currency: DenShopCurrency;
     balance: number;
 };
+type DenShopOfferingEvent = DenShopContents & {
+    ownerUserName: string | null;
+    ok: boolean;
+};
 type DenShopPurchaseEvent = {
     status: number;
     ownerUserName: string;
@@ -3426,21 +4480,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;
@@ -3511,17 +4619,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>;
@@ -3532,6 +4737,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;
@@ -3570,6 +4776,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>;
@@ -3584,13 +4791,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;
@@ -3601,13 +4849,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;
@@ -3636,6 +4909,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>;
@@ -3862,6 +5140,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;
@@ -3909,6 +5188,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;
@@ -3947,6 +5230,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;
@@ -3954,13 +5249,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;
@@ -3979,6 +5278,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, }: {
@@ -3991,6 +5294,7 @@ declare class InventoryApi {
         diamond?: boolean;
     }): Promise<PurchaseResult>;
     recycle(...invIds: number[]): Promise<RecycleResult>;
+    private keepSlot;
     private keep;
     private apply;
 }
@@ -4007,6 +5311,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>;
@@ -4022,12 +5331,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>>;
@@ -4221,6 +5566,7 @@ type MinigameStatus = {
     fullRoomGame: boolean;
     roomName: string;
     pending: PendingMinigame | null;
+    roomEnvironment: number | null;
 };
 type PendingMinigame = {
     gameDefId: number;
@@ -4243,6 +5589,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;
@@ -4254,6 +5644,9 @@ declare class MinigamesApi {
         "requested",
         "session",
         "boards",
+        "joinAnswer",
+        "invite",
+        "serialsHeard",
         "ticTacToe",
         "connectFour",
         "rockPaperScissors",
@@ -4267,6 +5660,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;
@@ -4313,6 +5714,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;
@@ -4320,6 +5735,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;
@@ -4343,6 +5808,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>;
@@ -4461,14 +5927,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>;
@@ -4522,9 +6038,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[];
@@ -4566,10 +6140,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>;
@@ -4592,6 +6223,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>;
@@ -4653,15 +6297,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>;
@@ -4688,7 +6448,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;
@@ -4710,12 +6500,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",
@@ -4754,6 +6555,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;
@@ -4872,12 +6692,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;
@@ -4894,6 +6717,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: {
@@ -4957,6 +6781,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;
@@ -4989,9 +6832,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;
@@ -5006,6 +6851,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[]>;
@@ -5021,9 +6870,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>;
@@ -5036,6 +6891,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 = {
@@ -5084,6 +6951,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;
@@ -5141,6 +7023,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;
@@ -5152,6 +7035,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;
@@ -5163,6 +7047,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>;
@@ -5188,7 +7076,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: {
@@ -5317,6 +7211,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 [
@@ -5324,6 +7236,7 @@ declare class TradesApi {
     ];
     private readonly flash;
     private readonly server;
+    private readonly clientSide;
     private pending;
     constructor(game: GameContext);
     get offer(): TradeOffer | null;
@@ -5345,6 +7258,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;
@@ -5470,10 +7388,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: {
@@ -5597,6 +7522,7 @@ type UiTooltip = UiWidget & {
 type UiTooltipOptions = UiOptions & {
     text?: string;
     visible?: boolean;
+    target?: UiWidget | OverlayNode;
 };
 type UiProgress = UiWidget & {
     value(): number;
@@ -5665,10 +7591,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,
@@ -5687,6 +7617,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[]>;
@@ -5709,9 +7641,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;
@@ -5764,6 +7703,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;
@@ -5776,11 +7732,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>;
@@ -5801,7 +7769,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,
@@ -5811,11 +7781,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;
@@ -5836,6 +8236,7 @@ type Phantom = {
     readonly adventures: AdventuresApi;
     readonly minigames: MinigamesApi;
     readonly achievements: AchievementsApi;
+    readonly membership: MembershipApi;
     readonly currency: CurrencyApi;
     readonly dailyGift: DailyGiftApi;
     readonly sound: SoundApi;
@@ -5851,6 +8252,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;
@@ -6029,7 +8438,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]>;
 declare const FRAME_MEMBERS: {
@@ -6040,6 +8450,7 @@ declare const FRAME_MEMBERS: {
     readonly "recipes.chatShortcuts": "flash";
     readonly "recipes.customChatBox": "flash";
     readonly "recipes.chatHistoryPanel": "flash";
+    readonly "realtime.join": "sdk:realtime:act";
 };
 declare const SDK_PERMISSIONS: {
     readonly "avatar.position": "read";
@@ -6055,6 +8466,7 @@ declare const SDK_PERMISSIONS: {
     readonly "avatar.restoreColors": "act";
     readonly "avatar.pickColor": "act";
     readonly "avatar.paint": "act";
+    readonly "avatar.paintColor": "act";
     readonly "avatar.act": "act";
     readonly "avatar.list": "read";
     readonly "avatar.switchTo": "act";
@@ -6083,6 +8495,38 @@ declare const SDK_PERMISSIONS: {
     readonly "avatar.setAirborne": "act";
     readonly "avatar.walkPath": "act";
     readonly "avatar.walkThrough": "act";
+    readonly "avatar.create": "act";
+    readonly "avatar.buySlot": "act";
+    readonly "avatar.createFirst": "act";
+    readonly "avatar.chooseUsable": "act";
+    readonly "avatar.setPendingFlag": "act";
+    readonly "avatar.canPayForPhoto": "read";
+    readonly "avatar.payForPhoto": "act";
+    readonly "avatar.definitionsLoaded": "read";
+    readonly "avatar.loadDefinitions": "read";
+    readonly "avatar.data": "read";
+    readonly "avatar.inRoom": "read";
+    readonly "avatar.findInRoom": "read";
+    readonly "avatar.standingOf": "read";
+    readonly "avatar.defaultLook": "read";
+    readonly "avatar.buddyCardAvatar": "read";
+    readonly "avatar.adventurePlayers": "read";
+    readonly "avatar.offScreenPlayers": "read";
+    readonly "avatar.lastSeenAt": "read";
+    readonly "avatar.hosting": "read";
+    readonly "avatar.isHostingAdventure": "read";
+    readonly "avatar.suitsEnvironment": "read";
+    readonly "avatar.roomState": "read";
+    readonly "avatar.lastNameBar": "read";
+    readonly "avatar.onList": "read";
+    readonly "avatar.onRemoved": "read";
+    readonly "avatar.onAdded": "read";
+    readonly "avatar.onSlotBought": "read";
+    readonly "avatar.onFirstCreated": "read";
+    readonly "avatar.onNameBarChange": "read";
+    readonly "avatar.onUsableChosen": "read";
+    readonly "avatar.onPhotoChecked": "read";
+    readonly "avatar.onPhotoTaken": "read";
     readonly "player.login": "read";
     readonly "player.onLogin": "read";
     readonly "player.userName": "read";
@@ -6109,6 +8553,25 @@ declare const SDK_PERMISSIONS: {
     readonly "player.invisible": "read";
     readonly "player.setInvisible": "act";
     readonly "player.settingOn": "read";
+    readonly "player.onInvisibleChange": "read";
+    readonly "player.state": "read";
+    readonly "player.onChange": "read";
+    readonly "player.record": "read";
+    readonly "player.avatars": "read";
+    readonly "player.avatarOf": "read";
+    readonly "player.partyTimeLeft": "read";
+    readonly "player.onPartyHosting": "read";
+    readonly "player.onTradeListChange": "read";
+    readonly "player.clothing": "read";
+    readonly "player.denItemsForRoom": "read";
+    readonly "player.petsInDen": "read";
+    readonly "player.animalKindCount": "read";
+    readonly "player.animalDefaults": "read";
+    readonly "player.customAnimal": "read";
+    readonly "player.customAnimalsOf": "read";
+    readonly "player.animalOf": "read";
+    readonly "player.denRoomDefinitions": "read";
+    readonly "player.denRoomDefinition": "read";
     readonly "chat.recent": "read";
     readonly "chat.say": "act";
     readonly "chat.emote": "act";
@@ -6133,6 +8596,8 @@ declare const SDK_PERMISSIONS: {
     readonly "chat.showBalloon": "act";
     readonly "chat.log": "act";
     readonly "chat.clearLog": "act";
+    readonly "chat.lastAdminMessage": "read";
+    readonly "chat.lastModeration": "read";
     readonly "buddies.list": "read";
     readonly "buddies.online": "read";
     readonly "buddies.blocked": "read";
@@ -6158,6 +8623,14 @@ declare const SDK_PERMISSIONS: {
     readonly "buddies.showCard": "act";
     readonly "buddies.closeCard": "act";
     readonly "buddies.joinBuddyQuest": "act";
+    readonly "buddies.requests": "read";
+    readonly "buddies.onAddResult": "read";
+    readonly "buddies.onBlockChange": "read";
+    readonly "buddies.onList": "read";
+    readonly "buddies.clientList": "read";
+    readonly "buddies.clientBlocked": "read";
+    readonly "buddies.hasBlocked": "read";
+    readonly "buddies.cardTradeList": "read";
     readonly "ecards.inbox": "read";
     readonly "ecards.unread": "read";
     readonly "ecards.get": "read";
@@ -6185,6 +8658,11 @@ declare const SDK_PERMISSIONS: {
     readonly "ecards.closeInbox": "act";
     readonly "ecards.send": "act";
     readonly "ecards.discardGift": "act";
+    readonly "ecards.lastBuddyAnswer": "read";
+    readonly "ecards.onBuddyAnswer": "read";
+    readonly "ecards.onInbox": "read";
+    readonly "ecards.clientInbox": "read";
+    readonly "ecards.clientInboxLoaded": "read";
     readonly "playerWall.posts": "read";
     readonly "playerWall.check": "read";
     readonly "playerWall.privacyOf": "read";
@@ -6209,6 +8687,19 @@ declare const SDK_PERMISSIONS: {
     readonly "playerWall.setParameters": "act";
     readonly "playerWall.showPostAs": "act";
     readonly "playerWall.removeMasterpiece": "act";
+    readonly "playerWall.hasOpenedOwnWall": "read";
+    readonly "playerWall.hasCountedVisit": "read";
+    readonly "playerWall.likes": "read";
+    readonly "playerWall.onAccess": "read";
+    readonly "playerWall.onPrivacy": "read";
+    readonly "playerWall.onPrivacyChange": "read";
+    readonly "playerWall.onParametersChange": "read";
+    readonly "playerWall.onVisitCounted": "read";
+    readonly "playerWall.onLikes": "read";
+    readonly "playerWall.onLiked": "read";
+    readonly "playerWall.onServiceRequest": "read";
+    readonly "playerWall.requestPermissions": "act";
+    readonly "playerWall.like": "act";
     readonly "dailyGift.daysInCycle": "read";
     readonly "dailyGift.statId": "read";
     readonly "dailyGift.received": "read";
@@ -6254,6 +8745,9 @@ declare const SDK_PERMISSIONS: {
     readonly "feedback.close": "act";
     readonly "reports.report": "act";
     readonly "reports.reportContent": "act";
+    readonly "reports.onReportResult": "read";
+    readonly "reports.onContentReportResult": "read";
+    readonly "reports.onReportSent": "read";
     readonly "newspaper.definitions": "read";
     readonly "newspaper.dataOf": "read";
     readonly "newspaper.hasUnseenPages": "read";
@@ -6261,8 +8755,15 @@ declare const SDK_PERMISSIONS: {
     readonly "newspaper.onPageSeen": "read";
     readonly "newspaper.markSeen": "act";
     readonly "newspaper.open": "act";
+    readonly "newspaper.definition": "read";
     readonly "masterpieces.itemsOf": "read";
     readonly "masterpieces.creatorOf": "read";
+    readonly "masterpieces.likes": "read";
+    readonly "masterpieces.onItems": "read";
+    readonly "masterpieces.onCreator": "read";
+    readonly "masterpieces.onLikes": "read";
+    readonly "masterpieces.onLiked": "read";
+    readonly "masterpieces.like": "act";
     readonly "trades.offer": "read";
     readonly "trades.onOffer": "read";
     readonly "trades.onConfirmRequest": "read";
@@ -6282,6 +8783,10 @@ declare const SDK_PERMISSIONS: {
     readonly "trades.heldList": "read";
     readonly "trades.setBusy": "act";
     readonly "trades.onList": "read";
+    readonly "trades.onListChanged": "read";
+    readonly "trades.offerDraft": "read";
+    readonly "trades.counts": "read";
+    readonly "trades.listEntry": "read";
     readonly "inventory.items": "read";
     readonly "inventory.owned": "read";
     readonly "inventory.worn": "read";
@@ -6295,6 +8800,10 @@ declare const SDK_PERMISSIONS: {
     readonly "inventory.recycle": "act";
     readonly "inventory.wearableBy": "read";
     readonly "inventory.limits": "read";
+    readonly "inventory.avatarSlots": "read";
+    readonly "inventory.onAvatarSlot": "read";
+    readonly "inventory.latestPrize": "read";
+    readonly "inventory.onPrize": "read";
     readonly "shops.offering": "read";
     readonly "shops.definition": "read";
     readonly "shops.listType": "read";
@@ -6314,6 +8823,8 @@ declare const SDK_PERMISSIONS: {
     readonly "shops.isAvailable": "read";
     readonly "shops.onOpen": "read";
     readonly "shops.buyDiamondBundle": "act";
+    readonly "shops.onDiamondBundleBuy": "read";
+    readonly "shops.picture": "read";
     readonly "pets.list": "read";
     readonly "pets.active": "read";
     readonly "pets.activeName": "read";
@@ -6346,6 +8857,30 @@ declare const SDK_PERMISSIONS: {
     readonly "pets.nameEggPet": "act";
     readonly "pets.create": "act";
     readonly "pets.randomAppearance": "read";
+    readonly "pets.buy": "act";
+    readonly "pets.restyle": "act";
+    readonly "pets.adoptionChecklistOf": "read";
+    readonly "pets.adoptionCountOf": "read";
+    readonly "pets.adoptionCardDefs": "read";
+    readonly "pets.adoptionCardTotal": "read";
+    readonly "pets.hasAdoptionCards": "read";
+    readonly "pets.definitions": "read";
+    readonly "pets.unlockedKinds": "read";
+    readonly "pets.goesOnLandAndInOcean": "read";
+    readonly "pets.goesWith": "read";
+    readonly "pets.enviroTypeOf": "read";
+    readonly "pets.isGroundType": "read";
+    readonly "pets.kindOfBits": "read";
+    readonly "pets.listAsItems": "read";
+    readonly "pets.picture": "read";
+    readonly "pets.onCreated": "read";
+    readonly "pets.onEggNamed": "read";
+    readonly "pets.onMasteryBadge": "read";
+    readonly "pets.onRestyled": "read";
+    readonly "pets.onUnlocked": "read";
+    readonly "pets.onAdoptionChecklist": "read";
+    readonly "pets.onAdoptionCount": "read";
+    readonly "pets.onDefinitionsLoaded": "read";
     readonly "room.players.list": "read";
     readonly "room.players.count": "read";
     readonly "room.players.get": "read";
@@ -6358,6 +8893,7 @@ declare const SDK_PERMISSIONS: {
     readonly "room.current": "read";
     readonly "room.details": "read";
     readonly "room.layout": "read";
+    readonly "room.onLayout": "read";
     readonly "room.focusCamera": "act";
     readonly "room.stopWalking": "act";
     readonly "room.scene": "read";
@@ -6392,6 +8928,15 @@ declare const SDK_PERMISSIONS: {
     readonly "room.layers": "read";
     readonly "room.showAvatars": "act";
     readonly "room.reload": "act";
+    readonly "room.players.pathOf": "read";
+    readonly "room.onWorldItemTaken": "read";
+    readonly "room.joiningInvisibly": "read";
+    readonly "room.darkAreas": "read";
+    readonly "room.nearestEmptyCell": "read";
+    readonly "room.journeyBookItemsLeft": "read";
+    readonly "room.objectAt": "read";
+    readonly "room.setJamaaTime": "act";
+    readonly "room.setDenKickNotice": "act";
     readonly "dens.join": "act";
     readonly "dens.joinOwn": "act";
     readonly "dens.isOwnDen": "read";
@@ -6424,6 +8969,40 @@ declare const SDK_PERMISSIONS: {
     readonly "dens.ecoState": "read";
     readonly "dens.redeemEcoCredits": "act";
     readonly "dens.setEcoConsumer": "act";
+    readonly "dens.inOwnDen": "read";
+    readonly "dens.guests": "read";
+    readonly "dens.onGuestArrive": "read";
+    readonly "dens.onVisit": "read";
+    readonly "dens.onGuestLeave": "read";
+    readonly "dens.onOwnDen": "read";
+    readonly "dens.roomChange": "read";
+    readonly "dens.kickedAt": "read";
+    readonly "dens.lastPurchase": "read";
+    readonly "dens.onPurchase": "read";
+    readonly "dens.lastSale": "read";
+    readonly "dens.onSale": "read";
+    readonly "dens.emptiedAt": "read";
+    readonly "dens.onEmptied": "read";
+    readonly "dens.epicDens": "read";
+    readonly "dens.onEpicDens": "read";
+    readonly "dens.setPhantom": "act";
+    readonly "dens.onPhantom": "read";
+    readonly "dens.lastEcoState": "read";
+    readonly "dens.onEcoState": "read";
+    readonly "dens.lastEcoRedemption": "read";
+    readonly "dens.onEcoCreditsRedeemed": "read";
+    readonly "dens.ecoConsumers": "read";
+    readonly "dens.onEcoConsumers": "read";
+    readonly "dens.activeDenIdx": "read";
+    readonly "dens.onItemList": "read";
+    readonly "dens.serverState": "read";
+    readonly "dens.onState": "read";
+    readonly "dens.saveItems": "act";
+    readonly "dens.onSaved": "read";
+    readonly "dens.onSaving": "read";
+    readonly "dens.isChangePending": "read";
+    readonly "dens.openDenShopId": "read";
+    readonly "dens.heldDenShop": "read";
     readonly "denShop.offering": "read";
     readonly "denShop.onChange": "read";
     readonly "denShop.onBuy": "read";
@@ -6431,6 +9010,11 @@ declare const SDK_PERMISSIONS: {
     readonly "denShop.reprice": "act";
     readonly "denShop.unlist": "act";
     readonly "denShop.buy": "act";
+    readonly "denShop.onOffering": "read";
+    readonly "denShop.onSale": "read";
+    readonly "denShop.inDen": "read";
+    readonly "denShop.update": "act";
+    readonly "shops.knownShops": "read";
     readonly "world.serverNode": "read";
     readonly "world.shardId": "read";
     readonly "world.shards": "read";
@@ -6459,6 +9043,22 @@ declare const SDK_PERMISSIONS: {
     readonly "world.showParties": "act";
     readonly "world.onRoomList": "read";
     readonly "world.onRandomKey": "read";
+    readonly "world.rooms": "read";
+    readonly "world.randomKey": "read";
+    readonly "world.lastNodeHop": "read";
+    readonly "world.lastPartyJoin": "read";
+    readonly "world.hosting": "read";
+    readonly "world.onHostResult": "read";
+    readonly "world.onCustomParties": "read";
+    readonly "world.onShards": "read";
+    readonly "world.onHostingTimeLeft": "read";
+    readonly "world.partyDefinitions": "read";
+    readonly "world.canUseAvatarHere": "read";
+    readonly "world.partyMasterpieces": "read";
+    readonly "world.onPartyMasterpieces": "read";
+    readonly "world.onFirstFiveMinutesRoom": "read";
+    readonly "world.requestFirstFiveMinutesRoom": "act";
+    readonly "world.joinNamedRoom": "act";
     readonly "session.connected": "read";
     readonly "session.mode": "read";
     readonly "session.server": "read";
@@ -6468,6 +9068,13 @@ declare const SDK_PERMISSIONS: {
     readonly "session.disconnect": "act";
     readonly "session.requestList": "read";
     readonly "session.onList": "read";
+    readonly "session.inMinigame": "read";
+    readonly "session.settingsUserName": "read";
+    readonly "session.sendEmailActivation": "act";
+    readonly "session.onEmailActivation": "read";
+    readonly "session.onEmailActivationRequest": "read";
+    readonly "session.emailValidated": "read";
+    readonly "session.onEmailValidated": "read";
     readonly "assets.deployVersion": "read";
     readonly "assets.buildVersion": "read";
     readonly "assets.loadMedia": "read";
@@ -6583,6 +9190,89 @@ declare const SDK_PERMISSIONS: {
     readonly "adventures.onPlantAte": "read";
     readonly "adventures.onPlantEatRecoil": "read";
     readonly "adventures.canPlaySideScroll": "act";
+    readonly "adventures.experience": "read";
+    readonly "adventures.playerLevel": "read";
+    readonly "adventures.departedPlayers": "read";
+    readonly "adventures.defeatedPlayers": "read";
+    readonly "adventures.awards": "read";
+    readonly "adventures.givenItems": "read";
+    readonly "adventures.exitConfirmed": "read";
+    readonly "adventures.lastBundle": "read";
+    readonly "adventures.actorIconShowing": "read";
+    readonly "adventures.actorSeeking": "read";
+    readonly "adventures.disguise": "read";
+    readonly "adventures.seeds": "read";
+    readonly "adventures.plants": "read";
+    readonly "adventures.combatStats": "read";
+    readonly "adventures.volumeProgress": "read";
+    readonly "adventures.attackTarget": "read";
+    readonly "adventures.playerRoom": "read";
+    readonly "adventures.sideScrollPosition": "read";
+    readonly "adventures.actorTorch": "read";
+    readonly "adventures.playerTorch": "read";
+    readonly "adventures.music": "read";
+    readonly "adventures.cutscene": "read";
+    readonly "adventures.preloadedCutscenes": "read";
+    readonly "adventures.soundPacks": "read";
+    readonly "adventures.screenFaded": "read";
+    readonly "adventures.lastZap": "read";
+    readonly "adventures.lastLaunch": "read";
+    readonly "adventures.respawnsGranted": "read";
+    readonly "adventures.shaking": "read";
+    readonly "adventures.lastSound": "read";
+    readonly "adventures.pageViews": "read";
+    readonly "adventures.clientStatus": "read";
+    readonly "adventures.actorPathToPlayer": "read";
+    readonly "adventures.onActorSpawned": "read";
+    readonly "adventures.onActorMoved": "read";
+    readonly "adventures.onActorHealth": "read";
+    readonly "adventures.onActorDied": "read";
+    readonly "adventures.onActorRestored": "read";
+    readonly "adventures.onActorSwfState": "read";
+    readonly "adventures.onActorPath": "read";
+    readonly "adventures.onCommand": "read";
+    readonly "adventures.onVariable": "read";
+    readonly "adventures.onPickUpResult": "read";
+    readonly "adventures.onMovedItems": "read";
+    readonly "adventures.onCrystalCount": "read";
+    readonly "adventures.onSentOut": "read";
+    readonly "adventures.onLobbyWaiting": "read";
+    readonly "adventures.onLobbyLeft": "read";
+    readonly "adventures.onPlayerAttacked": "read";
+    readonly "adventures.onBeamZap": "read";
+    readonly "adventures.onPhantomZap": "read";
+    readonly "adventures.onThrow": "read";
+    readonly "adventures.onSwing": "read";
+    readonly "adventures.onRespawnGranted": "read";
+    readonly "adventures.onPlayerRoomChange": "read";
+    readonly "adventures.onSideScroll": "read";
+    readonly "adventures.onTorch": "read";
+    readonly "adventures.onCutscene": "read";
+    readonly "adventures.onCutscenePreload": "read";
+    readonly "adventures.onFade": "read";
+    readonly "adventures.onShake": "read";
+    readonly "adventures.onSound": "read";
+    readonly "adventures.onMusic": "read";
+    readonly "adventures.onSoundPack": "read";
+    readonly "adventures.onPageView": "read";
+    readonly "adventures.movedItems": "read";
+    readonly "adventures.reportHit": "act";
+    readonly "adventures.reportPlayerHit": "act";
+    readonly "adventures.reportAttackOnPlayer": "act";
+    readonly "adventures.reportActorPosition": "act";
+    readonly "adventures.requestActorSeek": "act";
+    readonly "adventures.untrigger": "act";
+    readonly "adventures.reportBeamZap": "act";
+    readonly "adventures.reportPhantomZap": "act";
+    readonly "adventures.reportDestructibleHit": "act";
+    readonly "adventures.reportPlantAte": "act";
+    readonly "adventures.reportThrow": "act";
+    readonly "adventures.reportSwing": "act";
+    readonly "adventures.finishCutscene": "act";
+    readonly "adventures.requestRespawn": "act";
+    readonly "adventures.finishMinigame": "act";
+    readonly "adventures.finishRoomMinigame": "act";
+    readonly "adventures.reportSideScroll": "act";
     readonly "minigames.current": "read";
     readonly "minigames.isPlaying": "read";
     readonly "minigames.play": "act";
@@ -6620,6 +9310,20 @@ declare const SDK_PERMISSIONS: {
     readonly "minigames.offerPvp": "act";
     readonly "minigames.joinOfferedPvp": "act";
     readonly "minigames.chat": "act";
+    readonly "minigames.onLeaderboard": "read";
+    readonly "minigames.clientLeaderboard": "read";
+    readonly "minigames.lastJoin": "read";
+    readonly "minigames.pvpInvite": "read";
+    readonly "minigames.serials": "read";
+    readonly "minigames.onGemSerial": "read";
+    readonly "minigames.onMasterySerial": "read";
+    readonly "minigames.onGemAward": "read";
+    readonly "minigames.onPetMasteryAward": "read";
+    readonly "minigames.onScore": "read";
+    readonly "minigames.quit": "act";
+    readonly "minigames.playerInfo": "read";
+    readonly "minigames.gameNameId": "read";
+    readonly "minigames.isMemberAccountType": "read";
     readonly "minigames.ticTacToe.board": "read";
     readonly "minigames.ticTacToe.opponent": "read";
     readonly "minigames.ticTacToe.myTurn": "read";
@@ -6671,6 +9375,16 @@ declare const SDK_PERMISSIONS: {
     readonly "achievements.readStats": "read";
     readonly "achievements.statBit": "read";
     readonly "achievements.statType": "read";
+    readonly "achievements.earn": "act";
+    readonly "achievements.onStats": "read";
+    readonly "achievements.definitionsByType": "read";
+    readonly "membership.real": "read";
+    readonly "membership.onChange": "read";
+    readonly "membership.shown": "read";
+    readonly "membership.showing": "read";
+    readonly "membership.onShowing": "read";
+    readonly "membership.show": "act";
+    readonly "membership.stopShowing": "act";
     readonly "currency.gems": "read";
     readonly "currency.tickets": "read";
     readonly "currency.diamonds": "read";
@@ -6689,6 +9403,8 @@ declare const SDK_PERMISSIONS: {
     readonly "currency.exchange": "act";
     readonly "currency.onExchange": "read";
     readonly "currency.onDonate": "read";
+    readonly "currency.diamondsLoaded": "read";
+    readonly "currency.diamondDefinitionId": "read";
     readonly "gui.tree": "read";
     readonly "gui.find": "read";
     readonly "gui.findAll": "read";
@@ -6762,6 +9478,9 @@ declare const SDK_PERMISSIONS: {
     readonly "screens.denSwitcherIndex": "read";
     readonly "screens.serverName": "read";
     readonly "ui.skin": "act";
+    readonly "ui.status": "read";
+    readonly "ui.ready": "read";
+    readonly "ui.readyTimeoutMs": "act";
     readonly "ui.theme": "read";
     readonly "ui.symbols": "read";
     readonly "ui.hasSymbol": "read";
@@ -6810,28 +9529,160 @@ declare const SDK_PERMISSIONS: {
     readonly "localization.languageId": "read";
     readonly "localization.onLanguageChange": "read";
     readonly "localization.onReady": "read";
+    readonly "localization.accountLanguage": "read";
+    readonly "localization.languageForLocale": "read";
+    readonly "localization.sortingLocale": "read";
+    readonly "localization.numberLocale": "read";
+    readonly "localization.countryCode": "read";
     readonly "content.available": "read";
     readonly "content.replacements": "read";
     readonly "content.onRequest": "read";
     readonly "content.replace": "act";
     readonly "content.restore": "act";
     readonly "community.available": "read";
-    readonly "community.status": "read";
-    readonly "community.onStatus": "read";
-    readonly "community.members": "read";
-    readonly "community.onMembers": "read";
-    readonly "community.onMessage": "read";
-    readonly "community.online": "read";
-    readonly "community.join": "act";
-    readonly "community.leave": "act";
-    readonly "community.say": "act";
+    readonly "community.hidden": "read";
+    readonly "community.onHidden": "read";
+    readonly "community.hide": "act";
+    readonly "community.unhide": "act";
     readonly "community.report": "act";
-    readonly "community.captureChat": "act";
-    readonly "community.invite": "act";
-    readonly "community.askToJoin": "act";
-    readonly "community.answer": "act";
-    readonly "community.onRequest": "read";
-    readonly "community.onAnswered": "read";
+    readonly "customRooms.available": "read";
+    readonly "customRooms.current": "read";
+    readonly "customRooms.onEnter": "read";
+    readonly "customRooms.onLeave": "read";
+    readonly "customRooms.onMove": "read";
+    readonly "customRooms.onChat": "read";
+    readonly "customRooms.onPropEnter": "read";
+    readonly "customRooms.onPropLeave": "read";
+    readonly "customRooms.onPropNear": "read";
+    readonly "customRooms.onPropClick": "read";
+    readonly "customRooms.shared": "read";
+    readonly "customRooms.define": "act";
+    readonly "customRooms.remove": "act";
+    readonly "customRooms.enter": "act";
+    readonly "customRooms.leave": "act";
+    readonly "realtime.available": "read";
+    readonly "realtime.status": "read";
+    readonly "realtime.onStatus": "read";
+    readonly "realtime.channels": "read";
+    readonly "realtime.members": "read";
+    readonly "realtime.state": "read";
+    readonly "realtime.presence": "read";
+    readonly "realtime.host": "read";
+    readonly "realtime.onMessage": "read";
+    readonly "realtime.onJoin": "read";
+    readonly "realtime.onLeave": "read";
+    readonly "realtime.onState": "read";
+    readonly "realtime.onPresence": "read";
+    readonly "realtime.onHost": "read";
+    readonly "realtime.onClose": "read";
+    readonly "realtime.open": "act";
+    readonly "realtime.leave": "act";
+    readonly "realtime.send": "act";
+    readonly "realtime.sendTo": "act";
+    readonly "realtime.onAsk": "read";
+    readonly "realtime.ask": "act";
+    readonly "realtime.answer": "act";
+    readonly "realtime.decline": "act";
+    readonly "realtime.setState": "act";
+    readonly "realtime.setPresence": "act";
+    readonly "realtime.giveHost": "act";
+    readonly "journeyBook.counts": "read";
+    readonly "journeyBook.unseenPages": "read";
+    readonly "journeyBook.unclaimedGifts": "read";
+    readonly "journeyBook.onChange": "read";
+    readonly "journeyBook.open": "act";
+    readonly "referrals.code": "read";
+    readonly "referrals.clientCode": "read";
+    readonly "referrals.fetchCode": "read";
+    readonly "referrals.hasReferrer": "read";
+    readonly "referrals.list": "read";
+    readonly "referrals.onCode": "read";
+    readonly "referrals.onHasReferrer": "read";
+    readonly "referrals.onReferrerNamed": "read";
+    readonly "referrals.onList": "read";
+    readonly "referrals.nameReferrer": "act";
+    readonly "avatar.noClip": "read";
+    readonly "avatar.onNoClip": "read";
+    readonly "input.bound": "read";
+    readonly "input.onShortcut": "read";
+    readonly "input.bind": "act";
+    readonly "input.unbind": "act";
+    readonly "view.state": "read";
+    readonly "view.zoom": "read";
+    readonly "view.zoomLimits": "read";
+    readonly "view.onChange": "read";
+    readonly "view.setZoom": "act";
+    readonly "view.resetZoom": "act";
+    readonly "view.showInterface": "act";
+    readonly "view.showOwnAvatar": "act";
+    readonly "view.showOwnNameTag": "act";
+    readonly "session.markActive": "act";
+    readonly "session.keepActive": "act";
+    readonly "session.stopKeepingActive": "act";
+    readonly "session.keepingActive": "read";
+    readonly "session.onIdleWarning": "read";
+    readonly "popups.skipAtLogin": "act";
+    readonly "popups.stopSkippingAtLogin": "act";
+    readonly "popups.skippingAtLogin": "read";
+    readonly "popups.onSkipped": "read";
+    readonly "gui.pinCurrency": "act";
+    readonly "gui.unpinCurrency": "act";
+    readonly "gui.currencyPinned": "read";
+    readonly "dens.placement": "read";
+    readonly "dailyGift.unwrap": "act";
+    readonly "dailyGift.onOpen": "read";
+    readonly "dailyGift.wheelOpen": "read";
+    readonly "dailyGift.spinWheel": "act";
+    readonly "dailyGift.onWheelOpen": "read";
+    readonly "buddies.whereabouts": "read";
+    readonly "buddies.whereaboutsOf": "read";
+    readonly "buddies.onWhereabouts": "read";
+    readonly "world.roomDefinitions": "read";
+    readonly "looks.current": "read";
+    readonly "looks.of": "read";
+    readonly "looks.plan": "read";
+    readonly "looks.onChange": "read";
+    readonly "looks.putOn": "act";
+    readonly "artStudio.isOpen": "read";
+    readonly "artStudio.current": "read";
+    readonly "artStudio.state": "read";
+    readonly "artStudio.palette": "read";
+    readonly "artStudio.picture": "read";
+    readonly "artStudio.painting": "read";
+    readonly "artStudio.planPainting": "read";
+    readonly "artStudio.onOpen": "read";
+    readonly "artStudio.onClose": "read";
+    readonly "artStudio.onStroke": "read";
+    readonly "artStudio.onToolChange": "read";
+    readonly "artStudio.onColorChange": "read";
+    readonly "artStudio.onClear": "read";
+    readonly "artStudio.onSubmit": "read";
+    readonly "artStudio.onSubmitted": "read";
+    readonly "artStudio.onMasterpieceBought": "read";
+    readonly "artStudio.onSaved": "read";
+    readonly "artStudio.onBrowse": "read";
+    readonly "artStudio.onPaintProgress": "read";
+    readonly "artStudio.onPaintDone": "read";
+    readonly "artStudio.open": "act";
+    readonly "artStudio.close": "act";
+    readonly "artStudio.setTool": "act";
+    readonly "artStudio.setBrushSize": "act";
+    readonly "artStudio.setColor": "act";
+    readonly "artStudio.stroke": "act";
+    readonly "artStudio.shape": "act";
+    readonly "artStudio.fill": "act";
+    readonly "artStudio.setCells": "act";
+    readonly "artStudio.clear": "act";
+    readonly "artStudio.undo": "act";
+    readonly "artStudio.paintImage": "act";
+    readonly "artStudio.startPainting": "act";
+    readonly "artStudio.stopPainting": "act";
+    readonly "artStudio.submit": "act";
+    readonly "artStudio.createMasterpiece": "act";
+    readonly "artStudio.openStorage": "act";
+    readonly "artStudio.print": "act";
+    readonly "artStudio.browse": "act";
+    readonly "artStudio.startColouring": "act";
 };
 declare function isEventPath(path: string): boolean;
 declare function isSdkPath(path: string): path is SdkPath;
@@ -8780,16 +11631,22 @@ declare const permissionsSchema: ZodDefault<ZodObject<{
         room: "room";
         currency: "currency";
         inventory: "inventory";
+        referrals: "referrals";
+        input: "input";
         gui: "gui";
         content: "content";
+        chat: "chat";
         world: "world";
         localization: "localization";
-        chat: "chat";
+        newspaper: "newspaper";
         popups: "popups";
+        artStudio: "artStudio";
         masterpieces: "masterpieces";
+        journeyBook: "journeyBook";
         session: "session";
-        newspaper: "newspaper";
         community: "community";
+        customRooms: "customRooms";
+        realtime: "realtime";
         ecards: "ecards";
         playerWall: "playerWall";
         trades: "trades";
@@ -8799,6 +11656,7 @@ declare const permissionsSchema: ZodDefault<ZodObject<{
         assets: "assets";
         adventures: "adventures";
         minigames: "minigames";
+        membership: "membership";
         dailyGift: "dailyGift";
         sound: "sound";
         feedback: "feedback";
@@ -8806,6 +11664,8 @@ declare const permissionsSchema: ZodDefault<ZodObject<{
         editor: "editor";
         screens: "screens";
         ui: "ui";
+        view: "view";
+        looks: "looks";
     }> & $partial, ZodEnum<{
         read: "read";
         act: "act";
@@ -8825,8 +11685,10 @@ type PluginPermissions = output<typeof permissionsSchema>;
 type Scope = SdkScope | "packets:watch" | "packets:send" | "packets:modify" | "flash" | "clipboard:write" | "notifications" | `network:${string}`;
 declare const SDK_AREAS: readonly [
     "player",
+    "membership",
     "reports",
     "avatar",
+    "looks",
     "room",
     "world",
     "session",
@@ -8838,6 +11700,7 @@ declare const SDK_AREAS: readonly [
     "ecards",
     "playerWall",
     "trades",
+    "referrals",
     "inventory",
     "shops",
     "pets",
@@ -8846,6 +11709,7 @@ declare const SDK_AREAS: readonly [
     "achievements",
     "adventures",
     "minigames",
+    "journeyBook",
     "gui",
     "editor",
     "popups",
@@ -8857,7 +11721,12 @@ declare const SDK_AREAS: readonly [
     "newspaper",
     "masterpieces",
     "content",
-    "community"
+    "customRooms",
+    "community",
+    "realtime",
+    "input",
+    "view",
+    "artStudio"
 ];
 type ScopeRisk = "low" | "medium" | "high" | "full";
 declare function scopesOf(permissions: PluginPermissions): Scope[];
@@ -9092,7 +11961,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>;
     };
@@ -9100,6 +11969,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;
@@ -9153,4 +12025,4 @@ type ActionResult = {
 type CommandView = {
     props: Record<string, unknown>;
 };
-export { DEV_MANIFEST_PATH, DEV_PORT, FRAME_MEMBERS, FRAME_PAGE, NOT_FOR_PLUGINS, PLUGIN_FLASH_IDS_PER_FRAME, PLUGIN_FLASH_IDS_START, PROTOCOL, PluginError, RUNTIME_SCRIPT, RUNTIME_STYLES, SDK_AREAS, SDK_PERMISSIONS, definePlugin, describeScope, isEventPath, isFrameMessage, isHostMessage, isSdkPath, pluginUrl, scopeOfPath, scopeRisk, scopesOf };
+export { DEV_MANIFEST_PATH, DEV_PORT, FRAME_MEMBERS, FRAME_PAGE, NOT_FOR_PLUGINS, PLUGIN_FLASH_IDS_PER_FRAME, PLUGIN_FLASH_IDS_START, PROTOCOL, PluginError, RUNTIME_SCRIPT, RUNTIME_STYLES, RealtimeAskError, SDK_AREAS, SDK_PERMISSIONS, definePlugin, describeScope, isEventPath, isFrameMessage, isHostMessage, isSdkPath, pluginUrl, scopeOfPath, scopeRisk, scopesOf };