sandstone 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/core/nodes.d.ts

@@ -1,88 +0,0 @@
-import type { SandstonePack } from "../pack/index.js";
-import * as util from 'util';
-import type { MCFunctionClass, MCFunctionNode } from "./resources/datapack/index.js";
-import type { SandstoneCore } from "./sandstoneCore.js";
-export declare abstract class Node {
-    sandstoneCore: SandstoneCore;
-    constructor(sandstoneCore: SandstoneCore);
-    [util.inspect.custom](_depth: number, _options: any): string;
-    abstract getValue(): any;
-    type: string;
-}
-/**
- * A node that includes other nodes.
- */
-export declare abstract class ContainerNode extends Node {
-    _body: Node[];
-    constructor(sandstoneCore: SandstoneCore);
-    get body(): Node[];
-    set body(body: Node[]);
-    generateBody(callback: () => void): Node[];
-    /**
-     * Appends a node at the end of this node's body.
-     */
-    append<NODE extends Node>(node: NODE): NODE;
-    /**
-     * Appends several nodes at the end of this node's body.
-     */
-    append<NODES extends Node[]>(...nodes: NODES): NODES;
-    /**
-     * Prepends a node to the beginning of this node's body.
-     */
-    prepend<NODE extends Node>(node: NODE): NODE;
-    /**
-     * Prepends several nodes to the beginning of this node's body.
-     */
-    prepend<NODES extends Node[]>(...nodes: NODES): NODES;
-    [util.inspect.custom](depth: number, options: any): string;
-}
-/**
- * A node that represents a generic command.
- */
-export declare abstract class CommandNode<ARGS extends unknown[] = unknown[]> extends Node {
-    sandstonePack: SandstonePack;
-    abstract command: string;
-    args: ARGS;
-    commited: boolean;
-    isMacro: boolean;
-    constructor(sandstonePack: SandstonePack, ...args: ARGS);
-    getValue(): string;
-    /**
-     * Commits the command to the current MCFunction context.
-     */
-    commit(): void | this;
-    [util.inspect.custom](depth: number, options: any): string;
-}
-/**
- * A node that includes other nodes.
- */
-export declare abstract class ContainerCommandNode<ARGS extends unknown[] = unknown[]> extends CommandNode<ARGS> implements ContainerNode {
-    abstract command: string;
-    _body: Node[];
-    constructor(sandstonePack: SandstonePack, ...args: ARGS);
-    get body(): Node[];
-    set body(body: Node[]);
-    generateBody(callback: () => void): Node[];
-    /**
-     * Appends a node at the end of this node's body.
-     */
-    append(node: Node): Node;
-    /**
-     * Appends a node at the end of this node's body.
-     */
-    prepend(node: Node): Node;
-    [util.inspect.custom](depth: number, options: any): string;
-    /**
-     * Create a MCFunction from this node.
-     * It shouldn't be added to Sandstone's core.
-     *
-     * The returned node will replace
-     */
-    createMCFunction: (currentMCFunction: MCFunctionNode | null) => {
-        node: Node | Node[];
-        mcFunction?: MCFunctionNode;
-    };
-}
-export declare abstract class AwaitNode extends ContainerCommandNode {
-    mcfunction: MCFunctionClass<any, any>;
-}

package/dist/core/resources/datapack/mcfunction.d.ts

@@ -1,159 +0,0 @@
-import type { TimeArgument } from "../../../arguments/basics.js";
-import type { NBTSerializable } from "../../../arguments/nbt.js";
-import type { ScheduleType } from "../../../commands/index.js";
-import type { FinalCommandOutput } from "../../../commands/helpers.js";
-import type { ContainerCommandNode, MacroArgument, Node, ResourceClassArguments, ResourceNode, SandstoneCore } from "../../../core/index.js";
-import * as util from 'util';
-import type { MakeInstanceCallable } from "../../../utils.js";
-import { ContainerNode } from "../../nodes.js";
-import { CallableResourceClass } from "../resource.js";
-import { TagClass } from "./tag.js";
-/**
- * A node representing a Minecraft function.
- */
-export declare class MCFunctionNode extends ContainerNode implements ResourceNode {
-    resource: MCFunctionClass<any, any>;
-    contextStack: (ContainerNode | ContainerCommandNode)[];
-    constructor(sandstoneCore: SandstoneCore, resource: MCFunctionClass<any, any>);
-    /**
-     * The currently active context.
-     *
-     * For example, the current context is the function body if the function is not in a loop.
-     * If the function is in a loop, the current context is the loop body.
-     */
-    get currentContext(): ContainerNode | ContainerCommandNode<unknown[]>;
-    /**
-     * Sequentially add node(s) to the end of the body of the function.
-     *
-     * @param node The node(s) to add.
-     */
-    appendNode: (node: Node | Node[]) => void;
-    /**
-     * Sequentially add node(s) to the beginning of the body of the function.
-     *
-     * @param node The node(s) to add.
-     */
-    prependNode: (node: Node | Node[]) => void;
-    /**
-     * Switch the current context to the given node.
-     * Also adds the node to the body of the current context, except if addNode is False.
-     *
-     * @param node The node to switch to.
-     * @param addNode Whether to add the node to the body of the current context.
-     */
-    enterContext: (node: ContainerNode | ContainerCommandNode, addNode?: boolean) => void;
-    /**
-     * Switch the current context to the given node, run the given function, and switch back to the original context.
-     * Also adds the node to the body of the current context, except if addNode is False.
-     *
-     * @param node The node to switch to.
-     * @param callback The function to run.
-     * @param addNode Whether to add the node to the body of the current context.
-     *
-     * @return The previously active context.
-     * @throws Error if there is no previous context.
-     */
-    insideContext: (node: ContainerNode | ContainerCommandNode, callback: () => void, addNode?: boolean) => ContainerNode | ContainerCommandNode<unknown[]> | undefined;
-    /**
-     * Leave the current context, and return to the previous one.
-     *
-     * @return The previously active context.
-     * @throws Error if there is no previous context.
-     */
-    exitContext: () => ContainerNode | ContainerCommandNode<unknown[]> | undefined;
-    getValue: () => string;
-    [util.inspect.custom](depth: number, options: any): string;
-}
-export type MCFunctionClassArguments = {
-    /**
-     * The callback to run when the MCFunction is generated.
-     *
-     * @default () => {}
-     */
-    callback?: (...params: [
-        loop: MCFunctionClass<any, any>,
-        ...params: MacroArgument[]
-    ]) => void;
-    /**
-     * If true, then the function will only be created if it is called from another function.
-     */
-    lazy?: boolean;
-    /**
-     * Whether the function should run when the datapack loads.
-     *
-     * Defaults to `true` if `runEvery` is specified, else `false`.
-     *
-     * Incompatible with macro parameters.
-     */
-    runOnLoad?: boolean;
-    /**
-     * The function tags to put this function in.
-     */
-    tags?: readonly (string | TagClass<'function'>)[];
-    /**
-     * If specified, the function will run every given time.
-     *
-     * If `runOnLoad` is unspecified or `true`, then it will run on load too.
-     *
-     * If `runOnLoad` is `false`, you will have to manually start it.
-     *
-     * You can stop the automatic scheduling by running `theFunction.clearSchedule()`.
-     *
-     * Incompatible with macro parameters.
-     *
-     * @example
-     *
-     * // Run every 5 ticks, including on datapack load.
-     * {
-     *   runEvery: 5,
-     * }
-     *
-     * // Run every 5 ticks, but wait until 5 ticks after the datapack loads for 1st execution.
-     * {
-     *   runEvery: 5,
-     *   runOnLoad: false,
-     * }
-     *
-     * // Run every 8 seconds
-     * {
-     *   runEvery: '8s'
-     * }
-     */
-    runEvery?: TimeArgument;
-    /**
-     * Whether the function should run each tick.
-     *
-     * Incompatible with macro parameters.
-     */
-    runEveryTick?: boolean;
-    /**
-     * Optional. Whether to retain the execution context through async calls. Defaults to false.
-     */
-    asyncContext?: boolean;
-} & ResourceClassArguments<'function'>;
-export declare class _RawMCFunctionClass<PARAMS extends readonly MacroArgument[] | undefined, ENV extends readonly MacroArgument[] | undefined> extends CallableResourceClass<MCFunctionNode> implements NBTSerializable {
-    static readonly resourceType = "function";
-    callback: NonNullable<MCFunctionClassArguments['callback']>;
-    nested: number;
-    asyncContext: NonNullable<MCFunctionClassArguments['asyncContext']>;
-    constructor(core: SandstoneCore, name: string, args: MCFunctionClassArguments, env?: ENV);
-    private generated;
-    protected addToTag: (tag: string) => void;
-    __call__: (..._params: PARAMS extends undefined ? [
-    ] : PARAMS) => FinalCommandOutput;
-    schedule: {
-        clear: () => FinalCommandOutput;
-        function: (delay: TimeArgument, type: ScheduleType) => FinalCommandOutput;
-    };
-    push(...contents: _RawMCFunctionClass<PARAMS, ENV>[] | [
-        () => any
-    ]): void;
-    unshift(...contents: _RawMCFunctionClass<PARAMS, ENV>[] | [
-        () => any
-    ]): void;
-    splice(start: number, removeItems: number | 'auto', ...contents: _RawMCFunctionClass<PARAMS, ENV>[] | [
-        () => void
-    ]): void;
-}
-export declare const MCFunctionClass: import("../../../utils.js").MakeClassCallable<typeof _RawMCFunctionClass>;
-export type MCFunctionClass<PARAMS extends readonly MacroArgument[] | undefined = undefined, ENV extends readonly MacroArgument[] | undefined = undefined> = MakeInstanceCallable<_RawMCFunctionClass<PARAMS, ENV>> & NBTSerializable;

package/dist/core/resources/datapack/structure.d.ts

@@ -1,108 +0,0 @@
-import { type SymbolEntity, type Registry, type Coordinates, type RootNBT } from "../../../arguments/index.js";
-import type { ResourceClassArguments, ResourceNode, SandstoneCore } from "../../../core/index.js";
-import type { DataPointClass, Score, StructureMirror, StructureRotation } from "../../../variables/index.js";
-import { ContainerNode } from "../../nodes.js";
-import { ResourceClass } from "../resource.js";
-import type { StructureNBT } from "../../../arguments/generated/data/structure.js";
-/**
- * A node representing a Minecraft structure.
- */
-export declare class StructureNode extends ContainerNode implements ResourceNode<StructureClass> {
-    resource: StructureClass;
-    constructor(sandstoneCore: SandstoneCore, resource: StructureClass);
-    getValue: () => Buffer<ArrayBufferLike> | Promise<Buffer<ArrayBufferLike>> | undefined;
-}
-type Block = {
-    id: Registry['minecraft:block'];
-    state?: {
-        [key: string]: string;
-    };
-    /** Must use NBT Primitives! */
-    nbt?: RootNBT;
-};
-type StructureEntry = {
-    block?: Block | Block[];
-    entities?: [
-        ({
-            [ID in Registry['minecraft:entity_type']]: {
-                id: ID;
-                nbt?: ID extends keyof SymbolEntity ? SymbolEntity[ID] : RootNBT;
-                offset?: [
-                    number,
-                    number,
-                    number
-                ];
-            };
-        }[Registry['minecraft:entity_type']])
-    ];
-};
-export type StructureClassArguments = {
-    /**
-     * Either:
-     * - Path in existing resources
-     * - Structure's NBT
-     * - Existing Structure definition
-     * - 3D Array representing the structure. Longest entry will be counted as bounds, missing or empty elements will be counted as air from origin.
-     */
-    structure?: string | StructureNBT | StructureClass | [
-        [
-            [
-                StructureEntry
-            ]
-        ]
-    ];
-} & ResourceClassArguments<'default'>;
-type VariableInsertion = Score | DataPointClass<'storage'>;
-export declare class StructureClass extends ResourceClass<StructureNode> {
-    static readonly resourceType: "structure";
-    structureBuffer?: Promise<Buffer>;
-    structureNBT?: StructureNBT;
-    constructor(sandstoneCore: SandstoneCore, name: string, args: StructureClassArguments);
-    structure(): StructureNBT | Promise<Buffer>;
-    readBuffer(): Promise<void>;
-    array(): Promise<[
-        [
-            [
-                StructureEntry
-            ]
-        ]
-    ]>;
-    arrayToNBT(array: [
-        [
-            [
-                StructureEntry
-            ]
-        ]
-    ]): StructureNBT;
-    /**
-     * Places the structure.
-     *
-     * Usage of `VariableInsertion` or `xz` will result in a structure block being used.
-     *
-     * @param pos Optional. Where to place relative to the current location.
-     * @param rotation Optional. Rotation to apply to the structure.
-     * @param mirror Optional. Mirroring to apply to the structure. `xz` will clear all existing blocks in the region, only works for structures with defined size, & will await structures not in memory.
-     * @param integrity Optional. How complete the structure will be. Must be a float between 1.0 & 0.0 (inclusive), if below 1 the structure will be randomly degraded.
-     * @param seed Optional. Integer applied to the integrity random. Defaults to 0.
-     */
-    load(pos?: [
-        number,
-        number,
-        number
-    ], rotation?: StructureRotation | VariableInsertion, mirror?: StructureMirror | '^xz' | 'xz' | VariableInsertion, integrity?: number | VariableInsertion, seed?: number | VariableInsertion): Promise<void>;
-    save(_pos: (Coordinates<false> | [
-        Score,
-        Score,
-        Score
-    ]) | undefined, _size: [
-        number,
-        number,
-        number
-    ] | [
-        Score,
-        Score,
-        Score
-    ]): void;
-    toString(): `${string}:${string}`;
-}
-export {};

package/dist/core/resources/datapack/variant.d.ts

@@ -1,39 +0,0 @@
-import type { SymbolResource } from "../../../arguments/index.js";
-import { ContainerNode } from "../../nodes.js";
-import type { SandstoneCore } from "../../sandstoneCore.js";
-import type { ResourceClassArguments, ResourceNode } from "../resource.js";
-import { ResourceClass } from "../resource.js";
-export type AudibleVariantType = ('cat' | 'chicken' | 'cow' | 'pig' | 'wolf');
-/**
- * All supported variant types.
- */
-export type VariantType = ('frog' | 'painting' | 'zombie_nautilus' | AudibleVariantType | `${AudibleVariantType}_sound`);
-/**
- * Maps variant types to their SymbolResource keys.
- */
-type VariantSymbolKey<T extends VariantType> = `${T}_variant`;
-/**
- * Gets the JSON type for a variant from SymbolResource.
- */
-type VariantJSON<T extends VariantType> = SymbolResource[VariantSymbolKey<T>];
-/**
- * A node representing a Minecraft entity variant.
- */
-export declare class VariantNode<T extends VariantType> extends ContainerNode implements ResourceNode<VariantClass<T>> {
-    resource: VariantClass<T>;
-    constructor(sandstoneCore: SandstoneCore, resource: VariantClass<T>);
-    getValue: () => string;
-}
-export type VariantClassArguments<T extends VariantType> = {
-    /**
-     * The variant's JSON.
-     */
-    variant: VariantJSON<T>;
-} & ResourceClassArguments<'default'>;
-export declare class VariantClass<T extends VariantType> extends ResourceClass<VariantNode<T>> {
-    variantType: T;
-    static readonly resourceType = "variant";
-    variantJSON: NonNullable<VariantJSON<T>>;
-    constructor(sandstoneCore: SandstoneCore, variantType: T, name: string, args: VariantClassArguments<T>);
-}
-export {};

package/dist/core/resources/resource.d.ts

@@ -1,94 +0,0 @@
-import type fs from 'fs-extra';
-import type { SandstoneCommands } from "../../commands/commands.js";
-import type { Node, SandstoneCore } from "../../core/index.js";
-import type { ResourcePath, SandstonePack } from "../../pack/index.js";
-import type { PackType } from "../../pack/packType.js";
-import type { BASIC_CONFLICT_STRATEGIES, LiteralUnion, MakeInstanceCallable } from "../../utils.js";
-import type { NBTSerializable } from "../../arguments/nbt.js";
-export type ResourceClassArguments<ConflictType extends 'default' | 'list' | 'function'> = {
-    /**
-     * Whether the associated Node should be added to Sandstone Core.
-     */
-    addToSandstoneCore: boolean;
-    /**
-     * Whether the resource has been created explicitely by a user, or automatically generated by Sandstone.
-     */
-    creator: 'user' | 'sandstone';
-    /**
-     * What to do if another resource of the same type has the same name.
-     *
-     * - `throw`: Throw an error.
-     * - `replace`: Replace silently the old resource with the new one.
-     * - `ignore`: Keep silently the old resource, discarding the new one.
-     * - `append`: Append the new resource entries to the old one.
-     * - `prepend`: Prepend the new resource entries to the old one.
-     * - `rename`: Rename the new file to an iterating number (ie. func1, func2, func3)
-     */
-    onConflict?: ConflictType extends 'default' ? BASIC_CONFLICT_STRATEGIES : BASIC_CONFLICT_STRATEGIES | 'append' | 'prepend';
-    /**
-     * Overrides the default pack for the resource.
-     */
-    packType?: PackType;
-};
-export type ResourceNode<T = ResourceClass<any>> = Node & {
-    resource: T;
-};
-export type ResourceNodeConstructor<N extends Node> = new (sandstoneCore: SandstoneCore, resource: any) => N;
-export declare abstract class ResourceClass<N extends ResourceNode = ResourceNode<any>> implements NBTSerializable {
-    protected core: SandstoneCore;
-    protected _resourceType: string;
-    node: N;
-    packType: PackType;
-    fileExtension: string;
-    fileEncoding: false | "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | fs.ObjectEncodingOptions;
-    creator: NonNullable<ResourceClassArguments<any>['creator']>;
-    commands: SandstoneCommands<false>;
-    pack: SandstonePack;
-    path: ResourcePath;
-    addToSandstoneCore: boolean;
-    onConflict: LiteralUnion<BASIC_CONFLICT_STRATEGIES>;
-    renameIndex: number;
-    constructor(core: SandstoneCore, file: {
-        packType: PackType;
-        extension?: string;
-        encoding?: fs.EncodingOption | false;
-    }, NodeType: ResourceNodeConstructor<N>, _resourceType: string, path: ResourcePath, args: ResourceClassArguments<any>);
-    protected handleConflicts(): void;
-    protected getNode: () => N;
-    get name(): `${string}:${string}`;
-    get namespace(): string;
-    generate: () => void;
-    toString(): string;
-    toNBT(): string;
-}
-export declare abstract class CallableResourceClass<N extends ResourceNode = ResourceNode<any>> extends ResourceClass<N> {
-    private _that;
-    protected get asCallable(): MakeInstanceCallable<this>;
-    abstract __call__: (...args: any) => any;
-}
-export declare abstract class ListResource {
-    push(..._args: any[]): void;
-    unshift(..._args: any[]): void;
-}
-/**
- * A Map-like structure to store ResourceNodes, allowing for easy iteration and management of resources.
- * It uses the resource's path + packType as the key, ensuring that resources with the same path are treated as the same resource.
- */
-export declare class ResourceNodesMap<T extends ResourceNode = ResourceNode> {
-    private nodes;
-    constructor(iterable?: Iterable<T>);
-    forEach(callback: (value: T) => void): void;
-    private getKey;
-    add(value: T): this;
-    delete(value: T): boolean;
-    clear(): void;
-    [Symbol.iterator](): Iterator<T>;
-    get size(): number;
-    /**
-     * Check if a resource node is present in the set, **based on its path and packType**, and returns it.
-     * @param node The resource node to check.
-     * @returns The resource node if it exists, otherwise `undefined`.
-     */
-    get(node: T): T | undefined;
-}
-export declare function jsonStringify(json: any): string;

package/dist/core/resources/resourcepack/itemDefinition.d.ts

@@ -1,109 +0,0 @@
-import type { ItemDefinition, ItemModel, NumericPropertyType, RangeDispatch, Select, SelectPropertyType, SpecialModel } from "../../../arguments/generated/assets/item_definition.js";
-import type { ModelRef } from "../../../arguments/generated/assets/model.js";
-import { ContainerNode } from "../../nodes.js";
-import type { SandstoneCore } from "../../sandstoneCore.js";
-import type { ResourceClassArguments, ResourceNode } from "../resource.js";
-import { ResourceClass } from "../resource.js";
-import { ItemPredicateClass } from "../../../variables/ItemPredicate.js";
-import type { SandstonePack } from "../../../pack/index.js";
-/**
- * Builder for creating item model definitions.
- * Extends ItemPredicateClass to inherit predicate methods (has, without, exact, match, etc.)
- * and adds model-specific methods for building ItemModel JSON.
- */
-export declare class ItemModelBuilder extends ItemPredicateClass {
-    private onTrueModel?;
-    private onFalseModel?;
-    private explicitModel?;
-    private _handAnimationOnSwap?;
-    private _oversizedInGui?;
-    private _swapAnimationScale?;
-    constructor(pack: SandstonePack);
-    /**
-     * Specify the model to use when all conditions match.
-     * @param model The ItemModel or model reference string
-     */
-    onTrue(model: ItemModel | ModelRef): this;
-    /**
-     * Specify the model to use when any condition fails.
-     * @param model The ItemModel or model reference string
-     */
-    onFalse(model: ItemModel | ModelRef): this;
-    /**
-     * Create a composite model that renders multiple models layered together.
-     * @param models The models to compose
-     */
-    composite(...models: Array<ItemModel | ModelRef>): this;
-    /**
-     * Create a select model for value-based branching.
-     * @param property The select property type
-     * @param config Configuration including cases and optional fallback
-     */
-    select<P extends SelectPropertyType>(property: P, config: Omit<Extract<Select, {
-        property: P | `minecraft:${P}`;
-    }>, 'type' | 'property'>): this;
-    /**
-     * Create a range dispatch model for numeric range-based selection.
-     * @param property The numeric property type
-     * @param config Configuration including entries and optional fallback
-     */
-    rangeDispatch<P extends NumericPropertyType>(property: P, config: Omit<Extract<RangeDispatch, {
-        property: P | `minecraft:${P}`;
-    }>, 'type' | 'property'>): this;
-    /**
-     * Create a special model for hardcoded rendering (heads, banners, etc.).
-     * @param model The special model configuration
-     * @param base The base model reference providing transformations
-     */
-    special(model: SpecialModel, base: ModelRef): this;
-    /**
-     * Create an empty model that renders nothing.
-     */
-    empty(): this;
-    /**
-     * Set whether the down-and-up animation should be played when the item stack is changed.
-     * @param enabled Whether to enable the animation (defaults to true in Minecraft)
-     */
-    handAnimationOnSwap(enabled: boolean): this;
-    /**
-     * Set whether the item model is allowed to be bigger than its item slot.
-     * @param enabled Whether to allow oversized display (defaults to false in Minecraft)
-     */
-    oversizedInGui(enabled: boolean): this;
-    /**
-     * Set how fast the item moves up and down when swapping items in hotbar.
-     * @param scale The animation scale (defaults to 1.0 in Minecraft)
-     */
-    swapAnimationScale(scale: number): this;
-    /**
-     * Build the ItemModel JSON from the builder configuration.
-     */
-    toItemModel(): ItemModel;
-    /**
-     * Build the complete ItemModelDefinition JSON including model and options.
-     */
-    toItemModelDefinition(): ItemDefinition;
-    private buildFromPredicates;
-    private buildNestedConditions;
-    private testToCondition;
-}
-export declare class ItemModelDefinitionNode extends ContainerNode implements ResourceNode<ItemModelDefinitionClass> {
-    resource: ItemModelDefinitionClass;
-    constructor(sandstoneCore: SandstoneCore, resource: ItemModelDefinitionClass);
-    getValue: () => string;
-}
-export type ItemModelDefinitionInput = ItemDefinition | ItemModel | ItemModelBuilder | ((builder: ItemModelBuilder) => ItemModelBuilder);
-export type ItemModelDefinitionClassArguments = {
-    definition: ItemModelDefinitionInput;
-} & ResourceClassArguments<'default'>;
-/**
- * Resource class for item definitions (items/*.json in resource packs).
- * Controls how items are rendered based on their components and state.
- */
-export declare class ItemModelDefinitionClass extends ResourceClass<ItemModelDefinitionNode> {
-    static readonly resourceType = "item_definition";
-    itemDefinitionJSON: ItemDefinition;
-    constructor(core: SandstoneCore, name: string, args: ItemModelDefinitionClassArguments);
-    private resolveDefinitionInput;
-    toString: () => string;
-}

package/dist/core/sandstoneCore.d.ts

@@ -1,64 +0,0 @@
-import fs from 'fs-extra';
-import type { SandstonePack } from "../pack/index.js";
-import { MCMetaCache } from "./mcmeta.js";
-import type { AwaitNode } from "./nodes.js";
-import type { _RawMCFunctionClass, MCFunctionClass, MCFunctionNode } from "./resources/datapack/mcfunction.js";
-import { type ResourceClass, ResourceNodesMap } from "./resources/resource.js";
-import { SmithedDependencyCache } from "./smithed.js";
-import type { GenericCoreVisitor } from "./visitors.js";
-export declare class SandstoneCore {
-    pack: SandstonePack;
-    /** All Resources */
-    resourceNodes: ResourceNodesMap;
-    mcfunctionStack: MCFunctionNode[];
-    awaitNodes: Set<AwaitNode>;
-    currentNode: string;
-    _mcMetaCache: MCMetaCache | undefined | false;
-    _smithed: SmithedDependencyCache | undefined | false;
-    dependencies: ((() => Promise<true | false>) | true | false)[];
-    constructor(pack: SandstonePack);
-    reset: () => void;
-    /**
-     * The current MCFunction.
-     */
-    get currentMCFunction(): MCFunctionNode | undefined;
-    getCurrentMCFunctionOrThrow: () => MCFunctionNode;
-    insideContext: MCFunctionNode['insideContext'];
-    /**
-     * Create a new MCFunction with the given name, and switch the currently active MCFunction to it.
-     * @param mcfunction The MCFunction to switch to.
-     * @return The newly created and active MCFunction.
-     */
-    enterMCFunction: (mcfunction: _RawMCFunctionClass<any, any> | MCFunctionClass<any, any>) => MCFunctionNode;
-    /**
-     * Leave the current MCFunction, and return to the previous one.
-     * @return The previously active MCFunction.
-     */
-    exitMCFunction: () => MCFunctionNode | undefined;
-    get mcMetaCache(): MCMetaCache;
-    getExistingResource(relativePath: string): Promise<string>;
-    getExistingResource(relativePath: string, encoding: false): Promise<Buffer>;
-    getExistingResource(relativePath: string, encoding: fs.EncodingOption): Promise<Buffer | string>;
-    getExistingResource(resource: ResourceClass, encoding?: 'utf-8'): Promise<string>;
-    getExistingResource(resource: ResourceClass, encoding: false | fs.EncodingOption): Promise<Buffer>;
-    getVanillaResource(relativePath: string): Promise<string>;
-    getVanillaResource(relativePath: string, text: true, type: 'client' | 'server'): Promise<string>;
-    getVanillaResource(relativePath: string, text: false, type: 'client' | 'server'): Promise<Buffer>;
-    get smithed(): SmithedDependencyCache;
-    /**
-     * Add a dependency for a Smithed Library
-     *
-     * @returns Index of the async dependency request in SandstoneCore#dependencies
-     */
-    depend(dependency: string, version?: string): number;
-    generateResources: (opts: {
-        visitors: GenericCoreVisitor[];
-    }) => ResourceNodesMap<import("./resources/index.js").ResourceNode<ResourceClass<any>>>;
-    save: (cliOptions: {
-        fileHandler: (relativePath: string, content: any) => Promise<void>;
-        dry: boolean;
-        verbose: boolean;
-    }, opts: {
-        visitors: GenericCoreVisitor[];
-    }) => Promise<void>;
-}