@energy8platform/shell 0.2.0

package/dist/pixi.d.ts

@@ -0,0 +1,682 @@
+import { Container, Application } from 'pixi.js';
+
+/**
+ * Minimal typed event emitter — internal utility for platform-core.
+ *
+ * Supports `void` event types — events that carry no data can be emitted
+ * without arguments: `emitter.emit('eventName')`.
+ *
+ * Mirrors the EventEmitter shipped from game-engine's core, copied here
+ * so platform-core has no upward dependency on game-engine.
+ */
+declare class EventEmitter<TEvents extends {}> {
+    private listeners;
+    on<K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void): this;
+    once<K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void): this;
+    off<K extends keyof TEvents>(event: K, handler: (data: TEvents[K]) => void): this;
+    emit<K extends keyof TEvents>(...args: TEvents[K] extends void ? [event: K] : [event: K, data: TEvents[K]]): void;
+    removeAllListeners(event?: keyof TEvents): this;
+}
+
+type ShellMode = 'base' | 'freeSpins' | 'replay';
+interface CurrencyConfig {
+    symbol: string;
+    position: 'left' | 'right';
+    /** Maximum fraction digits (default 2). Win / total-win readouts are rounded to this precision;
+     *  balance / bet / prices stay fixed at `minDecimals`. */
+    maxDecimals?: number;
+    /** Minimum fraction digits (defaults to `maxDecimals`). For win / total-win, trailing zeros are
+     *  trimmed down to this many places so small wins keep their significant digits (e.g. 0.0673)
+     *  while round amounts stay compact (e.g. 0.30). Everything else is shown at exactly this many. */
+    minDecimals?: number;
+    separator?: {
+        thousands?: string;
+        decimal?: string;
+    };
+}
+interface BonusOption$1 {
+    id: string;
+    /** 'bonus' buys into a bonus round, 'feature' toggles a base-game modifier (e.g. Ante).
+     *  Drives the card/button label and accent. Defaults to 'bonus'. */
+    type?: 'feature' | 'bonus';
+    title: string;
+    description: string;
+    /** Transparent art image shown at the top of the card (no background plate). */
+    thumbnail?: string;
+    volatility?: 1 | 2 | 3 | 4 | 5;
+    /** Card price = priceMultiplier × current bet, rendered in the shell currency. */
+    priceMultiplier: number;
+    /** Per-option accent override. Falls back to the type default (bonus → purple, feature → gold). */
+    accentColor?: string;
+    /** Override the card UI. Return the card's inner content; the shell keeps the grid wrapper,
+     *  accent vars and live re-pricing, and runs the normal buy flow when you call `ctx.select()`.
+     *  Core uses `unknown`; each renderer re-exports a typed alias (ui/html → HTMLElement,
+     *  ui/pixi → Container). */
+    custom?: (ctx: BonusCardContext) => unknown;
+}
+/** Context passed to a `BonusOption.custom` renderer. Render the card however you like and wire
+ *  your own control to `select()` — the buy/confirm flow stays internal to the shell. */
+interface BonusCardContext {
+    bonus: BonusOption$1;
+    /** Current bet. */
+    bet: number;
+    /** Card price = `bonus.priceMultiplier × bet`. */
+    price: number;
+    /** `price` formatted in the shell currency. */
+    priceText: string;
+    /** True when the option can't be bought right now (unaffordable / busy / buy-bonus disabled);
+     *  reflect it in your UI. `select()` is a no-op while disabled. */
+    disabled: boolean;
+    /** Card accent (per-option override or the type default); also set as the `--card-acc` CSS var. */
+    accent: string;
+    /** Proceed through the shell's normal flow: opens the confirm modal, then emits `buyBonusSelect`
+     *  / activates the feature. No-op while `disabled`. */
+    select: () => void;
+}
+interface ThemeConfig {
+    /** Palette scheme: 'dark' (default) for dark games, 'light' for light backgrounds. */
+    scheme?: 'dark' | 'light';
+    /** Brand accent — active states, the SPIN hover glow, and the BUY BONUS button.
+     *  (Per-bonus card accents are set on each `BonusOption.accentColor`.) */
+    accent?: string;
+}
+/** One paytable entry: a symbol (text/image) and its win tiers, rendered "<count> x<multiplier>". */
+interface PaytableRow {
+    symbol: {
+        text?: string;
+        image?: string;
+    };
+    wins: Array<{
+        count?: string;
+        multiplier: number;
+    }>;
+}
+/** One payline over a cols×rows grid: the row index (0 = top) the line takes in each column. */
+interface PaylineDef {
+    /** length must equal grid.cols; each value in 0..rows-1 */
+    pattern: number[];
+    label?: string;
+}
+/** A single grid cell, 0-based, row 0 = top. */
+type CellRef = [col: number, row: number];
+/** A named winning shape: an arbitrary set of grid cells (not one-per-column like a payline),
+ *  shown as a grid illustration with its name and optional description. */
+interface ShapeDef {
+    /** The lit cells, in any pattern. */
+    cells: CellRef[];
+    name: string;
+    description?: string;
+}
+/** How a game pays — drives the GameInfo win-section illustration. One section = one kind.
+ *  `example`/`winExample`/`loseExample` are optional; omit them for an auto-drawn illustration
+ *  sized to `grid`. */
+type WinSection = {
+    type: 'wins';
+    title?: string;
+    order?: number;
+    grid: {
+        cols: number;
+        rows: number;
+    };
+    /** Optional prose shown alongside the illustration. */
+    description?: string;
+} & ({
+    kind: 'classic';
+    lines: Array<number[] | PaylineDef>;
+} | {
+    kind: 'cluster';
+    minCount: number;
+    example?: CellRef[];
+} | {
+    kind: 'anywhere';
+    minCount: number;
+    example?: CellRef[];
+} | {
+    kind: 'ways';
+    winExample?: CellRef[];
+    loseExample?: CellRef[];
+} | {
+    kind: 'shapes';
+    shapes: ShapeDef[];
+});
+/** A playable mode / bonus-buy option, shown for comparison (informational only). */
+interface GameMode {
+    title: string;
+    price?: string;
+    rtp?: number;
+    maxWin?: string;
+    description?: string;
+}
+/** A preset game-info section. `order` overrides placement; by default `modes` comes
+ *  first, `controls` second, and the rest follow in declaration order. */
+type GameInfoSection$1 = {
+    type: 'modes';
+    title?: string;
+    order?: number;
+    modes: GameMode[];
+} | {
+    type: 'controls';
+    title?: string;
+    order?: number;
+} | {
+    type: 'hotkeys';
+    title?: string;
+    order?: number;
+} | {
+    type: 'paytable';
+    title?: string;
+    order?: number;
+    rows: PaytableRow[];
+} | WinSection | {
+    type: 'custom';
+    title?: string;
+    order?: number;
+    node?: unknown;
+    html?: string;
+};
+interface GameInfoContent {
+    sections?: GameInfoSection$1[];
+}
+/** Autoplay limits. Presence of this object (vs `null`) is what enables autoplay. */
+interface AutoplayConfig {
+    /** Maximum selectable spin count in the autoplay picker. Caps the built-in presets and
+     *  drops the unlimited (∞) choice; if it isn't already a preset it becomes the top choice.
+     *  Omit for the default presets (including ∞). */
+    maxCount?: number;
+}
+interface ShellFeatures {
+    turbo: 0 | 1 | 2 | 3;
+    /** Master keyboard-shortcut switch. Defaults to `true`; set `false` to disable ALL hotkeys
+     *  (overrides `spacebar` and any future hotkey). */
+    hotkeys?: boolean;
+    /** Spacebar starts a spin in base mode. Defaults to `true`; set `false` to disable the
+     *  keyboard shortcut (e.g. jurisdictions that forbid quick-spin keys). */
+    spacebar?: boolean;
+    /** Autoplay: `null` (or omitted) disables it; an object enables it (optionally with limits). */
+    autoplay?: AutoplayConfig | null;
+    buyBonus: BonusOption$1[] | false;
+}
+interface AutoplayOptions {
+    active: boolean;
+    remaining: number;
+}
+interface FreeSpinsState {
+    /** Spin index for the `current / total` counter. Set to `null` (or omit) to instead show just
+     *  `total` as a single number — drive a countdown by decrementing `total` each spin. */
+    current?: number | null;
+    total: number;
+    totalWin: number;
+}
+/** One footer button of a generic modal. Clicking it runs `on` (if any), then closes the modal. */
+interface ModalAction {
+    title: string;
+    /** Button fill colour (any CSS colour). Omit for a neutral/secondary button. */
+    color?: string;
+    on?: () => void;
+}
+/** Options for `shell.openReplay()` — a non-dismissable replay summary modal.
+ *  `bonusId` is matched against `features.buyBonus` to label the mode and read the cost
+ *  multiplier. There is no ✕ and the backdrop never closes it; the only action is START
+ *  REPLAY, which closes the modal, runs `onReplay`, then reopens it. */
+interface ReplayModalOptions {
+    bonusId: string;
+    /** Base bet the replay was recorded at. */
+    bet: number;
+    payoutMultiplier: number;
+    /** Runs after the modal closes; the modal reopens once it resolves (immediately for sync). */
+    onReplay: () => void | Promise<void>;
+}
+/** Options for `shell.openModal()` — a generic, externally-triggered card modal. */
+interface ModalOptions {
+    /** Show the ✕ in the overlay's top-right corner. */
+    availableClose: boolean;
+    title: string;
+    body: string;
+    /** Footer buttons; each closes the modal (after running its `on`). */
+    actions?: ModalAction[];
+    /** Backdrop blur in px (defaults to the shell's standard blur). */
+    blurLevel?: number;
+    /** Optional keyboard handler — called by the shell keyboard controller while this modal is
+     *  open. Return true to consume the key (prevents bar actions + Escape close); false to let
+     *  the controller handle it (Escape → closeModal). */
+    onKey?: (e: KeyboardEvent) => boolean;
+}
+interface ShellConfig {
+    theme?: ThemeConfig;
+    gameInfo: GameInfoContent;
+    language: string;
+    /** Game version shown in the game-info footer (e.g. '1.2.0'). Defaults to '1.0.0'. The footer
+     *  stamp is `${version}.${engineVersionWithoutDots}` — e.g. game 1.0.0 on engine 0.24.6 → '1.0.0.0246'. */
+    version?: string;
+    /** When true, all built-in shell text is shown in the social-casino vocabulary (derived from
+     *  English via word-swap rules), regardless of `language`. Game-supplied content is untouched. */
+    isSocial?: boolean;
+    currency: CurrencyConfig;
+    availableBets: number[];
+    defaultBet: number;
+    currentBet: number | null;
+    balance: number;
+    win: number;
+    mode: ShellMode;
+    /** Mark this shell as a read-only historical-round replay. A replay never shows the player's
+     *  balance (there's no live wallet), even while its free-spins phase runs in `freeSpins` mode.
+     *  Defaults to `mode === 'replay'`; set explicitly when a replay starts in another mode. */
+    replay?: boolean;
+    features: ShellFeatures;
+    /** Override the BUY BONUS bar button's action: when set, tapping it calls this instead of
+     *  opening the built-in buy-bonus overlay (e.g. the game shows its own bonus UI). The button
+     *  is shown whenever this OR `features.buyBonus` is set. */
+    onBonusBuy?: () => void;
+}
+/** ShellConfig after the controller applies defaults (version, isSocial, replay, theme). No mount. */
+type ResolvedShellConfig = Required<Pick<ShellConfig, 'language' | 'currency' | 'availableBets' | 'defaultBet' | 'balance' | 'win' | 'mode' | 'features' | 'gameInfo' | 'version' | 'isSocial' | 'replay'>> & Pick<ShellConfig, 'currentBet' | 'theme' | 'onBonusBuy'>;
+interface ShellState {
+    mode: ShellMode;
+    /** Sticky replay marker — true for a historical-round replay, regardless of the current
+     *  `mode`. Set once (from config or when `mode` becomes 'replay') and never cleared, since a
+     *  shell instance is either a live game or a replay viewer for its whole lifetime. */
+    replay: boolean;
+    balance: number;
+    win: number;
+    bet: number;
+    availableBets: number[];
+    busy: boolean;
+    autoplay: AutoplayOptions;
+    turbo: number;
+    buyBonusEnabled: boolean;
+    freeSpins: FreeSpinsState;
+    /** The currently activated `feature` option (e.g. Ante), or null. Drives the
+     *  effective-bet readout tint and the BUY BONUS → DISABLE toggle on the bar. */
+    activeFeature: BonusOption$1 | null;
+}
+interface ShellEvents {
+    spin: void;
+    betChange: number;
+    autoplayStart: AutoplayOptions;
+    autoplayStop: void;
+    turboChange: number;
+    buyBonusSelect: {
+        id: string;
+    };
+    featureActivate: {
+        id: string;
+    };
+    featureDeactivate: {
+        id: string;
+    };
+    menuOpen: void;
+    settingsOpen: void;
+    infoOpen: void;
+    settingChange: {
+        key: string;
+        value: unknown;
+    };
+}
+
+declare const DEFAULT_ACCENT = "#8b5cf6";
+/** Resolved colour tokens for the shell — scheme palette + the scheme-independent
+ *  "plaque" language shared by the control bar and overlays, plus the game-overridable accent. */
+interface ShellTokens {
+    fg: string;
+    muted: string;
+    icon: string;
+    iconActive: string;
+    surface: string;
+    hairline: string;
+    veil: string;
+    veilStrong: string;
+    track: string;
+    soft: string;
+    spin: string;
+    spinFg: string;
+    plaqueDark: string;
+    plaqueGlass: string;
+    plaqueGlassHover: string;
+    plaqueSolid: string;
+    plaqueLine: string;
+    plaqueLabel: string;
+    bar: string;
+    btn: string;
+    btnInk: string;
+    accent: string;
+    backdrop: string;
+    white: string;
+    winOk: string;
+    winNo: string;
+}
+declare const SCHEMES: readonly ["dark", "light"];
+declare function resolveTheme(theme?: ThemeConfig): ShellTokens;
+
+type ShellLayoutMode = 'wide' | 'mobile';
+/** The view side the controller drives. A renderer holds its own mount target (DOM element /
+ *  Pixi app) and translates state → pixels; it never owns logic. */
+interface ShellRenderer {
+    /** Bind to the brain. Called once during createShell, before the first renderBar. */
+    mount(host: ShellHost): void;
+    /** (Re)build the bottom bar from host.state. MUST cancel any in-flight money count-up first. */
+    renderBar(): void;
+    /** Switch bar layout. The controller derives wide|mobile from host.notifyResize. */
+    setLayout(layout: ShellLayoutMode): void;
+    /** Apply colour tokens (CSS vars in DOM / repaint in Pixi). */
+    applyTheme(tokens: ShellTokens): void;
+    /** Count a money readout from→to on the freshly-rendered bar (DOM rAF / Pixi ticker). */
+    animateMoney(field: 'balance' | 'win', from: number, to: number): void;
+    /** Build + show an overlay from a controller-supplied model; return a handle for key routing
+     *  and programmatic close. Returns void when nothing was shown. */
+    openOverlay(req: OverlayRequest): OverlayHandle | void;
+    /** Tear down any open overlay. */
+    closeOverlay(): void;
+    /** If the open overlay registered a sound-icon refresher, the controller calls this to refresh it. */
+    refreshSoundIcon?(on: boolean): void;
+    /** Fade out + remove all nodes; resolve when gone. */
+    destroy(): Promise<void> | void;
+    /** Insets a scene should avoid (only the bottom bar is reserved; the rest is full-bleed). */
+    readonly safeArea?: SafeArea;
+    /** Height of the bottom control bar in px (0 before first layout / when there's no bar). */
+    readonly barHeight?: number;
+    /** Show/hide the whole shell (bar + overlays). */
+    setVisible?(visible: boolean): void;
+}
+/** Bottom-bar inset a host reserves for scene content. */
+interface SafeArea {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** The surface facade createShell() guarantees on the returned shell, delegating to the renderer
+ *  (inert defaults when the renderer omits a member). Hosts embedding a shell read these. */
+interface ShellSurface {
+    readonly safeArea: SafeArea;
+    readonly barHeight: number;
+    setVisible(visible: boolean): void;
+}
+/** What the renderer (and its components) read from the brain. */
+interface ShellHost {
+    readonly state: ShellState;
+    readonly config: ResolvedShellConfig;
+    readonly tokens: ShellTokens;
+    readonly layout: ShellLayoutMode;
+    readonly soundOn: boolean;
+    /** Resolve a built-in string (translation + optional socialize). */
+    t(text: string): string;
+    /** Currency-aware money formatting (win=true ⇒ variable decimals). */
+    formatCurrency(n: number, win?: boolean): string;
+    /** Typed event emit — same signature as the shells. */
+    emit: EventEmitter<ShellEvents>['emit'];
+    /** Renderer reports its surface size; the controller recomputes layout + re-renders. */
+    notifyResize(w: number, h: number): void;
+    /** Flip shared sound state (emits settingChange + refreshes an open Settings icon). */
+    setSound(on: boolean): void;
+    /** An open Settings overlay registers an icon updater here (null clears it on close). */
+    setSoundRefresh(fn: ((on: boolean) => void) | null): void;
+    /** Logic-bearing actions invoked by renderer controls. */
+    readonly actions: ShellActions;
+}
+/** Every state-changing thing a control can do. Each runs logic in the controller, emits the
+ *  matching event, and triggers a re-render. Renderers MUST route input through these. */
+interface ShellActions {
+    spin(): void;
+    stepBet(dir: 1 | -1): void;
+    setBet(n: number): void;
+    cycleTurbo(): void;
+    toggleAutoplay(): void;
+    startAutoplay(remaining: number): void;
+    stopAutoplay(): void;
+    openMenu(): void;
+    openSettings(): void;
+    openInfo(): void;
+    openBuyBonus(): void;
+    openBetPicker(): void;
+    openAutoplayPicker(): void;
+    selectBuyBonus(id: string): void;
+    activateFeature(b: BonusOption$1): void;
+    deactivateFeature(): void;
+    setSound(on: boolean): void;
+    closeOverlay(): void;
+}
+interface OverlayHandle {
+    /** Overlay-specific keys (e.g. arrows in a picker). Return true to consume. */
+    onKey?(e: KeyboardEvent): boolean;
+    /** Programmatically close this overlay. */
+    close(): void;
+}
+type OverlayRequest = {
+    kind: 'settings';
+} | {
+    kind: 'gameInfo';
+} | {
+    kind: 'buyBonus';
+} | {
+    kind: 'betPicker';
+} | {
+    kind: 'autoplayPicker';
+} | {
+    kind: 'replay';
+    opts: ReplayModalOptions;
+} | {
+    kind: 'modal';
+    opts: ModalOptions;
+};
+
+interface CreateShellOptions extends ShellConfig {
+    renderer: ShellRenderer;
+}
+/** Apply defaults to the raw config (the mount target lives on the renderer, not here). */
+declare function resolveConfig(config: ShellConfig): ResolvedShellConfig;
+/** The renderer-agnostic brain. Owns state, events, keyboard, i18n, theme, overlay flow and the
+ *  game-facing public API; drives a ShellRenderer for the view. Implements ShellHost so the
+ *  renderer + its components read everything they need through one interface. */
+declare class ShellController extends EventEmitter<ShellEvents> implements ShellHost {
+    readonly config: ResolvedShellConfig;
+    state: ShellState;
+    tokens: ShellTokens;
+    layout: ShellLayoutMode;
+    soundOn: boolean;
+    readonly engineVersion = "0.2.0";
+    readonly actions: ShellActions;
+    private renderer;
+    private i18n;
+    private kbd?;
+    private overlay;
+    private soundRefresh;
+    private prevBalance;
+    private prevWin;
+    private destroyed;
+    constructor(opts: CreateShellOptions);
+    t(text: string): string;
+    formatCurrency(n: number, win?: boolean): string;
+    formatWin(value: number): string;
+    notifyResize(w: number, h: number): void;
+    private buildActions;
+    private attachKeyboard;
+    private pullFocus;
+    private show;
+    openMenu(): void;
+    openSettings(): void;
+    openInfo(): void;
+    openBuyBonus(): void;
+    openBetPicker(): void;
+    openAutoplayPicker(): void;
+    openReplay(opts: ReplayModalOptions): void;
+    openModal(opts: ModalOptions): void;
+    /** Programmatically dismiss whatever overlay/modal is open. No-op when nothing is shown. */
+    closeModal(): void;
+    setSound(on: boolean): void;
+    setSoundRefresh(fn: ((on: boolean) => void) | null): void;
+    activateFeature(bonus: BonusOption$1): void;
+    deactivateFeature(): void;
+    private money;
+    setBalance(n: number): void;
+    setWin(n: number): void;
+    setBet(n: number): void;
+    setMode(mode: ShellMode): void;
+    setBusy(busy: boolean): void;
+    setAutoplay(a: AutoplayOptions): void;
+    setTurbo(level: number): void;
+    setBuyBonusEnabled(enabled: boolean): void;
+    setFreeSpins(fs: FreeSpinsState): void;
+    setTheme(theme: ThemeConfig): void;
+    setLanguage(lang: string): void;
+    setSocial(isSocial: boolean): void;
+    setLayout(layout: ShellLayoutMode): void;
+    destroy(): Promise<void>;
+}
+
+/** Rewrite restricted gambling terms in `text` to social-safe phrasing, preserving case. */
+declare function socialize(text: string): string;
+type Lang = 'de' | 'en' | 'es' | 'fi' | 'fr' | 'hi' | 'id' | 'ja' | 'ko' | 'pl' | 'pt' | 'ru' | 'tr' | 'vi' | 'zh' | 'da';
+declare function normalizeLang(code: string | null | undefined): Lang;
+interface I18nOptions {
+    language: string;
+    isSocial?: boolean;
+    messages?: Partial<Record<Lang, Record<string, string>>>;
+}
+interface I18n {
+    readonly lang: Lang;
+    t(src: string): string;
+}
+declare function createI18n(opts: I18nOptions): I18n;
+
+/** The @energy8platform/shell package version, stamped into the game-info footer. */
+declare const PACKAGE_VERSION = "0.2.0";
+
+/** A shell: the renderer-agnostic controller plus the surface facade (safeArea/barHeight/setVisible)
+ *  an embedding host reads. `createShell`, `createGameShell` and `createPixiShell` all return this. */
+type Shell = ShellController & ShellSurface;
+/** Create a shell with an explicit renderer instance (custom or a built-in HtmlRenderer/PixiRenderer).
+ *  Built-in renderers also have the createGameShell/createPixiShell sugar in /html and /pixi.
+ *
+ *  The returned controller is augmented with the `ShellSurface` facade, delegating to the renderer's
+ *  optional surface members (inert defaults when it has none) — so any renderer, custom included, is
+ *  drivable by an embedding host (e.g. game-engine's createSlotGame) without Pixi-specific glue. */
+declare function createShell(opts: CreateShellOptions): Shell;
+
+/** A pushed full-screen layer (overlay or centred modal). Optional hooks let the host re-fit it
+ *  on resize. */
+interface ShellLayer extends Container {
+    /** Re-flow to a new screen size (overlays fill it; cards re-centre + fit-scale). */
+    resize?(w: number, h: number): void;
+    /** Re-run the card fit-scale backstop for short popouts. */
+    fit?(): void;
+    /** Called right before the layer is removed, so it can detach DOM listeners etc. */
+    onRemove?(): void;
+    /** Called by the shell keyboard controller while this layer is open.
+     *  Return true to consume the key (prevents bar actions + Escape close); false to pass through
+     *  (Escape → closeLayer). */
+    onKey?(e: KeyboardEvent): boolean;
+}
+interface LayerHandle {
+    root: ShellLayer;
+    close(): void;
+}
+
+interface PixiRendererOptions {
+    app: Application;
+    parent?: Container;
+}
+/** The Pixi VIEW half of the shell — the renderer the controller drives. Owns the root/bar/modal
+ *  containers, builds the BottomBar + overlays, runs money count-ups + the frosted backdrop, and
+ *  reports its surface size back to the controller. All the keyboard / pull-focus / overlay-flow
+ *  logic lives in the ShellController; this class is pure Pixi rendering — a 1:1 port of the
+ *  PixiGameShell rendering methods. */
+declare class PixiRenderer implements ShellRenderer {
+    private app;
+    private parent?;
+    private host;
+    private ctx;
+    private root;
+    private barLayer;
+    private modalLayer;
+    private bar?;
+    private currentLayer;
+    private backdrop?;
+    private moneyAnims;
+    private destroyed;
+    constructor(opts: PixiRendererOptions);
+    private get ticker();
+    private get screenW();
+    private get screenH();
+    mount(host: ShellHost): void;
+    renderBar(): void;
+    setLayout(): void;
+    /** Tokens are read live from host.tokens by the components, so a theme change is just a re-render
+     *  (mirrors PixiGameShell.setTheme which re-rendered). */
+    applyTheme(_tokens: ShellTokens): void;
+    /** Count a money readout from→to on the freshly-rendered bar's value Text node. Mirrors
+     *  PixiGameShell.animateMoney (which counted on the just-built bar's value Texts). */
+    animateMoney(field: 'balance' | 'win', from: number, to: number): void;
+    private cancelMoneyAnims;
+    openOverlay(req: OverlayRequest): OverlayHandle | void;
+    closeOverlay(): void;
+    refreshSoundIcon(_on: boolean): void;
+    /** Fade out (≈250ms, like GameShell's REMOVE_FADE_MS) then tear down; resolves when removed. */
+    destroy(): Promise<void>;
+    pushLayer(node: ShellLayer): LayerHandle;
+    closeLayer(): void;
+    private clearLayer;
+    fitModals(): void;
+    /** Replay's reopen path: a replay modal can rebuild itself (e.g. after a replay completes). It is
+     *  routed back through the controller-equivalent open flow so the layer stack + backdrop stay in
+     *  sync — mirrors PixiGameShell.openReplay (push a fresh replay modal). */
+    private openReplayInternal;
+    /** Snapshot the scene behind the modal layer and blur it — the Pixi analogue of the overlay's
+     *  `backdrop-filter: blur(20px) saturate(120%)`. Static (captured at open time): the game is paused
+     *  under a modal, so a live re-blur each frame isn't worth the cost. */
+    private makeBackdrop;
+    private removeBackdrop;
+    /** Height of the bottom control bar in px (0 before first layout, or in replay-only chrome). */
+    get barHeight(): number;
+    /** Insets a scene should avoid. Only the bottom bar is reserved; the rest is full-bleed. */
+    get safeArea(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Show/hide the whole shell (bar + overlays). */
+    setVisible(visible: boolean): void;
+    private onResize;
+    /** Build the surface pixi components read: the core brain (host) plus the Pixi-specific members
+     *  (ticker, canvas, screen size, the layer-stack methods, fmt/fmtWin shorthands). */
+    private makeContext;
+}
+
+/** Config for the Pixi shell: the renderer-agnostic ShellConfig plus the Pixi mount target.
+ *  `app` is the PixiJS Application; `parent` (defaults to `app.stage`) is where the shell root
+ *  attaches. */
+interface PixiShellConfig extends ShellConfig {
+    app: Application;
+    parent?: Container;
+}
+/** A bonus-buy option whose `custom` card renderer returns a Pixi `Container` (vs core's `unknown`
+ *  / ui/html's `HTMLElement`). */
+interface BonusOption extends BonusOption$1 {
+    custom?: (ctx: BonusCardContext) => Container;
+}
+/** A `custom` game-info section renders a game-supplied Pixi `Container` (`node`). The other section
+ *  kinds are unchanged from core. */
+type GameInfoSection = Exclude<GameInfoSection$1, {
+    type: 'custom';
+}> | {
+    type: 'custom';
+    title?: string;
+    order?: number;
+    node?: Container;
+    html?: string;
+};
+/** The surface game scenes use to position themselves. Identical to the renderer-agnostic
+ *  `ShellSurface` (kept as a named alias for back-compat). */
+type PixiShellSurface = ShellSurface;
+/** The Pixi shell handle: the renderer-agnostic controller + the surface game scenes use. */
+type PixiGameShell = Shell;
+/** Create the Pixi game shell. Like `createGameShell`, only one is active at a time. Returns the
+ *  existing instance if one is already active. The `ShellSurface` facade (safeArea/barHeight/
+ *  setVisible) is wired by `createShell`, delegating to the PixiRenderer. */
+declare function createPixiShell(config: PixiShellConfig): PixiGameShell;
+/** Tear down the active Pixi shell (fade out, detach listeners, remove its display objects).
+ *  Resolves when removed — mirrors `removePixiShell` in the legacy package. */
+declare function removePixiShell(): Promise<void>;
+
+export { DEFAULT_ACCENT, PACKAGE_VERSION, PixiRenderer, SCHEMES, ShellController, createI18n, createPixiShell, createShell, normalizeLang, removePixiShell, resolveConfig, resolveTheme, socialize };
+export type { AutoplayConfig, AutoplayOptions, BonusCardContext, BonusOption, CellRef, CreateShellOptions, CurrencyConfig, FreeSpinsState, GameInfoContent, GameInfoSection, GameMode, I18n, I18nOptions, Lang, ModalAction, ModalOptions, OverlayHandle, OverlayRequest, PaylineDef, PaytableRow, PixiGameShell, PixiShellConfig, PixiShellSurface, ReplayModalOptions, ResolvedShellConfig, SafeArea, ShapeDef, Shell, ShellActions, ShellConfig, ShellEvents, ShellFeatures, ShellHost, ShellLayoutMode, ShellMode, ShellRenderer, ShellState, ShellSurface, ShellTokens, ThemeConfig, WinSection };