import type { Balance, Entitlements, HelixCameraCapability, HelixCameraState, HelixEvent, HelixSession, HelixVoiceSettings, HelixWorldContext, RuntimeFidelityIntent, WorldToShellMessage } from '../protocol.js';
import { type DevShellAchievementProgress, type DevShellEarnedAchievement, type DevShellJoinAnswer, type DevShellJoinBody, type DevShellLogger, type DevShellPartyCode, type DevShellPartyInvite, type DevShellPartyMember, type DevShellPlatformAnswer, type DevShellPurchaseConfirm, type DevShellPurchaseFailureMode, type DevShellQueuesSeed, type DevShellRejoinAnswer, type DevShellRoomTicket, type DevShellRoomTypesSeed } from './simulator.js';
import { type DevShellIdentity, type DevShellProductsSeed, type DevShellState } from './state.js';
export { DEV_SHELL_ACHIEVEMENT_DEBOUNCE_MS, DEV_SHELL_CAPS, DEV_SHELL_LOG_PREFIX, DEV_SHELL_PARTY_CODE_TTL_MS, DEV_SHELL_PARTY_INVITE_TTL_MS, DEV_SHELL_PARTY_MAX_SIZE, DEV_SHELL_PARTY_PENDING_INVITES_MAX, DEV_SHELL_PURCHASE_FAILURE_MODES, DEV_SHELL_QUEUES_MAX, DEV_SHELL_QUEUE_ID_PATTERN, DEV_SHELL_REFUSED_METHODS, DEV_SHELL_ROOM_REFUSALS, DEV_SHELL_ROOM_TICKET_TTL_MS, DEV_SHELL_ROOM_TYPES_MAX, DEV_SHELL_ROOM_TYPE_NAME_PATTERN, DEV_SHELL_SIMULATED_METHODS, DevShellSimulator, } from './simulator.js';
export type { DevShellAchievementProgress, DevShellAnswer, DevShellEarnedAchievement, DevShellJoinAnswer, DevShellJoinBody, DevShellLogger, DevShellParty, DevShellPartyCode, DevShellPartyInvite, DevShellPartyMember, DevShellPlatformAnswer, DevShellPurchaseConfirm, DevShellPurchaseFailureMode, DevShellQueueSeed, DevShellQueuesSeed, DevShellRejoinAnswer, DevShellRoomRefusalBody, DevShellRoomRefusalCode, DevShellRoomTicket, DevShellRoomTypeSeed, DevShellRoomTypesSeed, } from './simulator.js';
export { DEV_SHELL_CRITERIA_FIELD_PATTERN, DEV_SHELL_CRITERIA_KEY_TEMPLATES, DEV_SHELL_CRITERIA_METRICS, DEV_SHELL_CRITERIA_OPS, DEV_SHELL_CRITERIA_SIGNALS, devShellCriteriaSatisfied, formatDevShellCriteria, measureDevShellCriteria, } from './criteria.js';
export type { DevShellAchievementCriteria, DevShellCriteriaEvidence, DevShellCriteriaKeyTemplate, DevShellCriteriaMetric, DevShellCriteriaOp, DevShellCriteriaSignal, } from './criteria.js';
export { DEV_SHELL_DEFAULT_IDENTITY, DEV_SHELL_DEFAULT_WALLET, DEV_SHELL_STATE_VERSION, cloneDevShellState, createDevShellState, devShellProductRef, normalizeDevShellState, } from './state.js';
export type { DevShellAchievement, DevShellBoard, DevShellDocument, DevShellIdentity, DevShellProduct, DevShellProductsSeed, DevShellPurchaseRecord, DevShellState, } from './state.js';
export { checkDevShellRead, checkDevShellWrite, playerSaveKey } from './keys.js';
export type { DevShellKeyVerdict, DevShellWriteRule } from './keys.js';
/** The world frame's window — anything that can receive a postMessage. */
export type DevShellPostTarget = {
    postMessage(message: unknown, targetOrigin: string): void;
};
/** An <iframe> whose contentWindow is the world. Resolved lazily, so the frame may still be loading. */
export type DevShellFrameLike = {
    contentWindow: DevShellPostTarget | null;
};
/** Where the shell hears the world. The host page's `window` in the browser; a fake bus in tests. */
export type DevShellHostWindow = {
    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
};
export type DevShellOptions = {
    /** The world iframe (or its contentWindow) this shell answers. */
    worldWindow: DevShellPostTarget | DevShellFrameLike;
    /** The origin the world bundle is served from. Every inbound message is checked against it; '*' accepts any. */
    worldOrigin: string;
    /** Defaults to the ambient `window`. Injectable so a jsdom spec can wire both ends in one page. */
    hostWindow?: DevShellHostWindow;
    /** The world identity announced in helix:init. */
    world?: HelixWorldContext;
    /** The simulated player. Used only when no `state` is supplied — a loaded state carries its own identity. */
    user?: Partial<DevShellIdentity>;
    /** Session scopes to announce. Default ['auth.profile'] — camera.capture is absent, matching the refusal. */
    scopes?: string[];
    /** Previously persisted state. Omit for a fresh player. */
    state?: DevShellState;
    /** Called with a serializable copy after every mutation. The embedder persists it; this module does no I/O. */
    onStateChange?: (state: DevShellState) => void;
    /** Product catalog seed (the CLI's `.helix/dev-products.json`). */
    products?: DevShellProductsSeed;
    /** The world's declared room types (manifest `multiplayer.roomTypes`) — drives the simulated join API. */
    roomTypes?: DevShellRoomTypesSeed;
    /** The world's declared matchmaking queues (manifest `matchmaking.queues`) — drives the simulated queue routes. */
    queues?: DevShellQueuesSeed;
    /** Mirror the world's console into the host frame (helix:init `debug`). */
    debug?: boolean;
    /** Versioned presentation intent, matching the production shell handshake. */
    runtimeFidelity?: RuntimeFidelityIntent;
    /** Where simulated-response lines go. Default console. */
    log?: DevShellLogger;
    /** Every world→shell message, after the origin check — for the page's own UI (notifications, prompts). */
    onWorldMessage?: (message: WorldToShellMessage) => void;
    /** A simulated unlock happened — host-page feedback (toast). Worlds observe it only by re-polling. */
    onAchievementEarned?: (achievement: DevShellEarnedAchievement) => void;
    /** Criteria re-evaluation delay after a write/settle. Default 3 s (production's debounce); 0 = sync. */
    achievementDebounceMs?: number;
    /**
     * The real shell raises a confirm dialog before settling a purchase; provide this to simulate it.
     * Resolve true to settle (injected failures still apply), false to answer `Cancelled` with nothing
     * recorded — so a retried attempt confirms again, as production's cancel-before-charge does. Omitted,
     * purchases settle immediately (the pre-dialog behavior; what every headless spec uses). The SDK gives
     * this request its long human-in-the-loop timeout, so the dialog may sit open while a human decides.
     */
    confirmPurchase?: (request: DevShellPurchaseConfirm) => Promise<boolean>;
};
export type DevShellHandle = {
    /** Always 'simulated'. Never call this mode "test": Roblox's test mode costs real money. */
    readonly mode: 'simulated';
    readonly world: HelixWorldContext;
    /** True once the world's helix:ready has been answered with helix:init. */
    isConnected(): boolean;
    getSession(): HelixSession;
    /** A serializable copy of the whole simulated player — what the embedder persists. */
    getState(): DevShellState;
    /** Swap the state in place (the `--reset` seam). Does NOT call onStateChange — the caller already knows. */
    setState(state: DevShellState): void;
    setProducts(products: DevShellProductsSeed | undefined): void;
    grantAllEntitlements(): void;
    grantEntitlement(ref: string): void;
    removeEntitlement(ref: string): void;
    getEntitlementsSnapshot(): Entitlements;
    setPurchasesAlwaysFail(mode: DevShellPurchaseFailureMode | 'off'): void;
    /** The menu button: off → InsufficientFunds → PriceChanged → Pending → off. Returns the new mode. */
    cyclePurchasesAlwaysFail(): DevShellPurchaseFailureMode | 'off';
    purchasesAlwaysFail(): DevShellPurchaseFailureMode | 'off';
    resetPlayerDocument(): void;
    setForceSaveFailure(on: boolean): void;
    exhaustConsumeFence(): void;
    setWallet(wallet: Partial<Balance>): void;
    /** Award by key — the room/platform lanes' stand-in. False when the key is not in the local registry. */
    awardAchievement(key: string): boolean;
    /** Clear earned[] for re-testing. Local-only convenience — production never revokes. */
    resetAchievements(): void;
    /** Accumulate playtime evidence. The `helix dev` page ticks this every 15 s while open. */
    addPlaytime(seconds: number): void;
    /** Bump an analytics event count — real events never reach a shell, so this is the only local writer. */
    bumpAnalyticsEvent(eventName: string, count?: number): void;
    /** Write one persistent playerVar into the mp:player:{userId} envelope, as a room flush would. */
    setMpPlayerVar(field: string, value: number): void;
    /** Measured-vs-target for every registered achievement — the menu's progress print. */
    getAchievementsProgress(): DevShellAchievementProgress[];
    /** The room's leaderboard submit, by hand — declared boards a world only reads stay empty without it. */
    seedLeaderboardScore(board: string, score: number, opts?: {
        subject?: string;
        displayName?: string;
        order?: 'asc' | 'desc';
    }): void;
    /** The server's hand on the data store: write ANY key (world-global, mp:world:*, reserved namespaces). */
    seedDocument(key: string, value: unknown): void;
    setRoomTypes(roomTypes: DevShellRoomTypesSeed | undefined): void;
    /** What `POST …/join` would answer for this body: none / `{}`, `{ roomType }`, or `{ ticket }`. */
    simulateRoomJoin(body?: DevShellJoinBody): DevShellJoinAnswer;
    /** The `openRoom` effect, by hand: a ticket to a ticketed type. Null when the type is not declared ticketed. */
    issueRoomTicket(roomType: string, opts?: {
        instanceId?: string;
        ttlMs?: number;
    }): DevShellRoomTicket | null;
    /** What `POST …/room-instances/:instanceId/rejoin` would answer (410 once the instance has closed). */
    rejoinRoomInstance(instanceId: string): DevShellRejoinAnswer;
    /** The ticketed room disposing. Idempotent; false when no such instance exists. */
    closeRoomInstance(instanceId: string): boolean;
    setQueues(queues: DevShellQueuesSeed | undefined): void;
    /**
     * What a v1 matchmaking / party route would answer: `{ status, body }`, with the backend's real
     * `{ statusCode, code, message }` refusal bodies. E.g. `('POST', '/instant-worlds/w/queues/duel/tickets')`,
     * `('GET', '/instant-worlds/w/queues/tickets/current')`, `('GET', '/parties/current')`.
     */
    simulatePlatformRequest(method: string, path: string, body?: unknown): DevShellPlatformAnswer;
    /** The matcher, by hand: the waiting ticket's match forms and a room ticket is issued. Null when nothing is waiting. */
    formMatch(opts?: {
        ttlMs?: number;
    }): DevShellRoomTicket | null;
    /** The platform ends the waiting ticket (`timeout`, `member-absent`, `replaced`, …). False when nothing is waiting. */
    endQueueTicket(reason: string): boolean;
    /** A party member holds a standing match (null clears it): enqueue is refused with `already-matched`, naming them. */
    setPartyMemberMatch(userId: string | null): void;
    /** Another player invites the simulated player to their party. */
    receivePartyInvite(from?: Partial<DevShellPartyMember>, opts?: {
        ttlMs?: number;
    }): DevShellPartyInvite;
    /** The player an invite was sent to accepts it. False when there is no such pending invite. */
    acceptPartyInvite(inviteId: string, displayName?: string): boolean;
    /** Another player's party has a join code: returns it, to try `POST /parties/join` with. */
    openPartyCode(host?: Partial<DevShellPartyMember>, opts?: {
        ttlMs?: number;
    }): DevShellPartyCode;
    /** Another player joins the simulated player's party with its code. False when the code is not live. */
    usePartyCode(code: string, member?: Partial<DevShellPartyMember>): boolean;
    /** Push helix:session — false simulates a sign-out (the world's onAuthChanged fires with null). */
    setSignedIn(signedIn: boolean): void;
    sendVoiceSettings(settings: HelixVoiceSettings): void;
    /**
     * Push helix:camera-state — the native avatar camera, as HELIX OS would drive it. The
     * world's reported capability is echoed back in it (the real shell does the same), so a
     * runtime that reported `video: false` sees that reflected instead of two views drifting.
     * There is no simulated RIG behind it: this moves the state, and the world renders it.
     */
    sendCameraState(state: HelixCameraState): void;
    /** The capability the world last reported via camera.reportCapability (all-false until it does). */
    getCameraCapability(): HelixCameraCapability;
    /**
     * Push helix:leave — the deliberate-exit path (consented room close, voice leave). Like the real shell's,
     * it ends the world: `Helix.hasLeft()` turns true, `Helix.onLeave` subscribers run, and room joins reject
     * `left`. The real shell then destroys the frame; here the frame stays, so reload it to enter again.
     */
    sendLeave(): void;
    pushEvent(event: HelixEvent, data?: unknown): void;
    dispose(): void;
};
/**
 * The simulated session token. Deliberately NOT a JWT and obviously fake, because the SDK surfaces that
 * carry no shell guard (presence.*, analytics.track, avatar.getEquipped, the loadout fallbacks) fetch the
 * platform API directly the moment a session token exists. They resolve their base through
 * multiplayer.resolveApiBase(token) = configure() ?? the shell's helix:init apiBaseUrl ?? the token's
 * `iss` claim — so a non-JWT token plus a null apiBaseUrl below resolves to NO api base, and every one
 * of those calls returns its neutral value without a fetch ever leaving the page.
 */
export declare const DEV_SHELL_SESSION_TOKEN = "helix-dev-simulated";
/**
 * Start a simulated HELIX shell around a world frame. The world must be IFRAMED — the SDK only performs
 * the handshake when `window.parent !== window` — and helix:ready is answered immediately, because an
 * unanswered handshake costs every boot the SDK's full 8 s INIT_TIMEOUT_MS.
 */
export declare function createDevShell(options: DevShellOptions): DevShellHandle;
/** A fresh, empty state for a given identity — the `--fresh` / `--reset` seed. */
export declare function createFreshDevShellState(identity?: Partial<DevShellIdentity>): DevShellState;