sandstone 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/arguments/selector.d.ts

@@ -68,7 +68,7 @@ export type SinglePlayerArgument<MACRO extends boolean = false> = SinglePlayerSt
  * - Accepts: SelectorPickClass<true, boolean> (picked single entity)
  * - Accepts: UUIDClass<any> (entity UUID)
  */
-export type SingleEntityArgument<MACRO extends boolean = false> = SingleEntityStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | UUIDClass<any> | _ShowAlias;
+export type SingleEntityArgument<MACRO extends boolean = false> = SingleEntityStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | SelectorClass<MACRO, true, boolean> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | UUIDClass<any> | _ShowAlias;
 /**
  * Argument for commands that allow multiple players to be targeted.
  * - Accepts: '@a' | '@p' | '@r' | '@s' (player-targeting selectors)
@@ -76,7 +76,7 @@ export type SingleEntityArgument<MACRO extends boolean = false> = SingleEntitySt
  * - Accepts: SelectorClass<MACRO, boolean, true> (player-only selector, single or multiple)
  * - Accepts: SelectorPickClass<boolean, boolean> (picked entity - player not enforced at type level)
  */
-export type MultiplePlayersArgument<MACRO extends boolean = false> = MultiplePlayerStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, false, true> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | SelectorPickClass<false, true> | SelectorPickClass<false, false> | SelectorPickClass<false, boolean> | SelectorPickClass<boolean, boolean> | _ShowAlias;
+export type MultiplePlayersArgument<MACRO extends boolean = false> = MultiplePlayerStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, false, true> | SelectorClass<MACRO, boolean, true> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | SelectorPickClass<false, true> | SelectorPickClass<false, false> | SelectorPickClass<false, boolean> | SelectorPickClass<boolean, boolean> | _ShowAlias;
 /**
  * Argument for commands that allow multiple entities of any type to be targeted.
  * - Accepts: All selector literals ('@e' | '@a' | '@s' | '@p' | '@n' | '@r')
@@ -84,7 +84,7 @@ export type MultiplePlayersArgument<MACRO extends boolean = false> = MultiplePla
  * - Accepts: SelectorClass<MACRO, boolean, boolean> (any selector)
  * - Accepts: SelectorPickClass<boolean, boolean> (any picked entity)
  */
-export type MultipleEntitiesArgument<MACRO extends boolean = false> = MultipleEntityStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | SelectorClass<MACRO, false, true> | SelectorClass<MACRO, false, false> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | SelectorPickClass<false, true> | SelectorPickClass<false, false> | SelectorPickClass<false, boolean> | SelectorPickClass<boolean, boolean> | _ShowAlias;
+export type MultipleEntitiesArgument<MACRO extends boolean = false> = MultipleEntityStringArgument | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | SelectorClass<MACRO, true, boolean> | SelectorClass<MACRO, false, true> | SelectorClass<MACRO, false, false> | SelectorClass<MACRO, false, boolean> | SelectorClass<MACRO, boolean, true> | SelectorClass<MACRO, boolean, false> | SelectorClass<MACRO, boolean, boolean> | SelectorPickClass<true, true> | SelectorPickClass<true, false> | SelectorPickClass<true, boolean> | SelectorPickClass<false, true> | SelectorPickClass<false, false> | SelectorPickClass<false, boolean> | SelectorPickClass<boolean, boolean> | _ShowAlias;
 /**
  * Matches SelectorPickClass instances that are NOT SelectorClass.
  * SelectorClass has __selectorBrand, other SelectorPickClass subclasses (UUIDClass, EntityLabel) don't.
@@ -105,7 +105,7 @@ type PureSelectorPickClass<IsSingle extends boolean, IsPlayer extends boolean> =
  * foo('@e')  // Error: '@e' is not assignable to 'never'
  * ```
  */
-export type SinglePlayerArgumentOf<MACRO extends boolean, T extends string> = ValidateSinglePlayerString<T> | SelectorClass<MACRO, true, true> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean>;
+export type SinglePlayerArgumentOf<MACRO extends boolean, T extends string> = ValidateSinglePlayerString<T> | SinglePlayerSelectorLiteral | SelectorClass<MACRO, true, true> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean>;
 /**
  * Generic version of SingleEntityArgument that validates string literals.
  * Use this with a generic type parameter to reject invalid selectors like '@e' or '@a'.
@@ -117,10 +117,10 @@ export type SinglePlayerArgumentOf<MACRO extends boolean, T extends string> = Va
  * foo('@e')  // Error: '@e' is not assignable to 'never'
  * ```
  */
-export type SingleEntityArgumentOf<MACRO extends boolean, T extends string> = ValidateSingleEntityString<T> | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean> | UUIDClass<any>;
+export type SingleEntityArgumentOf<MACRO extends boolean, T extends string> = ValidateSingleEntityString<T> | SingleEntitySelectorLiteral | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, true, false> | SelectorClass<MACRO, true, boolean> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean> | UUIDClass<any>;
 /**
  * Generic version of MultiplePlayersArgument that validates string literals.
  * Use this with a generic type parameter to reject invalid selectors like '@e' or '@n'.
  */
-export type MultiplePlayersArgumentOf<MACRO extends boolean, T extends string> = ValidateMultiplePlayersString<T> | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, false, true> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean> | PureSelectorPickClass<false, true> | PureSelectorPickClass<false, false> | PureSelectorPickClass<false, boolean> | PureSelectorPickClass<boolean, boolean>;
+export type MultiplePlayersArgumentOf<MACRO extends boolean, T extends string> = ValidateMultiplePlayersString<T> | MultiplePlayerSelectorLiteral | SelectorClass<MACRO, true, true> | SelectorClass<MACRO, false, true> | SelectorClass<MACRO, boolean, true> | PureSelectorPickClass<true, true> | PureSelectorPickClass<true, false> | PureSelectorPickClass<true, boolean> | PureSelectorPickClass<false, true> | PureSelectorPickClass<false, false> | PureSelectorPickClass<false, boolean> | PureSelectorPickClass<boolean, boolean>;
 export {};

package/dist/commands/implementations/block/setblock.d.ts

@@ -3,18 +3,15 @@ import type { Macroable } from "../../../core/index.js";
 import { CommandNode } from "../../../core/nodes.js";
 import type { FinalCommandOutput } from "../../helpers.js";
 import { CommandArguments } from "../../helpers.js";
-import type { BLOCKS_SET } from "../../../arguments/generated/_registry/blocks.js";
-import type { NamespacedLiteralUnion, SetType } from "../../../utils.js";
+import type { NamespacedLiteralUnion } from "../../../utils.js";
 /** Converts stringified boolean/numeric literals to actual booleans/numbers */
-export type ParseLiteral<T> = T extends 'true' | 'false' ? boolean : T extends `${infer N extends number}` ? N : T;
+export type ParseLiteral<T> = (T extends 'true' | 'false' ? boolean : T extends `${infer N extends number}` ? N : T);
 /** Converts block state types from stringified literals to proper primitives */
 export type ParseBlockState<T> = {
     [K in keyof T]: ParseLiteral<T[K]>;
 };
-export type BlockEntityName = keyof SymbolBlock;
-export type BlockEntity = NamespacedLiteralUnion<BlockEntityName>;
-export type BlockStaticName = keyof Omit<Record<SetType<typeof BLOCKS_SET>, false>, BlockEntityName>;
-export type BlockStatic = (NamespacedLiteralUnion<BlockStaticName> | `minecraft:${BlockStaticName}`);
+export type BlockEntity = NamespacedLiteralUnion<keyof SymbolBlock>;
+export type BlockStatic = NamespacedLiteralUnion<Exclude<keyof SymbolMcdocBlockStates, keyof SymbolBlock>>;
 export declare class SetBlockCommandNode extends CommandNode {
     command: "setblock";
 }
@@ -67,7 +64,7 @@ export declare class SetBlockCommand<MACRO extends boolean> extends CommandArgum
      * setblock([spawn.x, spawn.y, spawn.z], 'minecraft:stone_brick_wall', { up: true }, 'strict')
      * ```
      */
-    setblock<BLOCK extends Macroable<BlockStatic, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[BLOCK]>> : Record<string, string | boolean | number>, MACRO>, type?: 'destroy' | 'keep' | 'replace' | 'strict'): FinalCommandOutput;
+    setblock<BLOCK extends Macroable<BlockStatic, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number>, MACRO>, type?: 'destroy' | 'keep' | 'replace' | 'strict'): FinalCommandOutput;
     /**
      * Place a block with NBT data at the specified coordinates.
      *
@@ -118,6 +115,6 @@ export declare class SetBlockCommand<MACRO extends boolean> extends CommandArgum
      * })
      * ```
      */
-    setblock<BLOCK extends Macroable<BlockEntity, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[BLOCK]>> : Record<string, string | boolean | number>, MACRO>, nbt?: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[BLOCK]> : SymbolBlock<'%fallback'>, MACRO>, type?: 'destroy' | 'keep' | 'replace' | 'strict'): FinalCommandOutput;
+    setblock<BLOCK extends Macroable<BlockEntity, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number>, MACRO>, nbt?: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]> : SymbolBlock<'%fallback'>, MACRO>, type?: 'destroy' | 'keep' | 'replace' | 'strict'): FinalCommandOutput;
 }
 export declare function blockStateStringifier(state: Record<string, string | number | boolean>): string;

package/dist/commands/implementations/entity/execute.d.ts

@@ -1,5 +1,4 @@
 import type { ANCHORS, AXES, Registry, COMPARISON_OPERATORS, ContainerSlotSelector, Coordinates, EntitySlotSelector, MultipleEntitiesArgument, ObjectiveArgument, Range, Rotation, SingleEntityArgumentOf, SymbolBlock, SymbolMcdocBlockStates } from "../../../arguments/index.js";
-import type { BlockStatic, ParseBlockState } from "../block/setblock.js";
 import type { SandstoneCommands } from "../../../commands/index.js";
 import { type MacroArgument, type Macroable, type MCFunctionNode, type PredicateClass } from "../../../core/index.js";
 import type { Node } from "../../../core/nodes.js";
@@ -16,10 +15,13 @@ export type SubCommand = [
     subcommand: string,
     ...args: unknown[]
 ];
-type BlockEntityName = keyof SymbolBlock;
-type BlockEntity = NamespacedLiteralUnion<BlockEntityName>;
+type ParseLiteral<T> = (T extends 'true' | 'false' ? boolean : T extends `${infer N extends number}` ? N : T);
+type ParseBlockState<T> = {
+    [K in keyof T]: ParseLiteral<T[K]>;
+};
+type BlockEntity = NamespacedLiteralUnion<keyof SymbolBlock>;
+type BlockStatic = NamespacedLiteralUnion<Exclude<keyof SymbolMcdocBlockStates, keyof SymbolBlock>>;
 export declare class ExecuteCommandPart<MACRO extends boolean> extends CommandArguments<typeof ExecuteCommandNode> {
-    protected nestedExecute: (args: SubCommand, executable?: boolean) => ExecuteCommand<MACRO>;
 }
 export type StoreType = 'byte' | 'short' | 'int' | 'long' | 'float' | 'double';
 export type RelationType = 'attacker' | 'controller' | 'leasher' | 'origin' | 'owner' | 'passengers' | 'target' | 'vehicle';
@@ -43,13 +45,24 @@ export declare class ExecuteCommandNode extends ContainerCommandNode<SubCommand[
      * `function <name> with storage <macroStorage>`. This enables macro variables
      * from the storage to be used in the execute command.
      */
-    macroStorage: string | undefined;
-    constructor(sandstonePack: SandstonePack, args?: SubCommand[], { isFake, isSingleExecute, givenCallbackName, body, macroStorage, }?: {
+    macroStorage: DataPointClass | undefined;
+    /**
+     * If true, this execute node should be committed to its parent context after its body receives a command.
+     * This is set when .run is accessed and the execute hasn't been committed yet.
+     */
+    pendingCommit: boolean;
+    /**
+     * The MCFunction created by createMCFunction, if any.
+     * Used by LoopArgument to reference the loop function.
+     */
+    createdMCFunction: _RawMCFunctionClass<any, any> | null;
+    constructor(sandstonePack: SandstonePack, args?: SubCommand[], { isFake, isSingleExecute, givenCallbackName, body, macroStorage, pendingCommit, }?: {
         isFake?: boolean | undefined;
         isSingleExecute?: boolean | undefined;
         givenCallbackName?: string | undefined;
         body?: Node[] | undefined;
-        macroStorage?: string | undefined;
+        macroStorage?: DataPointClass<any> | undefined;
+        pendingCommit?: boolean | undefined;
     });
     get callbackName(): string;
     append: (...nodes: Node[]) => any;
@@ -102,20 +115,13 @@ export declare class ExecuteStoreArgsCommand<MACRO extends boolean> extends Exec
      */
     entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, path: Macroable<string, MACRO>, type: Macroable<StoreType, MACRO>, scale?: Macroable<number, MACRO>) => ExecuteCommand<MACRO>;
     /**
-     * Overrides the given score with the final command's return value.
+     * Overrides the given scores with the final command's return value.
      *
      * @param targets Specifies score holder(s) whose score is to be overridden.
      *
      * @param objective A scoreboard objective.
-     *
-     * @param playerScore The player's score to override.
      */
-    score(...args: [
-        targets: Macroable<MultipleEntitiesArgument<MACRO>, MACRO>,
-        objective: Macroable<ObjectiveArgument, MACRO>
-    ] | [
-        playerScore: Macroable<Score, MACRO>
-    ]): ExecuteCommand<MACRO>;
+    score: (targets: Macroable<MultipleEntitiesArgument<MACRO>, MACRO>, objective: Macroable<ObjectiveArgument, MACRO>) => ExecuteCommand<MACRO>;
     /**
      * Uses the `path` within storage `target` to store the return value in.
      *
@@ -133,11 +139,20 @@ export declare class ExecuteStoreArgsCommand<MACRO extends boolean> extends Exec
      */
     storage: (target: Macroable<string, MACRO>, path: Macroable<string, MACRO>, type: Macroable<StoreType, MACRO>, scale?: Macroable<number, MACRO>) => ExecuteCommand<MACRO>;
 }
+type DropFirstArg<T> = (T extends {
+    (first: any, ...args: infer A1): infer R1;
+    (first: any, ...args: infer A2): infer R2;
+} ? {
+    (...args: A1): R1;
+    (...args: A2): R2;
+} : never);
 export declare class ExecuteStoreCommand<MACRO extends boolean> extends ExecuteCommandPart<MACRO> {
+    _storeCallable(cmd: ExecuteStoreArgsCommand<MACRO>, score: Score): ExecuteCommand<MACRO>;
+    _storeCallable(cmd: ExecuteStoreArgsCommand<MACRO>, dataPoint: DataPointClass<'entity'> | DataPointClass<'block'> | DataPointClass<'storage'>, type?: Macroable<StoreType, MACRO>, scale?: Macroable<number, MACRO>): ExecuteCommand<MACRO>;
     /** Store the final command's result value. */
-    get result(): ExecuteStoreArgsCommand<MACRO>;
+    get result(): ExecuteStoreArgsCommand<MACRO> & DropFirstArg<ExecuteStoreCommand<MACRO>["_storeCallable"]>;
     /** Store the final command's success value. */
-    get success(): ExecuteStoreArgsCommand<MACRO>;
+    get success(): ExecuteStoreArgsCommand<MACRO> & DropFirstArg<ExecuteStoreCommand<MACRO>["_storeCallable"]>;
 }
 export declare class ExecuteDataArgsCommand<MACRO extends boolean> extends ExecuteCommandPart<MACRO> {
     /**
@@ -249,7 +264,7 @@ export declare class ExecuteIfUnlessCommand<MACRO extends boolean> extends Execu
      * execute.if.block(abs(0, 64, 0), 'minecraft:oak_log', { axis: 'y' })
      * ```
      */
-    block<BLOCK extends Macroable<BlockStatic, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[BLOCK]>> : Record<string, string | boolean | number>, MACRO>): ExecuteCommand<MACRO>;
+    block<BLOCK extends Macroable<BlockStatic, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state?: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number>, MACRO>): ExecuteCommand<MACRO>;
     /**
      * Compares the block at a given position to a given block with NBT data.
      *
@@ -267,7 +282,7 @@ export declare class ExecuteIfUnlessCommand<MACRO extends boolean> extends Execu
      * execute.if.block(['~', '~', '~1'], 'minecraft:command_block', {}, { Command: 'say Hello' })
      * ```
      */
-    block<BLOCK extends Macroable<BlockEntity, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[BLOCK]>> : Record<string, string | boolean | number> | undefined, MACRO>, nbt: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[BLOCK]> : SymbolBlock<'%fallback'>, MACRO>): ExecuteCommand<MACRO>;
+    block<BLOCK extends Macroable<BlockEntity, MACRO>>(pos: Macroable<Coordinates<MACRO>, MACRO>, block: BLOCK, state: Macroable<BLOCK extends keyof SymbolMcdocBlockStates ? ParseBlockState<NonNullable<SymbolMcdocBlockStates[Extract<BLOCK, keyof SymbolMcdocBlockStates>]>> : Record<string, string | boolean | number> | undefined, MACRO>, nbt: Macroable<BLOCK extends keyof SymbolBlock ? NonNullable<SymbolBlock[Extract<BLOCK, keyof SymbolBlock>]> : SymbolBlock<'%fallback'>, MACRO>): ExecuteCommand<MACRO>;
     /**
      * Compares the blocks in two equally sized volumes.
      * @param start Start position of the first volume.
@@ -469,7 +484,7 @@ export type DeferredMacroExecuteOptions = {
     macroStorage?: never;
 } | {
     /** Explicit storage to use for the macro function call (e.g., '__sandstone:temp') */
-    macroStorage: string;
+    macroStorage: DataPointClass;
     env?: never;
 });
 /**

package/dist/commands/implementations/server/return.d.ts

@@ -11,11 +11,18 @@ export declare class ReturnRunCommandNode extends ContainerCommandNode {
      * This is set to `false` if the execute is used as a function (execute.run(() => { stuff })).
      */
     isSingleExecute: boolean;
+    /**
+     * When true, this return run is needed for flow control (e.g., if/elseIf early exit).
+     * When false, the return run was added for function boundary semantics and can be
+     * unwrapped when the function is inlined.
+     */
+    isFlowControl: boolean;
     constructor(sandstonePack: SandstonePack, args?: [
         ...args: unknown[]
-    ], { isSingleExecute, body }?: {
+    ], { isSingleExecute, body, isFlowControl }?: {
         isSingleExecute?: boolean | undefined;
         body?: Node[] | undefined;
+        isFlowControl?: boolean | undefined;
     });
     getValue: () => string;
     createMCFunction: (currentMCFunction: MCFunctionNode | null) => {
@@ -40,7 +47,7 @@ export declare class ReturnArgumentsCommand<MACRO extends boolean> extends Comma
      * - With a callback function: return.run(() => { commands })
      *
      * @example
-     * return.run.execute.if.score('@p', 'health').matches([1, 10]).run.return(1)
+     * return.run.execute.if.score('@p', 'health').matches([1, 10]).run.returnCmd(1)
      */
     get run(): SandstoneCommands<MACRO> & ((callback: () => any) => FinalCommandOutput);
 }
@@ -68,8 +75,8 @@ export declare class ReturnCommand<MACRO extends boolean> extends CommandArgumen
      * return.return()
      *
      * // Return based on conditions
-     * execute.if.entity('@p[tag=vip]').run.return(100)  // VIP bonus
-     * execute.unless.entity('@p[tag=vip]').run.return(50) // Regular bonus
+     * execute.if.entity('@p[tag=vip]').run.returnCmd(100)  // VIP bonus
+     * execute.unless.entity('@p[tag=vip]').run.returnCmd(50) // Regular bonus
      * ```
      */
     get return(): {
@@ -88,13 +95,13 @@ export declare class ReturnCommand<MACRO extends boolean> extends CommandArgumen
      * @example
      * ```ts
      * // Early exit on invalid conditions
-     * execute.unless.entity('@p').run.return.fail() // No player found
+     * execute.unless.entity('@p').run.returnCmd.fail() // No player found
      *
      * // Validation check
-     * execute.if.score('@p', 'level').matches([..0]).run.return.fail() // Invalid level
+     * execute.if.score('@p', 'level').matches([..0]).run.returnCmd.fail() // Invalid level
      *
      * // Error handling
-     * execute.unless.block('~ ~ ~', 'minecraft:chest').run.return.fail() // Expected chest not found
+     * execute.unless.block('~ ~ ~', 'minecraft:chest').run.returnCmd.fail() // Expected chest not found
      * ```
      */
     fail: () => FinalCommandOutput;

package/dist/commands/implementations/world/data.d.ts

@@ -1,8 +1,8 @@
 import type { Coordinates, NBTObject, SingleEntityArgumentOf } from "../../../arguments/index.js";
 import { type Macroable } from "../../../core/index.js";
 import { CommandNode } from "../../../core/nodes.js";
-import type { DataPointClass } from "../../../variables/index.js";
-import { CommandArguments } from "../../helpers.js";
+import { DataPointClass } from "../../../variables/index.js";
+import { CommandArguments, type FinalCommandOutput } from "../../helpers.js";
 export declare class DataCommandNode extends CommandNode {
     command: "data";
 }
@@ -13,12 +13,13 @@ export declare class DataCommand<MACRO extends boolean> extends CommandArguments
      *
      * @example
      * ```ts
-     * data.get.block(abs(100, 70, 200), 'Items[0]', 1)      // Get block NBT
-     * data.get.entity('@p', 'Health')                    // Get player health
-     * data.get.storage('minecraft:temp', 'value')        // Get storage data
+     * data.get(dataPoint, 1)                               // Get data point NBT with scale
+     * data.get.block(abs(100, 70, 200), 'Items[0]', 1)     // Get block NBT
+     * data.get.entity('@p', 'Health')                      // Get player health
+     * data.get.storage('minecraft:temp', 'value')          // Get storage data
      * ```
      */
-    get get(): DataGetCommand<MACRO>;
+    get get(): DataGetCommand<MACRO> & ((dataPoint: DataPointClass<"entity"> | DataPointClass<"block"> | DataPointClass<"storage">, scale?: Macroable<number, MACRO>) => FinalCommandOutput);
     /**
      * Merge NBT data into blocks, entities, or storage.
      *
@@ -35,23 +36,25 @@ export declare class DataCommand<MACRO extends boolean> extends CommandArguments
      *
      * @example
      * ```ts
-     * data.modify.entity('@p', 'Health').set.value(20)                    // Set health
+     * data.modify(dataPoint).set.value(20)                                 // Modify data point
+     * data.modify.entity('@p', 'Health').set.value(20)                     // Set health
      * data.modify.block(abs(100, 70, 200), 'Items').append.value({id: 'stone'}) // Add item
      * data.modify.storage('minecraft:temp', 'list').prepend.from.entity('@p', 'Inventory[0]')
      * ```
      */
-    get modify(): DataModifyCommand<MACRO>;
+    get modify(): DataModifyCommand<MACRO> & ((dataPoint: DataPointClass<"entity"> | DataPointClass<"block"> | DataPointClass<"storage">) => DataModifyTypeCommand<MACRO>);
     /**
      * Remove NBT data from blocks, entities, or storage.
      *
      * @example
      * ```ts
-     * data.remove.block(abs(100, 70, 200), 'Items[0]')      // Remove block NBT
-     * data.remove.entity('@e[type=item]', 'Motion')      // Remove entity motion
-     * data.remove.storage('minecraft:temp', 'old_data')  // Remove storage data
+     * data.remove(dataPoint)                               // Remove data point NBT
+     * data.remove.block(abs(100, 70, 200), 'Items[0]')     // Remove block NBT
+     * data.remove.entity('@e[type=item]', 'Motion')        // Remove entity motion
+     * data.remove.storage('minecraft:temp', 'old_data')    // Remove storage data
      * ```
      */
-    get remove(): DataRemoveCommand<MACRO>;
+    get remove(): DataRemoveCommand<MACRO> & ((dataPoint: DataPointClass<"entity"> | DataPointClass<"block"> | DataPointClass<"storage">) => FinalCommandOutput);
 }
 export declare class DataGetCommand<MACRO extends boolean> extends CommandArguments {
     /**
@@ -61,7 +64,7 @@ export declare class DataGetCommand<MACRO extends boolean> extends CommandArgume
      * @param path The path of the NBT to get.
      * @param scale The scale to multiply the NBT value by.
      */
-    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => import("../../index.js").FinalCommandOutput;
+    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => FinalCommandOutput;
     /**
      * Get the NBT of a given entity.
      *
@@ -69,7 +72,7 @@ export declare class DataGetCommand<MACRO extends boolean> extends CommandArgume
      * @param path The path of the NBT to get.
      * @param scale The scale to multiply the NBT value by.
      */
-    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => import("../../index.js").FinalCommandOutput;
+    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => FinalCommandOutput;
     /**
      * Get the NBT from a given storage path.
      *
@@ -77,7 +80,7 @@ export declare class DataGetCommand<MACRO extends boolean> extends CommandArgume
      * @param path The path of the NBT to get.
      * @param scale The scale to multiply the NBT value by.
      */
-    storage: (target: Macroable<string, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => import("../../index.js").FinalCommandOutput;
+    storage: (target: Macroable<string, MACRO>, path?: Macroable<string, MACRO>, scale?: Macroable<number, MACRO>) => FinalCommandOutput;
 }
 export declare class DataMergeCommand<MACRO extends boolean> extends CommandArguments {
     /**
@@ -86,21 +89,21 @@ export declare class DataMergeCommand<MACRO extends boolean> extends CommandArgu
      * @param targetPos The coordinates of the block to merge the NBT with.
      * @param nbt The NBT to merge with.
      */
-    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, nbt: Macroable<NBTObject, MACRO>) => import("../../index.js").FinalCommandOutput;
+    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, nbt: Macroable<NBTObject, MACRO>) => FinalCommandOutput;
     /**
      * Merge the NBT of the given entity, with the given NBT.
      *
      * @param target The entity to merge the NBT with.
      * @param nbt The NBT to merge with.
      */
-    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, nbt: Macroable<NBTObject, MACRO>) => import("../../index.js").FinalCommandOutput;
+    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, nbt: Macroable<NBTObject, MACRO>) => FinalCommandOutput;
     /**
      * Merge the NBT of the given storage path, with the given NBT.
      *
      * @param target The storage to merge the NBT with.
      * @param nbt The NBT to merge with.
      */
-    storage: (target: Macroable<string, MACRO>, nbt: Macroable<NBTObject, MACRO>) => import("../../index.js").FinalCommandOutput;
+    storage: (target: Macroable<string, MACRO>, nbt: Macroable<NBTObject, MACRO>) => FinalCommandOutput;
 }
 export declare class DataModifyFromCommand<MACRO extends boolean> extends CommandArguments {
     /**
@@ -109,30 +112,24 @@ export declare class DataModifyFromCommand<MACRO extends boolean> extends Comman
      * @param sourcePosition The coordinates of the block to modify the NBT with.
      * @param sourcePath The path of the NBT to modify with.
      */
-    block: (sourcePosition: Macroable<Coordinates<MACRO>, MACRO>, sourcePath: Macroable<string, MACRO>) => import("../../index.js").FinalCommandOutput;
+    block: (sourcePosition: Macroable<Coordinates<MACRO>, MACRO>, sourcePath: Macroable<string, MACRO>) => FinalCommandOutput;
     /**
      * Modify with the NBT of a given entity.
      *
      * @param source The entity to modify the NBT with.
      * @param sourcePath The path of the NBT to modify with.
      */
-    entity: <T extends string>(source: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, sourcePath: Macroable<string, MACRO>) => import("../../index.js").FinalCommandOutput;
-    /**
-     * Modify with the NBT of a given storage data point.
-     *
-     * @param source The storage data point to modify the NBT with.
-     */
-    storage(source: DataPointClass<'storage'>): void;
+    entity: <T extends string>(source: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, sourcePath: Macroable<string, MACRO>) => FinalCommandOutput;
     /**
      * Modify with the NBT of a given storage path.
      *
      * @param source The storage target to modify the NBT with.
      * @param sourcePath The path of the NBT to modify with.
      */
-    storage(source: Macroable<string, MACRO>, sourcePath: Macroable<string, MACRO>): void;
+    storage: (source: Macroable<string, MACRO>, sourcePath: Macroable<string, MACRO>) => FinalCommandOutput;
 }
 export declare class DataModifyValuesCommand<MACRO extends boolean> extends CommandArguments {
-    get from(): DataModifyFromCommand<MACRO>;
+    get from(): DataModifyFromCommand<MACRO> & ((dataPoint: DataPointClass<"entity"> | DataPointClass<"block"> | DataPointClass<"storage">) => FinalCommandOutput);
     string: {
         /**
          * Modify with the NBT String of a block at the given position.
@@ -165,7 +162,7 @@ export declare class DataModifyValuesCommand<MACRO extends boolean> extends Comm
     /**
      * Modify the NBT with the given value.
      */
-    value: (value: Macroable<NBTObject, MACRO>) => import("../../index.js").FinalCommandOutput;
+    value: (value: Macroable<NBTObject, MACRO>) => FinalCommandOutput;
 }
 export declare class DataModifyTypeCommand<MACRO extends boolean> extends CommandArguments {
     /** Append the source data onto the end of the pointed-to list. */
@@ -213,19 +210,19 @@ export declare class DataRemoveCommand<MACRO extends boolean> extends CommandArg
      * @param targetPos The coordinates of the block to remove the NBT from.
      * @param path The path of the NBT to remove.
      */
-    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, targetPath: Macroable<string, MACRO>) => import("../../index.js").FinalCommandOutput;
+    block: (targetPos: Macroable<Coordinates<MACRO>, MACRO>, targetPath: Macroable<string, MACRO>) => FinalCommandOutput;
     /**
      * Remove the NBT of a given entity.
      *
      * @param target The entity to remove the NBT from.
      * @param path The path of the NBT to remove.
      */
-    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, targetPath: Macroable<string, MACRO>) => import("../../index.js").FinalCommandOutput;
+    entity: <T extends string>(target: Macroable<SingleEntityArgumentOf<MACRO, T>, MACRO>, targetPath: Macroable<string, MACRO>) => FinalCommandOutput;
     /**
      * Remove the NBT from a given storage path.
      *
      * @param target The storage to remove the NBT from.
      * @param path The path of the NBT to remove.
      */
-    storage: (target: Macroable<string, MACRO>, targetPath: Macroable<string, MACRO>) => import("../../index.js").FinalCommandOutput;
+    storage: (target: Macroable<string, MACRO>, targetPath: Macroable<string, MACRO>) => FinalCommandOutput;
 }