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

package/dist/_internal/types/utils.d.ts

@@ -0,0 +1,310 @@
+import type { Static } from '@sinclair/typebox';
+import fs from 'fs-extra';
+import type { Response } from 'node-fetch';
+import type { MultipleEntitiesArgument } from "./arguments/selector.js";
+import type { Node } from "./core/nodes.js";
+import type { UUIDinNumber } from "./variables/UUID.js";
+export declare const fetch: (input: URL | RequestInfo, init?: RequestInit | undefined) => Promise<Response>;
+/**
+ * Allows to get autocompletion on string unions, while still allowing generic strings.
+ * @see https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227
+ */
+export type LiteralUnion<T extends string> = T | (`${any}${string}` & Record<never, never>);
+export type NamespacedLiteralUnion<T extends string> = T | (`${string}:${string}` & Record<never, never>);
+export type AtLeastOne<T> = [
+    T,
+    ...T[]
+];
+export type HideFunctionProperties<T extends Function> = T & {
+    /** @deprecated */
+    call: T['call'];
+    /** @deprecated */
+    apply: T['apply'];
+    /** @deprecated */
+    bind: T['bind'];
+    /** @deprecated */
+    prototype: T['prototype'];
+    /** @deprecated */
+    length: T['length'];
+    /** @deprecated */
+    arguments: T['arguments'];
+    /** @deprecated */
+    caller: T['caller'];
+    /** @deprecated */
+    readonly name: T['name'];
+    /** @deprecated */
+    [Symbol.hasInstance]: (value: unknown) => boolean;
+};
+export type BASIC_CONFLICT_STRATEGIES = 'throw' | 'replace' | 'warn' | 'rename' | 'ignore';
+export type OmitFirst<T extends unknown[]> = T extends [
+    infer _,
+    ...infer B
+] ? B : [
+];
+export type InstanceOfClass<X extends abstract new (...args: any[]) => any> = new (..._args: [
+    ...one: ConstructorParameters<X>,
+    ...two: any[]
+]) => InstanceType<X>;
+export declare function isAsyncFunction(func: ((...args: any[]) => void) | ((...args: any[]) => Promise<void>)): func is (...args: any[]) => Promise<void>;
+export declare function isPromise(promise: any): promise is Promise<unknown>;
+/**
+ * Create a brand checker for a class without importing it (avoiding circular deps).
+ * Returns a type guard function that checks for the brand symbol.
+ *
+ * @example
+ * import type { TagClass } from 'sandstone/core/resources/datapack/tag'
+ * const isTagClass = createBrandChecker<TagClass<string>>('TagClass')
+ * if (isTagClass(value)) {
+ *   // value is a TagClass instance
+ * }
+ */
+export declare function createBrandChecker<T>(className: string): (value: unknown) => value is T;
+export type Either<A extends Record<string, any>, B extends Record<string, any>> = ({
+    [K in keyof A | keyof B]?: K extends keyof A ? A[K] : never;
+} | {
+    [K in keyof A | keyof B]?: K extends keyof B ? B[K] : never;
+});
+export type WithMCNamespace<T extends string> = `minecraft:${T}` | T;
+export declare function makeCallableProxy(func: any, object: any): any;
+export interface CallableInstance {
+    __call__: (...args: any[]) => any;
+}
+type CallableClass = new (...args: any[]) => CallableInstance;
+export declare function makeClassCallable<C extends CallableClass>(Class_: C): MakeClassCallable<C>;
+export type MakeInstanceCallable<T extends CallableInstance> = T & T['__call__'];
+export type MakeClassCallable<T extends CallableClass> = new (...args: ConstructorParameters<T>) => MakeInstanceCallable<InstanceType<T>>;
+export declare function makeCallable<T, F extends (...args: any[]) => any>(object: T, func: F, useProxy?: boolean): T & F;
+type TupleSplit<T, N extends number, O extends readonly any[] = readonly [
+]> = O['length'] extends N ? [
+    O,
+    T
+] : T extends readonly [
+    infer F,
+    ...infer R
+] ? TupleSplit<readonly [
+    ...R
+], N, readonly [
+    ...O,
+    F
+]> : [
+    O,
+    T
+];
+type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[0];
+type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
+type TupleSlice<T extends readonly any[], S extends number, E extends number> = SkipFirst<TakeFirst<T, E>, S>;
+export type SlicedArguments<T extends (...args: any[]) => any, FROM extends number | undefined = undefined, TO extends number | undefined = undefined> = TupleSlice<Parameters<T>, FROM extends undefined ? 0 : FROM, TO extends undefined ? Parameters<T>['length'] : TO>;
+export type PartialFunction<T extends (...args: any[]) => any, FROM extends number | undefined = undefined, TO extends number | undefined = undefined> = (...args: SlicedArguments<T, FROM, TO>) => ReturnType<T>;
+export 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 function randomUUID(): UUIDinNumber;
+export declare const capitalize: (s: string) => string;
+export type UnionToIntersection<U> = ((U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never);
+export type LastOf<T> = (UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never);
+export type Push<T extends any[], V> = [
+    ...T,
+    V
+];
+export type UnionToTuple<T, L = LastOf<T>, N = [
+    T
+] extends [
+    never
+] ? true : false> = (true extends N ? [
+] : Push<UnionToTuple<Exclude<T, L>>, L>);
+export type PowerSet<T, Keys extends any[] = UnionToTuple<keyof T>> = (Keys extends [
+    infer Head,
+    ...infer Rest
+] ? PowerSet<T, Rest> | (Head extends keyof T ? {
+    [K in Head]: NonNullable<T[K]>;
+} & PowerSet<T, Rest> : never) : Record<string, never>);
+export type Prettify<T> = ({
+    [K in keyof T]: T[K];
+} & {});
+/**
+ * Helper to add key-value pairs to an object if the values are not undefined.
+ *
+ * @returns An object with the key-value pairs if the values are not undefined, otherwise an empty object.
+ */
+export declare function add<O extends Record<string, any>>(obj: O): Prettify<PowerSet<O>>;
+export type RemoveArrayRepeats<T extends readonly any[]> = {
+    [K in keyof T]: T[number] extends {
+        [P in keyof T]: P extends K ? never : T[P];
+    }[number] ? never : T[K];
+};
+export declare function iterateEntries(node: Map<string, any>, fn: (val: any) => any): Record<string, any>;
+export interface PackEntry {
+    added: number;
+    downloads: {
+        [key: string]: number;
+    };
+    updated: number;
+    owner: string;
+}
+export declare const supportedMinecraftVersions: string[];
+export declare const latestMinecraftVersion = "1.19";
+export declare const MinecraftVersionSchema: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>;
+export declare const packCategories: string[];
+declare const PackDependencySchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TString;
+}>;
+export declare const PackVersionSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    downloads: import("@sinclair/typebox").TObject<{
+        datapack: import("@sinclair/typebox").TString;
+        resourcepack: import("@sinclair/typebox").TString;
+    }>;
+    supports: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+    dependencies: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        version: import("@sinclair/typebox").TString;
+    }>>;
+}>;
+export declare const PackDataSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    display: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        description: import("@sinclair/typebox").TString;
+        icon: import("@sinclair/typebox").TString;
+        hidden: import("@sinclair/typebox").TBoolean;
+        webPage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    versions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        downloads: import("@sinclair/typebox").TObject<{
+            datapack: import("@sinclair/typebox").TString;
+            resourcepack: import("@sinclair/typebox").TString;
+        }>;
+        supports: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+        dependencies: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            version: import("@sinclair/typebox").TString;
+        }>>;
+    }>>;
+    categories: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+}>;
+export declare const MetaDataSchema: import("@sinclair/typebox").TObject<{
+    docId: import("@sinclair/typebox").TString;
+    rawId: import("@sinclair/typebox").TString;
+    stats: import("@sinclair/typebox").TObject<{
+        updated: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        added: import("@sinclair/typebox").TNumber;
+        downloads: import("@sinclair/typebox").TObject<{
+            total: import("@sinclair/typebox").TNumber;
+            today: import("@sinclair/typebox").TNumber;
+        }>;
+    }>;
+    owner: import("@sinclair/typebox").TString;
+    contributors: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>;
+export type PackMetaData = Static<typeof MetaDataSchema>;
+export type MinecraftVersion = Static<typeof MinecraftVersionSchema>;
+export type PackDependency = Static<typeof PackDependencySchema>;
+export type PackVersion = Static<typeof PackVersionSchema>;
+export type PackData = Static<typeof PackDataSchema>;
+export interface UserData {
+    displayName: string;
+}
+export declare enum HTTPResponses {
+    OK = 200,
+    CREATED = 201,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    CONFLICT = 409,
+    SERVER_ERROR = 500
+}
+export type ReviewState = 'verified' | 'pending' | 'unsubmitted' | 'rejected';
+export declare function safeWrite(...args: Partial<Parameters<(typeof fs)['writeFile']>>): Promise<void>;
+export declare function sanitizeTarget(target: MultipleEntitiesArgument<false>): string;
+/**
+ * Formats a debug string for a class instance, including its arguments and body.
+ * Must be called from the [util.inspect.custom] method.
+ *
+ * @param className The name of the class.
+ * @param args The arguments passed to the class instance. It can be an array or an object.
+ * @param body The body of the class instance, typically an array of nodes.
+ * @param currentIndent The current indentation level.
+ */
+export declare function formatDebugString(className: string, args: undefined | any[] | Record<string, any> | string, body: Node[] | undefined, currentIndent: string | undefined): string;
+export type AllKeys<T> = T extends T ? keyof T : never;
+type GetConstructorArgs<T> = T extends new (...args: infer U) => any ? U : never;
+export declare class Set<T> extends global.Set<T> {
+    constructor(...args: GetConstructorArgs<typeof global.Set<T>>);
+    has(value: unknown): boolean;
+}
+export type SetType<T> = T extends Set<infer U> ? U : never;
+type TestMembers<T, TestDispatcher> = {
+    [K in keyof T]: TestDispatcher[K extends keyof TestDispatcher ? K : never];
+};
+type NegatedMembers<T> = {
+    [K in keyof T as `!${Extract<K, string>}`]?: Record<string, never>;
+};
+export type MemberModifiers<T> = Partial<T> & NegatedMembers<T>;
+type UnknownKey<UnknownValue> = {
+    [K in `${string}:${string}`]?: UnknownValue;
+};
+type UnknownNegatableKey<UnknownValue> = ({
+    [K in `!${string}:${string}`]?: Record<string, never>;
+} & {
+    [K in `${string}:${string}`]?: UnknownValue | Record<string, never>;
+});
+type McdocIDMapBase<Dispatcher, UnknownValue> = Dispatcher & UnknownKey<UnknownValue>;
+/**
+ * A mapping of dispatcher IDs to their corresponding value types.
+ *
+ * Also supports unknown namespaced IDs.
+ *
+ * Must specify at least one key.
+ *
+ * ----
+ *
+ * Disclaimers:
+ * - Do not reference an ID multiple times. Multiple keys for the same ID (e.g. `acacia_button` and `minecraft:acacia_button`) will not cause a Typescript error due to limitations, but will cause an error in-game.
+ * - Unknown IDs will not satisfy the Typed requirement of specifying at least one key, so either a known key must be also specified or `as any` must be placed at the end of the object.
+ */
+export type McdocIDMap<Dispatcher, UnknownValue> = Partial<McdocIDMapBase<Dispatcher, UnknownValue>> & {
+    [K in keyof Dispatcher]-?: Record<K, McdocIDMapBase<Dispatcher, UnknownValue>[K]>;
+}[keyof Dispatcher];
+type McdocIDTestMapBase<Dispatcher, TestDispatcher, UnknownValue> = TestMembers<Dispatcher, TestDispatcher> & UnknownKey<UnknownValue>;
+/**
+ * A mapping of dispatcher IDs to their corresponding value types.
+ *
+ * Also supports unknown namespaced IDs.
+ *
+ * Must specify at least one key.
+ *
+ * ----
+ *
+ * Disclaimers:
+ * - Do not reference an ID multiple times. Multiple keys for the same ID (e.g. `acacia_button` and `minecraft:acacia_button`) will not cause a Typescript error due to limitations, but will cause an error in-game.
+ * - Unknown IDs will not satisfy the Typed requirement of specifying at least one key, so either a known key must be also specified or `as any` must be placed at the end of the object.
+ */
+export type McdocIDTestMap<Dispatcher, TestDispatcher, UnknownValue> = Partial<McdocIDTestMapBase<Dispatcher, TestDispatcher, UnknownValue>> & {
+    [K in keyof TestMembers<Dispatcher, TestDispatcher>]-?: Record<K, McdocIDTestMapBase<Dispatcher, TestDispatcher, UnknownValue>[K]>;
+}[keyof TestMembers<Dispatcher, TestDispatcher>];
+type McdocNegatableIDMapBase<Dispatcher, UnknownValue> = MemberModifiers<Dispatcher> & UnknownNegatableKey<UnknownValue>;
+/**
+ * A mapping of dispatcher IDs to their corresponding value types, with support for negated keys that equal an empty object.
+ *
+ * Also supports unknown namespaced IDs and negated unknown namespaced IDs.
+ *
+ * Must specify at least one key.
+ *
+ * ----
+ *
+ * Disclaimers:
+ * - Do not reference an ID multiple times. Multiple keys for the same ID (e.g. `acacia_button` and `minecraft:acacia_button` and `!acacia_button`) will not cause a Typescript error due to limitations, but will cause an error in-game.
+ * - Unknown IDs will not satisfy the Typed requirement of specifying at least one key, so either a known key must be also specified or `as any` must be placed at the end of the object.
+ * - The object type will allow non-negated Unknown IDs specified to an empty object, this is due to a types limitation, but will cause an error in-game.
+ */
+export type McdocNegatableIDMap<Dispatcher, UnknownValue> = Partial<McdocNegatableIDMapBase<Dispatcher, UnknownValue>> & {
+    [K in keyof MemberModifiers<Dispatcher>]-?: Record<K, McdocNegatableIDMapBase<Dispatcher, UnknownValue>[K]>;
+}[keyof MemberModifiers<Dispatcher>];
+export {};

package/dist/_internal/types/variables/Data.d.ts

@@ -0,0 +1,115 @@
+import type { Coordinates, NBTObject, NBTSerializable, SingleEntityArgument, SingleEntityArgumentOf } from "../arguments/index.js";
+import type { FinalCommandOutput } from "../commands/index.js";
+import type { DataModifyTypeCommand, DataModifyValuesCommand, StoreType } from "../commands/implementations/index.js";
+import type { SandstonePack } from '../../index.js';
+import { DataPointPickClass, MacroArgument } from "../core/Macro.js";
+import type { ConditionTextComponentClass } from "./abstractClasses.js";
+import { Score } from "./Score.js";
+export type DATA_TYPES = 'entity' | 'block' | 'storage';
+export type DATA_TARGET = {
+    entity: SingleEntityArgument<false>;
+    block: Coordinates<false>;
+    storage: string;
+};
+export type DATA_PATH = string | MacroArgument | Record<string, NBTObject> | NBTObject[];
+export declare function NBTpathToString(pack: SandstonePack, paths: DATA_PATH[]): string;
+export type TargetFor<TYPE extends DATA_TYPES, T extends string = string> = TYPE extends 'entity' ? SingleEntityArgumentOf<false, T> : TYPE extends 'block' ? Coordinates<false> : TYPE extends 'storage' ? string : never;
+export declare class TargetlessDataClass<TYPE extends DATA_TYPES = DATA_TYPES> {
+    protected sandstonePack: SandstonePack;
+    type: TYPE;
+    constructor(sandstonePack: SandstonePack, type: TYPE);
+    target: <T extends string>(target: TargetFor<TYPE, T>) => DataClass<TYPE>;
+    select: (...path: DATA_PATH[]) => TargetlessDataPointClass<TYPE>;
+}
+export declare class TargetlessDataPointClass<TYPE extends DATA_TYPES = DATA_TYPES> {
+    protected sandstonePack: SandstonePack;
+    type: TYPE;
+    path: string;
+    constructor(sandstonePack: SandstonePack, type: TYPE, path: DATA_PATH[]);
+    target: <T extends string>(target: TargetFor<TYPE, T>) => DataPointClass<TYPE>;
+    select: (...path: DATA_PATH[]) => TargetlessDataPointClass<TYPE>;
+}
+export declare class DataClass<TYPE extends DATA_TYPES = any> {
+    protected sandstonePack: SandstonePack;
+    type: TYPE;
+    currentTarget: DATA_TARGET[TYPE];
+    constructor(sandstonePack: SandstonePack, type: TYPE, target: DATA_TARGET[TYPE]);
+    /**
+     * Merge the given NBT to the current target.
+     */
+    merge: (value: NBTObject) => void;
+    target: (target: DATA_TARGET[TYPE]) => DataClass<TYPE>;
+    select: (...path: DATA_PATH[]) => DataPointClass<TYPE>;
+    toString: () => string;
+    toJSON: () => string;
+}
+export declare class DataPointClass<TYPE extends DATA_TYPES = any> extends MacroArgument implements ConditionTextComponentClass, NBTSerializable {
+    sandstonePack: SandstonePack;
+    type: TYPE;
+    path: string;
+    currentTarget: DATA_TARGET[TYPE];
+    constructor(sandstonePack: SandstonePack, type: TYPE, target: DATA_TARGET[TYPE], path: DATA_PATH[]);
+    target: (target: DATA_TARGET[TYPE]) => DataPointClass<TYPE>;
+    select: (...path: DATA_PATH[]) => DataPointClass<TYPE>;
+    protected modify: (cb: (data: DataModifyTypeCommand<false>) => DataModifyValuesCommand<false>, value: NBTObject | DataPointClass | DataPointPickClass) => this;
+    protected string: (cb: (data: DataModifyTypeCommand<false>) => DataModifyValuesCommand<false>, value: DataPointClass, start: number, end?: number) => void;
+    protected executeStore: (storeType: StoreType, scale: number) => import("../commands/index.js").ExecuteCommand<false>;
+    /**
+     * Set the data point to the given NBT.
+     */
+    set(value: NBTObject | DataPointClass): DataPointClass;
+    /**
+     * Set the data point to the given Data Point Pick.
+     */
+    set(value: DataPointPickClass): DataPointClass;
+    /**
+     * Set the data point to the given score, with a given type and a scale.
+     */
+    set(value: Score, storeType?: StoreType, scale?: number): DataPointClass;
+    /**
+     * Set the data point to the given NBT string.
+     */
+    set(value: StringDataPointClass): DataPointClass;
+    /**
+     * Set the data point to the given NBT.
+     */
+    merge: (value: NBTObject | DataPointClass | DataPointPickClass) => this;
+    /**
+     * Append the given NBT to the current data point.
+     */
+    append: (value: NBTObject | DataPointClass | DataPointPickClass) => this;
+    /**
+     * Prepend the given NBT to the current data point.
+     */
+    prepend: (value: NBTObject | DataPointClass | DataPointPickClass) => this;
+    /**
+     * Insert the given NBT to the given index of the current data point.
+     */
+    insert: (value: NBTObject | DataPointClass | DataPointPickClass, index: number) => this;
+    /**
+     * Remove the current NBT value.
+     */
+    remove: () => FinalCommandOutput;
+    /**
+     * Extracts a section of a string available for setting to another path, without modifying the original path.
+     *
+     * Use slice(0) to get a type-safe string data point; it compiles to a regular `from` argument.
+     *
+     * @param start Index of first character to include at the start of the string.
+     * @param end Optional. Index of the first character to exclude at the end of the string.
+     */
+    slice: (start: number, end?: number) => StringDataPointClass<TYPE>;
+    _toMinecraftCondition: () => import("../flow/index.js").DataPointExistsConditionNode;
+    equals: (value: NBTObject | Score | DataPointClass | DataPointPickClass) => import("../flow/index.js").DataPointEqualsConditionNode;
+}
+export declare class StringDataPointClass<TYPE extends DATA_TYPES = any> extends DataPointClass {
+    sandstonePack: SandstonePack;
+    type: TYPE;
+    readonly sliceBounds: [
+        number
+    ] | [
+        number,
+        number
+    ];
+    constructor(sandstonePack: SandstonePack, type: TYPE, target: DATA_TARGET[TYPE], path: DATA_PATH, start: number, end?: number);
+}

package/dist/_internal/types/variables/DataSets.d.ts

@@ -0,0 +1,120 @@
+import type { NBTObject, RootNBT } from "../arguments/index.js";
+import type { DataPointPickClass } from "../core/index.js";
+import type { ConditionNode } from "../flow/index.js";
+import type { LiteralUnion } from "../utils.js";
+import type { Macroable } from "../core/Macro.js";
+import { ConditionalDataPointPickClass } from "../core/Macro.js";
+import type { SandstonePack } from '../../index.js';
+import type { StringDataPointClass } from "./Data.js";
+import { DataPointClass } from "./Data.js";
+import { Score } from "./Score.js";
+export declare abstract class IterableDataClass<TYPE extends 'list' | 'map'> extends ConditionalDataPointPickClass {
+    iteratorType: TYPE;
+    constructor(sandstoneCore: SandstonePack['core'], iteratorType: TYPE);
+    iterator(_callback: (dataPoints: TYPE extends 'list' ? [
+        DataPointClass
+    ] : [
+        StringDataPointClass,
+        DataPointClass
+    ]) => void, _direction?: 'normal' | 'reverse'): () => void;
+    size(): DataPointClass<'storage'>;
+    last(): readonly [
+        StringDataPointClass,
+        DataPointClass
+    ] | DataPointClass;
+    continue(direction?: 'normal' | 'reverse'): ConditionNode;
+}
+type GetKeys<T> = T extends unknown[] ? T extends [
+] ? never : '0' extends keyof T ? Exclude<keyof T, keyof [
+]> : number : keyof T;
+export type DataIndexMapInitial = RootNBT | Record<string, DataPointClass | DataPointPickClass>;
+export declare class DataIndexMapClass<INITIAL extends DataIndexMapInitial> extends IterableDataClass<'map'> {
+    private pack;
+    entries: Record<string, number>;
+    dataPoint: NonNullable<DataPointClass<'storage'>>;
+    constructor(pack: SandstonePack, initialize: INITIAL, dataPoint?: DataPointClass<'storage'>);
+    private init;
+    __entryIterator?: DataPointClass<'storage'>;
+    entryIterator(direction: 'normal' | 'reverse'): DataPointClass<"storage">;
+    iterator(callback: (data: [
+        key: StringDataPointClass,
+        value: DataPointClass
+    ]) => void, direction?: 'normal' | 'reverse'): () => void;
+    continue(direction?: 'normal' | 'reverse'): import("../flow/index.js").DataPointExistsConditionNode;
+    /**
+     * Use in conjunction with a Score to get the count of entries.
+     *
+     * @example
+     * Variable(map.size(), 'map_size')
+     *
+     * @returns The entries of the map.
+     */
+    size: () => DataPointClass<"storage">;
+    last: () => readonly [
+        key: StringDataPointClass,
+        value: DataPointClass
+    ];
+    /**
+     * @returns The index of the entry.
+     */
+    set(key: Macroable<LiteralUnion<GetKeys<INITIAL>>, true>, value: NBTObject | DataPointClass | DataPointPickClass): number | Score;
+    get(key: GetKeys<INITIAL>): INITIAL[typeof key] extends DataPointClass ? INITIAL[typeof key] : DataPointClass<'storage'>;
+    get(key: Macroable<string, true>): DataPointClass<'storage'>;
+    remove(key: Macroable<LiteralUnion<GetKeys<INITIAL>>, true>): this;
+    _toDataPoint: () => DataPointClass<"storage">;
+    _toMinecraftCondition(): import("../flow/index.js").DataPointExistsConditionNode;
+}
+export type DataArrayInitial = readonly NBTObject[] | readonly [
+    string,
+    DataPointClass | DataPointPickClass
+];
+export declare class DataArrayClass<INITIAL extends DataArrayInitial> extends IterableDataClass<'list'> {
+    private pack;
+    dataPoint: NonNullable<DataPointClass<'storage'>>;
+    constructor(pack: SandstonePack, initialize: INITIAL, dataPoint?: DataPointClass<'storage'>);
+    private init;
+    __entryIterator?: DataPointClass<'storage'>;
+    entryIterator(direction: 'normal' | 'reverse'): DataPointClass<"storage">;
+    iterator(callback: (data: [
+        entry: DataPointClass
+    ]) => void, direction?: 'normal' | 'reverse'): () => void;
+    continue(direction?: 'normal' | 'reverse'): import("../flow/index.js").DataPointExistsConditionNode;
+    /**
+     * Use in conjunction with a Score to get the count of entries.
+     *
+     * @example
+     * Variable(array.size(), 'array_size')
+     *
+     * @returns The entries of the array.
+     */
+    size: () => DataPointClass<"storage">;
+    last: () => DataPointClass<"storage">;
+    set(index: Score | number, value: NBTObject | DataPointClass | DataPointPickClass): this;
+    push(value: NBTObject | DataPointClass | DataPointPickClass): this;
+    unshift(value: NBTObject | DataPointClass | DataPointPickClass): this;
+    get(index: Score | number): DataPointClass<"storage">;
+    remove(index: Score | number): this;
+    _toDataPoint: () => DataPointClass<"storage">;
+    _toMinecraftCondition(): import("../flow/index.js").DataPointExistsConditionNode;
+}
+export declare function DataIndexMap<INITIAL extends DataIndexMapInitial>(pack: SandstonePack, initialize: INITIAL, dataPoint?: DataPointClass<'storage'>): DataIndexMapClass<INITIAL> & {
+    [K in keyof INITIAL]: DataIndexMapInitial[string];
+} & {
+    [K in string]: DataIndexMapInitial[string];
+};
+export type DataIndexMap<INITIAL extends DataIndexMapInitial> = DataIndexMapClass<INITIAL> & {
+    [K in keyof INITIAL]: DataIndexMapInitial[string];
+} & {
+    [K in string]: DataIndexMapInitial[string];
+};
+export declare function DataArray<INITIAL extends DataArrayInitial>(pack: SandstonePack, initialize: INITIAL, dataPoint?: DataPointClass<'storage'>): DataArrayClass<INITIAL> & {
+    [K in keyof INITIAL]: DataArrayInitial[number];
+} & {
+    [K in number]: DataArrayInitial[number];
+};
+export type DataArray<INITIAL extends DataArrayInitial> = DataArrayClass<INITIAL> & {
+    [K in keyof INITIAL]: DataArrayInitial[number];
+} & {
+    [K in number]: DataArrayInitial[number];
+};
+export {};

package/dist/_internal/types/variables/ItemPredicate.d.ts

@@ -0,0 +1,112 @@
+import type { SymbolDataComponent, SymbolDataComponentPredicate } from "../arguments/generated/dispatcher.js";
+import type { Registry } from "../arguments/generated/registry.js";
+import type { MinMaxBounds } from "../arguments/generated/data/util.js";
+import type { SandstonePack } from '../../index.js';
+import * as util from 'util';
+import type { MacroArgument } from "../core/Macro.js";
+import { TagClass } from "../core/resources/datapack/tag.js";
+import type { NBTObject } from "../arguments/index.js";
+import type { ItemModelBuilder } from "../core/resources/resourcepack/itemDefinition.js";
+/** Item type: specific item, tag, or wildcard */
+export type ItemPredicateItem = Registry['minecraft:item'] | `#${string}` | TagClass<'item'> | '*';
+/** Keys for sub-predicate matching (~ operator) */
+type PredicateKeys = keyof SymbolDataComponentPredicate<'map'>;
+/** Keys for exact value matching (= operator) */
+type ComponentKeys = keyof SymbolDataComponent<'map'>;
+/** Range for count test */
+type CountRange = number | MinMaxBounds<number> | {
+    min?: number;
+    max?: number;
+};
+/** A single test entry */
+type TestEntry = {
+    negated: boolean;
+    component: string;
+    operator: '=' | '~' | 'exists';
+    value?: MacroArgument | NBTObject;
+};
+/** A group of tests joined by OR */
+type OrGroup = TestEntry[];
+/**
+ * Builder for item predicates used in commands like `clear` and `execute if items`.
+ *
+ * @example
+ * ```ts
+ * // Simple item match
+ * ItemPredicate('minecraft:diamond')
+ *
+ * // With component tests
+ * ItemPredicate('minecraft:diamond_sword')
+ *   .match('minecraft:enchantments', [{ enchantment: 'minecraft:sharpness', levels: { min: 3 } }])
+ *   .has('minecraft:custom_name')
+ *
+ * // Wildcard with count
+ * ItemPredicate('*').count({ max: 16 })
+ *
+ * // Tag with negation
+ * ItemPredicate('#minecraft:swords').without('minecraft:damage')
+ *
+ * // OR logic: items without damage OR with damage=0
+ * ItemPredicate('*').or(
+ *   i => i.without('minecraft:damage'),
+ *   i => i.exact('minecraft:damage', 0)
+ * )
+ * ```
+ */
+export declare class ItemPredicateClass {
+    private readonly pack;
+    private readonly itemType;
+    protected readonly testGroups: OrGroup[];
+    constructor(pack: SandstonePack, itemType: ItemPredicateItem);
+    /** Check if a component exists */
+    has<K extends ComponentKeys>(component: K): this;
+    /** Check if a component does NOT exist */
+    without<K extends ComponentKeys>(component: K): this;
+    /** Exact match for a component value (= operator) */
+    exact<K extends ComponentKeys>(component: K, value: SymbolDataComponent<'map'>[K]): this;
+    /** Negated exact match (!component=value) */
+    notExact<K extends ComponentKeys>(component: K, value: SymbolDataComponent<'map'>[K]): this;
+    /** Sub-predicate match (~ operator) */
+    match<K extends PredicateKeys>(predicate: K, value: SymbolDataComponentPredicate<'map'>[K]): this;
+    /** Negated sub-predicate match (!predicate~value) */
+    notMatch<K extends PredicateKeys>(predicate: K, value: SymbolDataComponentPredicate<'map'>[K]): this;
+    /** Test stack count */
+    count(range: CountRange): this;
+    /**
+     * Create an OR group of conditions.
+     * Each callback receives a fresh builder; all their tests are joined with |.
+     *
+     * @example
+     * ```ts
+     * ItemPredicate('*').or(
+     *   i => i.without('minecraft:damage'),
+     *   i => i.exact('minecraft:damage', 0)
+     * )
+     * // Produces: *[!minecraft:damage|minecraft:damage=0]
+     * ```
+     */
+    or(...builders: ((item: ItemPredicateClass) => ItemPredicateClass)[]): this;
+    /**
+     * Create an item model builder from this predicate.
+     * The builder inherits all predicate tests and adds model-specific methods
+     * for building ItemModel JSON for resource packs.
+     *
+     * @example
+     * ```ts
+     * ItemPredicate('minecraft:diamond_sword')
+     *   .has('minecraft:enchantments')
+     *   .without('minecraft:damage')
+     *   .model()
+     *   .onTrue('custom:enchanted_pristine')
+     *   .onFalse('minecraft:item/diamond_sword')
+     * ```
+     */
+    model(): ItemModelBuilder;
+    private addTest;
+    private stringifyTest;
+    private stringifyOrGroup;
+    toString(): string;
+    protected toJSON(): string;
+    [util.inspect.custom](): string;
+}
+export {};