import { Glossary } from '@bscotch/cl2-string-server-shared';
import { Pathy } from '@bscotch/pathy';
import { GameChangerRumpusMetadata } from './types.cl2.rumpus.js';
import { Bschema, ChangeType, Changes, type Mote, type MoteId, type PackedData, type SchemaId } from './types.js';
interface MoteVisitorDataCtx {
    /** The data at this point in the heirarchy */
    data: any;
    /** The key in the parent that points to this data. `undefined` at the data root */
    key: string | undefined;
    /** The full pointer, as a split array of strings, to the this data. Empty at the data root */
    pointer: string[];
    /** The subschema mapping onto this data */
    subschema: Bschema;
}
export interface MoteVisitorCtx<T = undefined> {
    mote: Mote;
    schema: Bschema;
    current: MoteVisitorDataCtx;
    /** `undefined` at the root, otherwise the prior visitor context data */
    parent: MoteVisitorCtx<T> | undefined;
    /** A place for your custom store to accumulate things during visits. Passed by reference. */
    store: T;
}
export declare class Gcdata {
    data: PackedData;
    constructor(data: PackedData, options?: {
        resolveRefsAndOverrides?: boolean;
    });
    get motes(): PackedData['motes'];
    get schemas(): PackedData['schemas'];
    visitMoteData<R>(moteId: string | Mote, 
    /** Function to call on every node in the mote data */
    visitor: (ctx: MoteVisitorCtx, priorVisitorReturn?: R | undefined) => R): R;
    visitMoteData<Store, R>(moteId: string | Mote, visitor: (ctx: MoteVisitorCtx<Store>, priorVisitorReturn?: R | undefined) => R, store: Store): R;
    getAncestors(ofMoteId: Mote | string, options?: {
        /** If true, circularity will cause an early return of the parents rather than throwing. */
        ignoreCircularity: boolean;
    }): Mote[];
    getMoteNamePointer(mote: Mote | string | undefined): string | undefined;
    getMoteName(moteId: Mote | string | undefined): string | undefined;
    getMote<T = any>(moteId: Mote | string | MoteId | undefined): Mote<T> | undefined;
    getSchema(schemaId: string | SchemaId | undefined): Bschema | undefined;
    listMotes(): Mote[];
    listMotesBySchema<D = unknown>(...schemaId: (string | SchemaId)[]): Mote<D>[];
    static from(gcdataFile: Pathy, options?: {
        resolveRefsAndOverrides?: boolean;
    }): Promise<Gcdata>;
    /**
     * Given a raw packed data object, recurse through to resolve
     * all references and overrides.
     */
    protected static resolveRefsAndOverrides(data: PackedData): void;
}
export declare class GameChanger {
    readonly projectName: string;
    base: Gcdata;
    working: Gcdata;
    protected changes: Changes;
    glossary?: Glossary;
    protected constructor(projectName: string);
    protected get workingData(): PackedData;
    protected get baseData(): PackedData;
    get projectSaveDir(): Pathy<unknown>;
    /**
     * Clear diffs for a subset of pointer patterns. This is so that
     * diff types that are fully represented by other editors can be
     * cleared, while leaving other changes intact.
     */
    clearMoteChanges(moteId: string, patterns: string[]): void;
    updateMoteLocation(moteId: string, newParentId: string | undefined, newFolder: string | undefined): void;
    createMote(schemaId: string, moteId: string): Mote<any, string>;
    updateMoteData(moteId: string, dataPath: string, value: any): void;
    protected createChange(category: 'schemas' | 'motes', id: string, change: {
        type: ChangeType;
        pointer?: string;
        newValue?: any;
    }): void;
    writeChanges(): Promise<void>;
    /** Apply changes to the baseData to get the updated workingData */
    protected applyChanges(): void;
    protected loadChanges(): Promise<void>;
    protected readCommitsMetadata(): Promise<GameChangerRumpusMetadata>;
    load(): Promise<void>;
    loadGlossary(access: {
        host: string;
        username: string;
        password: string;
    }): Promise<Glossary>;
    /**
     * @param path Either the path to a .yyp file (to get the included packed file) or the direct path to a GameChanger snapshot (e.g. a packed file or a base file).
     */
    static from(projectName: string): Promise<GameChanger | undefined>;
    static projectSaveDir(projectName: string): Pathy<unknown>;
    static projectRumpusGameChangerDir(projectName: string): Pathy<unknown>;
    static projectRumpusGameChangerMetadataFile(projectName: string): Pathy<unknown>;
    static projectGameChangerChangesFile(projectName: string): Pathy<{
        [x: string]: unknown;
        commitId: string;
        changes: {
            message: string;
            motes: Record<string, {
                [x: string]: unknown;
                schema_id: string;
                type: "added" | "deleted" | "changed";
                allowed: number | boolean;
                staged: number | boolean;
                mote_id?: string | undefined;
                schema_title?: string | undefined;
                mote_name?: string | undefined;
                diffs?: Record<string, [any, any]> | undefined;
            }>;
            schemas: Record<string, {
                [x: string]: unknown;
                schema_id: string;
                type: "added" | "deleted" | "changed";
                allowed: number | boolean;
                staged: number | boolean;
                mote_id?: string | undefined;
                schema_title?: string | undefined;
                mote_name?: string | undefined;
                diffs?: Record<string, [any, any]> | undefined;
            }>;
            conflicts: {
                [x: string]: unknown;
                motes: Record<string, any>;
                schemas: Record<string, any>;
            };
        };
    }>;
    static projectGameChangerChangesFolder(projectName: string): Pathy<unknown>;
    static projectGameChangerChangesBackupFolder(projectName: string): Pathy<unknown>;
}
export {};
//# sourceMappingURL=GameChanger.d.ts.map