@scml-dol-maplebirch/types 5.0.4 → 5.1.1

package/modules/NamedNPCAddon/NPCTransformation.d.ts

@@ -0,0 +1,51 @@
+import type NPCManager from '../NamedNPC.js';
+import type { NPCBodyData, NPCSidebarState } from './NPCSidebarConfig/types.js';
+import { transformationDefaults } from './NPCSidebarConfig/transformation_layers.js';
+export interface NPCTransformationState {
+    build: number;
+    level: number;
+}
+export type NPCTransformationPart = {
+    [Key in keyof typeof transformationDefaults]: Key extends `${infer Part}_type` ? Part : never;
+}[keyof typeof transformationDefaults];
+export interface NPCTransformationPartConfig {
+    level?: number;
+    style?: string;
+    filter?: {
+        blend?: string;
+        blendMode?: string;
+        brightness?: number;
+        contrast?: number;
+        desaturate?: boolean;
+    };
+}
+export interface NPCTransformationConfig {
+    levels?: readonly number[];
+    type?: string;
+    parts?: Partial<Record<NPCTransformationPart, NPCTransformationPartConfig>>;
+    body?: (bodydata: NPCBodyData, state: Readonly<NPCTransformationState>, npcName: string) => void;
+    sidebar?: (nnpc: Partial<NPCSidebarState>, state: Readonly<NPCTransformationState>, npcName: string) => void;
+    layers?: CanvasLayerMap;
+}
+declare class NPCTransformation {
+    private readonly manager;
+    private readonly configs;
+    constructor(manager: NPCManager);
+    add(npcName: string, type: string, config?: NPCTransformationConfig): this;
+    ensure(npcName: string, type?: string): Record<string, NPCTransformationState>;
+    get(npcName: string, type: string): NPCTransformationState;
+    build(npcName: string, type: string, value: number): NPCTransformationState;
+    set(npcName: string, type: string, level: number): NPCTransformationState;
+    clear(npcName: string, type?: string): void;
+    level(npcName: string, type: string): number;
+    type(npcName: string): string;
+    applyBody(nnpc: Partial<NPCSidebarState>, npcData: {
+        bodydata?: NPCBodyData;
+    }): void;
+    applySidebar(nnpc: Partial<NPCSidebarState>): void;
+    private read;
+    private entries;
+    private config;
+    private active;
+}
+export default NPCTransformation;

package/modules/NamedNPCAddon/NPCUtils.d.ts

@@ -0,0 +1,8 @@
+import type NPCManager from '../NamedNPC.js';
+declare const bodyDefaults: {
+    hair_sides_length: number;
+    hair_fringe_length: number;
+};
+declare function isPossible(manager: NPCManager, name: string): boolean;
+declare function setupNPCData(manager: NPCManager): void;
+export { bodyDefaults, isPossible, setupNPCData };

package/modules/State.d.ts

@@ -0,0 +1,46 @@
+import type Dynamic from './Dynamic.js';
+import Event, { type EventOptions } from './Event.js';
+export interface StateEventOptions extends EventOptions {
+    output?: string;
+    action?: () => void;
+    cond?: () => boolean;
+    forceExit?: boolean | (() => boolean);
+    extra?: {
+        passage?: string[];
+        exclude?: string[];
+        match?: RegExp;
+    };
+}
+interface StateEventResult {
+    hasOutput: boolean;
+    remove: boolean;
+}
+declare class StateEvent extends Event {
+    readonly type: 'gate' | 'append';
+    protected readonly eventName = "StateEvent";
+    output?: string;
+    private action?;
+    private cond;
+    private forceExit;
+    private extra;
+    constructor(id: string, type: 'gate' | 'append', options: StateEventOptions, log: Dynamic['log']);
+    private checkPassage;
+    tryRun(passageName?: string): StateEventResult | null;
+    private match;
+    private runAction;
+    shouldForceExit(): boolean;
+}
+export declare class StateManager {
+    private readonly manager;
+    private readonly stateEvents;
+    private readonly log;
+    constructor(manager: Dynamic);
+    get events(): Readonly<Record<'gate' | 'append', ReadonlyMap<string, StateEvent>>>;
+    trigger(type: 'gate' | 'append'): string;
+    private processGateEvents;
+    private processAppendEvents;
+    register(type: 'gate' | 'append', eventId: string, options: StateEventOptions): boolean;
+    unregister(type: 'gate' | 'append', eventId: string): boolean;
+    Init(): void;
+}
+export {};

package/modules/TimeStateWeather/DateTime.d.ts

@@ -0,0 +1,4 @@
+export declare function patchTimeConstantsAsset(content: string): string;
+export declare function patchDateTimeAsset(content: string): string;
+declare function patchDateTime(BaseDateTime: DateTimeConstructor): DateTimeConstructor;
+export default patchDateTime;

package/modules/TimeStateWeather/Time.d.ts

@@ -0,0 +1,14 @@
+export declare function patchTimeAsset(content: string): string;
+interface TimeHandlers {
+    pass?: (seconds: number) => unknown;
+    timeTravel?: (date: DateTime) => unknown;
+}
+export interface VanillaTimeHandlers {
+    set?: (value?: number | DateTime) => void;
+    pass?: (seconds: number) => unknown;
+    setDate?: (date: DateTime) => void;
+}
+export declare const vanillaTime: VanillaTimeHandlers;
+export declare function bindTimeHandlers(time: TimeAPI, handlers: TimeHandlers): void;
+declare function patchTime(time: TimeAPI): void;
+export default patchTime;

package/modules/TimeStateWeather/TimeEvents.d.ts

@@ -0,0 +1,130 @@
+import type DoLDynamic from '../DoL/Dynamic.js';
+import Event, { type EventOptions } from '../Event.js';
+export type TimeEventType = 'onSec' | 'onMin' | 'onHour' | 'onDay' | 'onWeek' | 'onMonth' | 'onYear' | 'onBefore' | 'onThread' | 'onAfter' | 'onTimeTravel';
+type TimeUnit = 'sec' | 'min' | 'hour' | 'day' | 'week' | 'month' | 'year';
+interface AccumulateConfig {
+    unit: TimeUnit;
+    target?: number;
+}
+export interface TimeData {
+    prevDate?: DateTime;
+    currentDate?: DateTime;
+    changes?: Record<TimeUnit, number>;
+    triggeredByAccumulator?: {
+        unit: TimeUnit;
+        target: number;
+        count: number;
+    };
+    exactPoints?: {
+        min: boolean;
+        hour: boolean;
+        day: boolean;
+        week: boolean;
+        month: boolean;
+        year: boolean;
+    };
+    passed?: number;
+    sec?: number;
+    min?: number;
+    hour?: number;
+    day?: number;
+    week?: number;
+    month?: number;
+    year?: number;
+    weekday?: [number, number];
+    detailedDiff?: ReturnType<DateTime['compareWith']>;
+    timeStamp?: number;
+    prev?: DateTime;
+    current?: DateTime;
+    diffSeconds?: number;
+    direction?: 'forward' | 'backward';
+    isLeap?: boolean;
+}
+export interface TimeEventOptions extends EventOptions {
+    action?: (data: TimeData) => void;
+    cond?: (data: TimeData) => boolean;
+    accumulate?: AccumulateConfig;
+    exact?: boolean;
+}
+export interface TimeTravelOptions {
+    target?: DateTime;
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    addYears?: number;
+    addMonths?: number;
+    addDays?: number;
+    addHours?: number;
+    addMinutes?: number;
+    addSeconds?: number;
+}
+declare class TimeEvent extends Event {
+    readonly type: TimeEventType;
+    protected readonly eventName = "TimeEvent";
+    private action?;
+    private cond;
+    private exact;
+    private accumulate?;
+    private accumulated;
+    private target;
+    constructor(id: string, type: TimeEventType, options: TimeEventOptions, log: DoLDynamic['log']);
+    tryRun(data: TimeData, accumulatedOnly?: boolean): boolean;
+    private runAccumulated;
+    private execute;
+    private match;
+    private runAction;
+    private isExactPoint;
+}
+export declare class TimeManager {
+    private readonly manager;
+    private readonly timeEvents;
+    private readonly travelHooks;
+    readonly log: DoLDynamic['log'];
+    readonly TimeConstants: Readonly<{
+        secondsPerDay: 86400;
+        secondsPerHour: 3600;
+        secondsPerMinute: 60;
+        minutesPerHour: 60;
+        standardYearMonths: readonly number[];
+        leapYearMonths: readonly number[];
+        synodicMonth: 29.53058867;
+        MIN_DATE: Readonly<{
+            timeStamp: -315537984000;
+            year: -9999;
+            month: 1;
+            day: 1;
+            hour: 0;
+            minute: 0;
+            second: 0;
+        }>;
+        MAX_DATE: Readonly<{
+            timeStamp: 315537897599;
+            year: 9999;
+            month: 12;
+            day: 31;
+            hour: 23;
+            minute: 59;
+            second: 59;
+        }>;
+    }>;
+    constructor(manager: DoLDynamic);
+    get events(): Readonly<Record<string, ReadonlyMap<string, TimeEvent>>>;
+    Init(): void;
+    patchDateTime(DateTimeClass: typeof DateTime): typeof DateTime;
+    patchTime(TimeObject: typeof Time): void;
+    register(type: TimeEventType, eventId: string, options: TimeEventOptions): boolean;
+    unregister(type: string, eventId: string): boolean;
+    onTravel(name: string, callback: (data: TimeData) => void): boolean;
+    timeTravel(options?: TimeTravelOptions): boolean;
+    updateTimeLanguage(choice?: 'JournalTime'): string | boolean;
+    private handleTimePass;
+    private handleTimeTravel;
+    private targetDate;
+    private timeData;
+    private triggerUnitEvents;
+    private trigger;
+}
+export {};

package/modules/TimeStateWeather/WeatherEvents.d.ts

@@ -0,0 +1,56 @@
+import type AddonPlugin from '../../services/AddonPlugin.js';
+import type DoLDynamic from '../DoL/Dynamic.js';
+import { type EventOptions } from '../Event.js';
+export interface WeatherEventOptions extends EventOptions {
+    condition?: () => boolean;
+    onEnter?: () => void;
+    onExit?: () => void;
+    [key: string]: any;
+}
+export interface WeatherTypeConfig {
+    name: string;
+    iconType?: string | (() => string);
+    value: number;
+    probability: {
+        summer: number;
+        winter: number;
+        spring: number;
+        autumn: number;
+    };
+    cloudCount: {
+        small: () => number;
+        large: () => number;
+    };
+    tanningModifier: number;
+    overcast: number | (() => number);
+    precipitationIntensity: number;
+    visibility: number;
+}
+export interface WeatherException {
+    date: () => DateTime;
+    duration: number;
+    weatherType: string;
+    temperature?: number;
+}
+export declare class WeatherManager {
+    private readonly manager;
+    private readonly weatherEvents;
+    private readonly activeEvents;
+    private readonly Exceptions;
+    private readonly WeatherTypes;
+    private readonly layerModifications;
+    private readonly effectModifications;
+    private weatherTriggered;
+    private readonly log;
+    constructor(manager: DoLDynamic);
+    private refresh;
+    private checkEvents;
+    register(eventId: string, options: WeatherEventOptions): boolean;
+    unregister(eventId: string): boolean;
+    addLayer(layerName: string, patch: any, mode?: 'concat' | 'replace' | 'merge'): this;
+    addEffect(effectName: string, patch: any, mode?: 'concat' | 'replace' | 'merge'): this;
+    applyModifications(params: any): any;
+    addWeatherData(data: WeatherException | WeatherTypeConfig): boolean | void;
+    Init(): void;
+    modifyWeatherJavaScript(manager: AddonPlugin): void;
+}

package/modules/ToolCollection.d.ts

@@ -0,0 +1,33 @@
+import type { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import Console from './Frameworks/ConsoleCheat.js';
+import migration from './Frameworks/migration.js';
+import randSystem from './Frameworks/RandSystem.js';
+import defineMacros, { type MacroFunction, type SimpleMacroFunction, type MacroTags, type SkipArgs, type MacroPhase } from './Frameworks/macros.js';
+import htmlTools from './Frameworks/HtmlTools.js';
+import { zonesManager, type InitFunction, type ZoneWidget } from './Frameworks/ZonesManager.js';
+import applyLinkZone from './Frameworks/ApplyLinkZone.js';
+import Patch from './Frameworks/Patch.js';
+type ToolConstructors = {
+    console?: new (manager: ToolCollection) => Console;
+    macro?: new (manager: ToolCollection) => defineMacros;
+};
+declare class ToolCollection {
+    readonly core: MaplebirchCore;
+    readonly log: ScopedLog;
+    readonly console: Console;
+    readonly migration: typeof migration;
+    readonly rand: typeof randSystem;
+    readonly macro: defineMacros;
+    readonly text: htmlTools;
+    readonly zone: zonesManager;
+    readonly link: typeof applyLinkZone;
+    readonly patch: Patch;
+    constructor(core: MaplebirchCore, constructors?: ToolConstructors);
+    onInit(...widgets: InitFunction[]): void;
+    define<Args extends unknown[]>(name: string, fn: MacroFunction<Args>, tags?: MacroTags, skipArgs?: SkipArgs, isAsync?: boolean, phase?: MacroPhase): void;
+    defineS<Args extends unknown[]>(name: string, fn: SimpleMacroFunction<Args>, tags?: MacroTags, skipArgs?: SkipArgs, maintainContext?: boolean, phase?: MacroPhase): void;
+    addTo(zone: string, ...widgets: ZoneWidget[]): void;
+    inject(...databases: Parameters<zonesManager['inject']>): void;
+}
+export default ToolCollection;

package/modules/Variables.d.ts

@@ -0,0 +1,32 @@
+import { MaplebirchCore } from '../core.js';
+import type { ScopedLog } from '../infra/Diagnostics.js';
+import migration from './Frameworks/migration.js';
+declare class Options {
+    define(...args: any[]): any;
+}
+interface HairGradientsReturn {
+    fringe: Record<string, string[]>;
+    sides: Record<string, string[]>;
+}
+declare function hairgradients(): HairGradientsReturn;
+declare class Variables {
+    readonly core: MaplebirchCore;
+    private static readonly OPTIONS_STORAGE_KEY;
+    private static moduleOptions;
+    static add(key: string, value: any): void;
+    static get options(): Record<string, any>;
+    version: string;
+    readonly tool: MaplebirchCore['tool'];
+    readonly log: ScopedLog;
+    readonly migration: migration;
+    readonly options: Options;
+    constructor(core: MaplebirchCore);
+    hairgradients: typeof hairgradients;
+    optionsStorage(action: 'save' | 'restore' | 'reset' | 'load'): any | null;
+    check(): void;
+    Init(): void;
+    loadInit(): void;
+    postInit(): void;
+    private run;
+}
+export default Variables;

package/package.d.ts

@@ -0,0 +1,30 @@
+import instance, * as types from './index';
+
+type Utils = typeof types.utils.publicUtils;
+
+declare global {
+  const maplebirch: typeof instance;
+  function clone<T>(...args: Parameters<typeof types.utils.clone<T>>): ReturnType<typeof types.utils.clone<T>>;
+  const equal: Utils['equal'];
+  const merge: Utils['merge'];
+  const append: Utils['append'];
+  const cover: Utils['cover'];
+  const mergefn: Utils['mergefn'];
+  const appendfn: Utils['appendfn'];
+  const coverfn: Utils['coverfn'];
+  const contains: Utils['contains'];
+  function random(...args: Parameters<Utils['random']>): ReturnType<Utils['random']>;
+  function either<T>(...args: Parameters<typeof types.utils.either<T>>): ReturnType<typeof types.utils.either<T>>;
+  const SelectCase: Utils['SelectCase'];
+  const convert: Utils['convert'];
+  const clamp: Utils['clamp'];
+  const loadImage: typeof types.ImageLoader.load;
+
+  interface Window extends Readonly<Utils> {
+    readonly maplebirch: typeof instance;
+    readonly loadImage: typeof types.ImageLoader.load;
+  }
+}
+
+export default instance;
+export * from './index';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scml-dol-maplebirch/types",
-  "version": "5.0.4",
+  "version": "5.1.1",
   "description": "TypeScript definitions for maplebirchFramework.",
   "keywords": [
     "degrees-of-lewdity",
@@ -13,21 +13,19 @@
   "license": "(MIT OR CC-BY-NC-SA-4.0)",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MaplebirchLeaf/SCML-DOL-maplebirchFramework.git",
-    "directory": "packages/types"
+    "url": "git+https://github.com/MaplebirchLeaf/SCML-DOL-maplebirchFramework.git"
   },
   "files": [
-    "index.d.ts",
-    "maplebirch.d.ts",
+    "**/*.d.ts",
     "README.md",
     "LICENSE",
     "LICENSE-CC-BY-NC-SA-4.0"
   ],
   "sideEffects": false,
-  "types": "index.d.ts",
+  "types": "package.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts"
+      "types": "./package.d.ts"
     }
   },
   "publishConfig": {

package/services/AddonPlugin.d.ts

@@ -0,0 +1,92 @@
+import type { Passage } from '@scml/types/sugarcube-2-ModLoader/SugarCube2';
+import type { ModBootJson, ModInfo } from '@scml/types/sugarcube-2-ModLoader/ModLoader';
+import type { JSZipLikeReadOnlyInterface } from '@scml/types/sugarcube-2-ModLoader/JSZipLikeReadOnlyInterface';
+import type { ModZipReader } from '@scml/types/sugarcube-2-ModLoader/ModZipReader';
+import type { SC2DataManager } from '@scml/types/sugarcube-2-ModLoader/SC2DataManager';
+import type { ModUtils } from '@scml/types/sugarcube-2-ModLoader/Utils';
+import type { CryptOptions } from '../services/CredentialVault.js';
+import type ModLoader from '../host/ModLoader.js';
+import type Resources from '../host/Resources.js';
+import type SugarCube from '../host/SugarCube.js';
+import type Emitter from '../infra/Emitter.js';
+import Catalog from '../infra/Catalog.js';
+import Hooks from '../infra/Hooks.js';
+import type { Replacement } from '../host/ModLoader.js';
+import type CredentialVault from './CredentialVault.js';
+import type GUIControl from './GUIControl.js';
+import type IndexedDB from './IndexedDB.js';
+import type Modules from './Modules.js';
+import type Translator from './Translator.js';
+interface FileItem {
+    modName: string;
+    filePath: string;
+    content: string;
+}
+export interface BootTask<T = unknown> {
+    modName: string;
+    modInfo: ModInfo;
+    modZip: ModZipReader;
+    config: T;
+}
+export type BootHandler<T = unknown> = (task: BootTask<T>) => void | Promise<void>;
+export interface AddonServices {
+    translator(): Translator;
+    gui(): GUIControl;
+    credential(): CredentialVault;
+}
+export declare class AddonPlugin extends Hooks<[BootTask], void> {
+    readonly sugarcube: SugarCube;
+    readonly events: Emitter;
+    readonly idb: IndexedDB;
+    readonly modules: Modules;
+    private readonly services;
+    onStart: boolean;
+    get resources(): Resources;
+    replace(content: string, replacements: Replacement[], label?: string): string;
+    readonly info: Catalog<string, {
+        addonName: string;
+        mod: ModInfo;
+        modZip: ModZipReader;
+    }>;
+    readonly modList: string[];
+    readonly jsFiles: FileItem[];
+    readonly moduleFiles: FileItem[];
+    private readonly disabledMods;
+    readonly blockedPassages: Set<string>;
+    readonly excludedMods: Set<string>;
+    private readonly bootQueue;
+    private onSaveLoadTracer;
+    private moduleFilesExecuted;
+    private scriptFilesExecuted;
+    private bootReady;
+    constructor(modloader: ModLoader, sugarcube: SugarCube, events: Emitter, idb: IndexedDB, modules: Modules, services: AddonServices);
+    get SC2DataManager(): SC2DataManager;
+    get modUtils(): ModUtils;
+    hook<T>(name: string, handler: BootHandler<T>): boolean;
+    canLoadThisMod(bootJson: ModBootJson, _zip: JSZipLikeReadOnlyInterface): Promise<boolean>;
+    afterInjectEarlyLoad(): Promise<void>;
+    ModLoaderLoadEnd(): Promise<void>;
+    afterEarlyLoad(): Promise<void>;
+    registerMod(addonName: string, modInfo: ModInfo, modZip: ModZipReader): Promise<void>;
+    afterRegisterMod2Addon(): Promise<void>;
+    beforePatchModToGame(): Promise<void>;
+    PatchModToGame_start(): Promise<void>;
+    afterPatchModToGame(): Promise<void>;
+    afterPreload(): Promise<void>;
+    whenSC2StoryReady(): Promise<void>;
+    whenSC2PassageInit(passage: Passage): Promise<void>;
+    whenSC2PassageStart(passage: Passage, content: HTMLDivElement): Promise<void>;
+    whenSC2PassageRender(passage: Passage, content: HTMLDivElement): Promise<void>;
+    whenSC2PassageDisplay(passage: Passage, content: HTMLDivElement): Promise<void>;
+    whenSC2PassageEnd(passage: Passage, content: HTMLDivElement): Promise<void>;
+    loadCrypt(options: CryptOptions): Promise<boolean>;
+    private scriptFiles;
+    private loadFiles;
+    private executeScripts;
+    private process;
+    private queue;
+    private flush;
+    private run;
+    private config;
+}
+export default AddonPlugin;

package/services/CloudSave.d.ts

@@ -0,0 +1,124 @@
+import Diagnostics from '../infra/Diagnostics.js';
+import type SugarCube from '../host/SugarCube.js';
+import type { DolStateMoment } from '../types/twine-sugarcube.js';
+type CloudSaveSlot = number;
+type PanelAction = 'connectRemote' | 'uploadSlot' | 'downloadSlot' | 'refreshRemoteList' | 'deleteRemoteSlot' | 'exportCurrentCode' | 'exportSlotCode' | 'uploadCode' | 'downloadCode' | 'importCode';
+interface CloudSaveConfig {
+    endpoint: string;
+    token: string;
+    remember?: boolean;
+}
+interface CloudSaveRecord {
+    slot: CloudSaveSlot;
+    details: SaveDetails | null;
+    save: SaveState;
+    exportedAt: number;
+    gameId?: string;
+}
+interface CloudSaveCodeRecord {
+    code: string;
+    exportedAt: number;
+    gameId?: string;
+}
+interface CloudSaveRemoteItem {
+    slot: CloudSaveSlot;
+    updatedAt: number;
+    payload?: CloudSaveRecord;
+}
+interface CloudSaveRemoteCode {
+    updatedAt: number;
+    payload?: CloudSaveCodeRecord;
+}
+interface SaveDetails {
+    date?: number;
+    title?: string;
+    idx?: unknown;
+    metadata?: {
+        saveName?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface SaveState {
+    history?: DolStateMoment[];
+    delta?: unknown;
+    [key: string]: unknown;
+}
+interface CloudSaveTools {
+    isPlainObject(value: unknown): value is Record<string, unknown>;
+    isFinite(value: unknown): boolean;
+    isInteger(value: unknown): boolean;
+    inRange(value: number, start: number, end: number): boolean;
+}
+export declare class CloudSave {
+    readonly sugarcube: SugarCube;
+    readonly translate: (key: string) => string;
+    readonly tools: CloudSaveTools;
+    readonly diagnostics: Diagnostics;
+    private static readonly PANEL_STORAGE_KEY;
+    private static readonly REQUEST_TIMEOUT;
+    private config;
+    private mountFrame;
+    private busy;
+    constructor(sugarcube: SugarCube, translate: (key: string) => string, tools: CloudSaveTools, diagnostics: Diagnostics);
+    configure(config: CloudSaveConfig): this;
+    /** 验证 Worker 与 Token 是否可用。 */
+    connect(): Promise<void>;
+    /** 从 DoL 原生 IndexedDB 读取本地存档。 */
+    exportSlot(slot: CloudSaveSlot): Promise<CloudSaveRecord>;
+    /** 将云端存档写回 DoL 原生 IndexedDB。 */
+    importSlot(record: CloudSaveRecord, targetSlot?: CloudSaveSlot): Promise<boolean>;
+    /** 上传本地存档。 */
+    upload(slot: CloudSaveSlot): Promise<CloudSaveRemoteItem>;
+    /** 下载云端存档。 */
+    download(slot: CloudSaveSlot, targetSlot?: CloudSaveSlot): Promise<boolean>;
+    /** 获取远端存档列表。 */
+    listRemote(): Promise<CloudSaveRemoteItem[]>;
+    /** 删除远端存档。 */
+    deleteRemote(slot: CloudSaveSlot): Promise<void>;
+    /** 导出当前 SugarCube 存档码。 */
+    exportCode(): string;
+    /** 将指定本地槽位转换为 SugarCube 存档码。 */
+    exportSlotCode(slot: CloudSaveSlot): Promise<string>;
+    /** 导入 SugarCube 存档码。 */
+    importCode(code: string): boolean;
+    /** 上传 SugarCube 存档码。 */
+    uploadCode(code?: string): Promise<CloudSaveRemoteCode>;
+    /** 下载 SugarCube 存档码。 */
+    downloadCode(): Promise<string>;
+    /** 初始化云存档面板。 */
+    mountPanel(): void;
+    /** Twee 面板动作入口。 */
+    panelAction(action: PanelAction, slot?: CloudSaveSlot): Promise<void>;
+    private runPanelAction;
+    private done;
+    private complete;
+    private refreshPanel;
+    private remoteRow;
+    private readPanel;
+    private loadPanelConfig;
+    private savePanelConfig;
+    /** Worker 请求统一入口。 */
+    private request;
+    /** SugarCube delta 存档还原为完整 history。 */
+    private normalizeSave;
+    private validateRecord;
+    private validateCodeRecord;
+    private isSlot;
+    private validateSlot;
+    private validateGame;
+    private invalidResponse;
+    private field;
+    private setField;
+    private panelSlot;
+    /** 动态填充本地存档槽位选项。 */
+    populateSlotOptions(panel?: HTMLElement | null): Promise<void>;
+    private status;
+    private get saveDB();
+    private get panel();
+    private get current();
+    private get endpoint();
+    private get token();
+}
+export default CloudSave;
+export type { CloudSaveConfig, CloudSaveRecord, CloudSaveRemoteItem, CloudSaveRemoteCode };