@minecraft/creator-tools/lib/minecraft/ContentMetaSchemaZod.d.ts

Minecraft Creator Tools command line and libraries.

/**
 * Zod schemas for Minecraft Content Meta-Schema.
 *
 * These schemas are used for:
 * 1. MCP tool input validation
 * 2. Runtime type checking
 * 3. AI-friendly schema descriptions
 *
 * The schemas mirror the TypeScript interfaces in IContentMetaSchema.ts
 */
import { z } from "zod";
/**
 * Color specification - hex string or RGB object.
 */
export declare const McpColorSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
    r: z.ZodNumber;
    g: z.ZodNumber;
    b: z.ZodNumber;
    a: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    b?: number;
    a?: number;
    g?: number;
    r?: number;
}, {
    b?: number;
    a?: number;
    g?: number;
    r?: number;
}>]>;
/**
 * Textured rectangle - procedural texture generation.
 */
export declare const TexturedRectangleSchema: z.ZodObject<{
    type: z.ZodEnum<["none", "solid", "random_noise", "dither_noise", "perlin_noise", "stipple_noise", "gradient"]>;
    colors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
        r: z.ZodNumber;
        g: z.ZodNumber;
        b: z.ZodNumber;
        a: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }, {
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }>]>, "many">>;
    factor: z.ZodOptional<z.ZodNumber>;
    seed: z.ZodOptional<z.ZodNumber>;
    pixelSize: z.ZodOptional<z.ZodNumber>;
    scale: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
    scale?: number;
    seed?: number;
    colors?: (string | {
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    })[];
    factor?: number;
    pixelSize?: number;
}, {
    type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
    scale?: number;
    seed?: number;
    colors?: (string | {
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    })[];
    factor?: number;
    pixelSize?: number;
}>;
/**
 * Pixel art overlay.
 */
export declare const PixelArtSchema: z.ZodObject<{
    scaleMode: z.ZodOptional<z.ZodEnum<["unit", "exact", "cover"]>>;
    x: z.ZodOptional<z.ZodNumber>;
    y: z.ZodOptional<z.ZodNumber>;
    lines: z.ZodArray<z.ZodString, "many">;
    palette: z.ZodRecord<z.ZodString, z.ZodObject<{
        r: z.ZodOptional<z.ZodNumber>;
        g: z.ZodOptional<z.ZodNumber>;
        b: z.ZodOptional<z.ZodNumber>;
        a: z.ZodOptional<z.ZodNumber>;
        hex: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        hex?: string;
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }, {
        hex?: string;
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    x?: number;
    y?: number;
    palette?: Record<string, {
        hex?: string;
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }>;
    lines?: string[];
    scaleMode?: "exact" | "unit" | "cover";
}, {
    x?: number;
    y?: number;
    palette?: Record<string, {
        hex?: string;
        b?: number;
        a?: number;
        g?: number;
        r?: number;
    }>;
    lines?: string[];
    scaleMode?: "exact" | "unit" | "cover";
}>;
/**
 * Texture specification.
 */
export declare const TextureSpecSchema: z.ZodObject<{
    file: z.ZodOptional<z.ZodString>;
    generate: z.ZodOptional<z.ZodObject<{
        type: z.ZodEnum<["none", "solid", "random_noise", "dither_noise", "perlin_noise", "stipple_noise", "gradient"]>;
        colors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
            r: z.ZodNumber;
            g: z.ZodNumber;
            b: z.ZodNumber;
            a: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }, {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>]>, "many">>;
        factor: z.ZodOptional<z.ZodNumber>;
        seed: z.ZodOptional<z.ZodNumber>;
        pixelSize: z.ZodOptional<z.ZodNumber>;
        scale: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
        scale?: number;
        seed?: number;
        colors?: (string | {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        })[];
        factor?: number;
        pixelSize?: number;
    }, {
        type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
        scale?: number;
        seed?: number;
        colors?: (string | {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        })[];
        factor?: number;
        pixelSize?: number;
    }>>;
    pixelArt: z.ZodOptional<z.ZodArray<z.ZodObject<{
        scaleMode: z.ZodOptional<z.ZodEnum<["unit", "exact", "cover"]>>;
        x: z.ZodOptional<z.ZodNumber>;
        y: z.ZodOptional<z.ZodNumber>;
        lines: z.ZodArray<z.ZodString, "many">;
        palette: z.ZodRecord<z.ZodString, z.ZodObject<{
            r: z.ZodOptional<z.ZodNumber>;
            g: z.ZodOptional<z.ZodNumber>;
            b: z.ZodOptional<z.ZodNumber>;
            a: z.ZodOptional<z.ZodNumber>;
            hex: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        x?: number;
        y?: number;
        palette?: Record<string, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>;
        lines?: string[];
        scaleMode?: "exact" | "unit" | "cover";
    }, {
        x?: number;
        y?: number;
        palette?: Record<string, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>;
        lines?: string[];
        scaleMode?: "exact" | "unit" | "cover";
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    file?: string;
    generate?: {
        type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
        scale?: number;
        seed?: number;
        colors?: (string | {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        })[];
        factor?: number;
        pixelSize?: number;
    };
    pixelArt?: {
        x?: number;
        y?: number;
        palette?: Record<string, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>;
        lines?: string[];
        scaleMode?: "exact" | "unit" | "cover";
    }[];
}, {
    file?: string;
    generate?: {
        type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
        scale?: number;
        seed?: number;
        colors?: (string | {
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        })[];
        factor?: number;
        pixelSize?: number;
    };
    pixelArt?: {
        x?: number;
        y?: number;
        palette?: Record<string, {
            hex?: string;
            b?: number;
            a?: number;
            g?: number;
            r?: number;
        }>;
        lines?: string[];
        scaleMode?: "exact" | "unit" | "cover";
    }[];
}>;
/**
 * Geometry template types.
 */
export declare const GeometryTemplateSchema: z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>;
/**
 * Geometry specification.
 */
export declare const GeometrySpecSchema: z.ZodObject<{
    file: z.ZodOptional<z.ZodString>;
    template: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
    design: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
    file?: string;
    design?: Record<string, any>;
}, {
    template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
    file?: string;
    design?: Record<string, any>;
}>;
/**
 * Entity traits.
 */
export declare const EntityTraitSchema: z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "flying", "aquatic", "arthropod", "slime", "hostile", "passive", "neutral", "boss", "melee_attacker", "ranged_attacker", "exploder", "trader", "tameable", "rideable", "breedable", "leasable", "undead", "illager", "aquatic_only", "baby_variant", "wanders", "patrols", "guards", "flees_daylight", "teleporter"]>;
/**
 * Entity behavior presets.
 */
export declare const EntityBehaviorPresetSchema: z.ZodEnum<["wander", "swim", "fly_around", "float", "climb", "melee_attack", "ranged_attack", "target_players", "target_monsters", "flee_when_hurt", "retaliate", "follow_owner", "follow_parent", "herd", "avoid_players", "look_at_player", "beg", "tempt", "sit_command", "eat_grass", "break_doors", "open_doors", "pick_up_items", "sleep_in_bed", "hide_from_sun", "go_home_at_night", "seek_water", "seek_land"]>;
/**
 * Drop definition.
 */
export declare const DropSchema: z.ZodObject<{
    item: z.ZodString;
    chance: z.ZodOptional<z.ZodNumber>;
    count: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        max?: number;
        min?: number;
    }, {
        max?: number;
        min?: number;
    }>]>>;
    killedByPlayer: z.ZodOptional<z.ZodBoolean>;
    lootingBonus: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    count?: number | {
        max?: number;
        min?: number;
    };
    item?: string;
    chance?: number;
    killedByPlayer?: boolean;
    lootingBonus?: number;
}, {
    count?: number | {
        max?: number;
        min?: number;
    };
    item?: string;
    chance?: number;
    killedByPlayer?: boolean;
    lootingBonus?: number;
}>;
/**
 * Entity appearance.
 */
export declare const EntityAppearanceSchema: z.ZodObject<{
    bodyType: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
    primaryColor: z.ZodOptional<z.ZodString>;
    secondaryColor: z.ZodOptional<z.ZodString>;
    textureStyle: z.ZodOptional<z.ZodEnum<["solid", "spotted", "striped", "gradient", "organic", "armored"]>>;
    scale: z.ZodOptional<z.ZodNumber>;
    eyes: z.ZodOptional<z.ZodEnum<["normal", "glowing", "red", "none"]>>;
    particles: z.ZodOptional<z.ZodArray<z.ZodEnum<["flames", "smoke", "drip", "sparkle", "hearts"]>, "many">>;
    texture: z.ZodOptional<z.ZodObject<{
        file: z.ZodOptional<z.ZodString>;
        generate: z.ZodOptional<z.ZodObject<{
            type: z.ZodEnum<["none", "solid", "random_noise", "dither_noise", "perlin_noise", "stipple_noise", "gradient"]>;
            colors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                r: z.ZodNumber;
                g: z.ZodNumber;
                b: z.ZodNumber;
                a: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }, {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>]>, "many">>;
            factor: z.ZodOptional<z.ZodNumber>;
            seed: z.ZodOptional<z.ZodNumber>;
            pixelSize: z.ZodOptional<z.ZodNumber>;
            scale: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        }, {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        }>>;
        pixelArt: z.ZodOptional<z.ZodArray<z.ZodObject<{
            scaleMode: z.ZodOptional<z.ZodEnum<["unit", "exact", "cover"]>>;
            x: z.ZodOptional<z.ZodNumber>;
            y: z.ZodOptional<z.ZodNumber>;
            lines: z.ZodArray<z.ZodString, "many">;
            palette: z.ZodRecord<z.ZodString, z.ZodObject<{
                r: z.ZodOptional<z.ZodNumber>;
                g: z.ZodOptional<z.ZodNumber>;
                b: z.ZodOptional<z.ZodNumber>;
                a: z.ZodOptional<z.ZodNumber>;
                hex: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }, {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    }, {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    }>>;
    geometry: z.ZodOptional<z.ZodObject<{
        file: z.ZodOptional<z.ZodString>;
        template: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
        design: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    }, "strip", z.ZodTypeAny, {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    }, {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    }>>;
}, "strip", z.ZodTypeAny, {
    geometry?: {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    };
    particles?: ("sparkle" | "flames" | "smoke" | "drip" | "hearts")[];
    scale?: number;
    bodyType?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
    primaryColor?: string;
    secondaryColor?: string;
    textureStyle?: "gradient" | "solid" | "spotted" | "striped" | "organic" | "armored";
    eyes?: "normal" | "none" | "glowing" | "red";
    texture?: {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    };
}, {
    geometry?: {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    };
    particles?: ("sparkle" | "flames" | "smoke" | "drip" | "hearts")[];
    scale?: number;
    bodyType?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
    primaryColor?: string;
    secondaryColor?: string;
    textureStyle?: "gradient" | "solid" | "spotted" | "striped" | "organic" | "armored";
    eyes?: "normal" | "none" | "glowing" | "red";
    texture?: {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    };
}>;
/**
 * Tameable configuration.
 */
export declare const TameableConfigSchema: z.ZodObject<{
    tameItems: z.ZodArray<z.ZodString, "many">;
    chance: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    chance?: number;
    tameItems?: string[];
}, {
    chance?: number;
    tameItems?: string[];
}>;
/**
 * Rideable configuration.
 */
export declare const RideableConfigSchema: z.ZodObject<{
    seatCount: z.ZodOptional<z.ZodNumber>;
    controllable: z.ZodOptional<z.ZodBoolean>;
    controlItems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    seatCount?: number;
    controllable?: boolean;
    controlItems?: string[];
}, {
    seatCount?: number;
    controllable?: boolean;
    controlItems?: string[];
}>;
/**
 * Breedable configuration.
 */
export declare const BreedableConfigSchema: z.ZodObject<{
    breedItems: z.ZodArray<z.ZodString, "many">;
    breedCooldown: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    breedItems?: string[];
    breedCooldown?: number;
}, {
    breedItems?: string[];
    breedCooldown?: number;
}>;
/**
 * Spawn configuration.
 *
 * There are two spawn-rule shapes: inline on an entity (this one, `entity.spawning`) and a
 * separate top-level `spawnRules[]` entry (SpawnRuleSchema). Use the inline form for a rule
 * bound to a single entity. Use the top-level form when the rule references an entity defined
 * elsewhere (e.g. a vanilla entity) or when you want the rule file separate from the entity.
 */
export declare const SpawnConfigSchema: z.ZodObject<{
    biomes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    weight: z.ZodOptional<z.ZodNumber>;
    groupSize: z.ZodOptional<z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        max?: number;
        min?: number;
    }, {
        max?: number;
        min?: number;
    }>>;
    lightLevel: z.ZodOptional<z.ZodObject<{
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        max?: number;
        min?: number;
    }, {
        max?: number;
        min?: number;
    }>>;
    heightRange: z.ZodOptional<z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        max?: number;
        min?: number;
    }, {
        max?: number;
        min?: number;
    }>>;
    timeOfDay: z.ZodOptional<z.ZodEnum<["day", "night", "any"]>>;
    surface: z.ZodOptional<z.ZodBoolean>;
    spawnOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    populationCap: z.ZodOptional<z.ZodNumber>;
    rarity: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    weight?: number;
    biomes?: string[];
    groupSize?: {
        max?: number;
        min?: number;
    };
    lightLevel?: {
        max?: number;
        min?: number;
    };
    heightRange?: {
        max?: number;
        min?: number;
    };
    timeOfDay?: "any" | "day" | "night";
    surface?: boolean;
    spawnOn?: string[];
    populationCap?: number;
    rarity?: number;
}, {
    weight?: number;
    biomes?: string[];
    groupSize?: {
        max?: number;
        min?: number;
    };
    lightLevel?: {
        max?: number;
        min?: number;
    };
    heightRange?: {
        max?: number;
        min?: number;
    };
    timeOfDay?: "any" | "day" | "night";
    surface?: boolean;
    spawnOn?: string[];
    populationCap?: number;
    rarity?: number;
}>;
/**
 * Entity sounds.
 */
export declare const EntitySoundsSchema: z.ZodObject<{
    ambient: z.ZodOptional<z.ZodString>;
    hurt: z.ZodOptional<z.ZodString>;
    death: z.ZodOptional<z.ZodString>;
    step: z.ZodOptional<z.ZodString>;
    attack: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    step?: string;
    ambient?: string;
    hurt?: string;
    death?: string;
    attack?: string;
}, {
    step?: string;
    ambient?: string;
    hurt?: string;
    death?: string;
    attack?: string;
}>;
/**
 * Entity type definition.
 */
export declare const EntityTypeSchema: z.ZodObject<{
    id: z.ZodString;
    displayName: z.ZodString;
    traits: z.ZodOptional<z.ZodArray<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "flying", "aquatic", "arthropod", "slime", "hostile", "passive", "neutral", "boss", "melee_attacker", "ranged_attacker", "exploder", "trader", "tameable", "rideable", "breedable", "leasable", "undead", "illager", "aquatic_only", "baby_variant", "wanders", "patrols", "guards", "flees_daylight", "teleporter"]>, "many">>;
    health: z.ZodOptional<z.ZodNumber>;
    attackDamage: z.ZodOptional<z.ZodNumber>;
    movementSpeed: z.ZodOptional<z.ZodNumber>;
    followRange: z.ZodOptional<z.ZodNumber>;
    knockbackResistance: z.ZodOptional<z.ZodNumber>;
    scale: z.ZodOptional<z.ZodNumber>;
    collisionWidth: z.ZodOptional<z.ZodNumber>;
    collisionHeight: z.ZodOptional<z.ZodNumber>;
    behaviors: z.ZodOptional<z.ZodArray<z.ZodEnum<["wander", "swim", "fly_around", "float", "climb", "melee_attack", "ranged_attack", "target_players", "target_monsters", "flee_when_hurt", "retaliate", "follow_owner", "follow_parent", "herd", "avoid_players", "look_at_player", "beg", "tempt", "sit_command", "eat_grass", "break_doors", "open_doors", "pick_up_items", "sleep_in_bed", "hide_from_sun", "go_home_at_night", "seek_water", "seek_land"]>, "many">>;
    drops: z.ZodOptional<z.ZodArray<z.ZodObject<{
        item: z.ZodString;
        chance: z.ZodOptional<z.ZodNumber>;
        count: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
            min: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            max?: number;
            min?: number;
        }, {
            max?: number;
            min?: number;
        }>]>>;
        killedByPlayer: z.ZodOptional<z.ZodBoolean>;
        lootingBonus: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        count?: number | {
            max?: number;
            min?: number;
        };
        item?: string;
        chance?: number;
        killedByPlayer?: boolean;
        lootingBonus?: number;
    }, {
        count?: number | {
            max?: number;
            min?: number;
        };
        item?: string;
        chance?: number;
        killedByPlayer?: boolean;
        lootingBonus?: number;
    }>, "many">>;
    appearance: z.ZodOptional<z.ZodObject<{
        bodyType: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
        primaryColor: z.ZodOptional<z.ZodString>;
        secondaryColor: z.ZodOptional<z.ZodString>;
        textureStyle: z.ZodOptional<z.ZodEnum<["solid", "spotted", "striped", "gradient", "organic", "armored"]>>;
        scale: z.ZodOptional<z.ZodNumber>;
        eyes: z.ZodOptional<z.ZodEnum<["normal", "glowing", "red", "none"]>>;
        particles: z.ZodOptional<z.ZodArray<z.ZodEnum<["flames", "smoke", "drip", "sparkle", "hearts"]>, "many">>;
        texture: z.ZodOptional<z.ZodObject<{
            file: z.ZodOptional<z.ZodString>;
            generate: z.ZodOptional<z.ZodObject<{
                type: z.ZodEnum<["none", "solid", "random_noise", "dither_noise", "perlin_noise", "stipple_noise", "gradient"]>;
                colors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }, {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>]>, "many">>;
                factor: z.ZodOptional<z.ZodNumber>;
                seed: z.ZodOptional<z.ZodNumber>;
                pixelSize: z.ZodOptional<z.ZodNumber>;
                scale: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            }, {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            }>>;
            pixelArt: z.ZodOptional<z.ZodArray<z.ZodObject<{
                scaleMode: z.ZodOptional<z.ZodEnum<["unit", "exact", "cover"]>>;
                x: z.ZodOptional<z.ZodNumber>;
                y: z.ZodOptional<z.ZodNumber>;
                lines: z.ZodArray<z.ZodString, "many">;
                palette: z.ZodRecord<z.ZodString, z.ZodObject<{
                    r: z.ZodOptional<z.ZodNumber>;
                    g: z.ZodOptional<z.ZodNumber>;
                    b: z.ZodOptional<z.ZodNumber>;
                    a: z.ZodOptional<z.ZodNumber>;
                    hex: z.ZodOptional<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>>;
            }, "strip", z.ZodTypeAny, {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }, {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            file?: string;
            generate?: {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            };
            pixelArt?: {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }[];
        }, {
            file?: string;
            generate?: {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            };
            pixelArt?: {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }[];
        }>>;
        geometry: z.ZodOptional<z.ZodObject<{
            file: z.ZodOptional<z.ZodString>;
            template: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
            design: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        }, "strip", z.ZodTypeAny, {
            template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
            file?: string;
            design?: Record<string, any>;
        }, {
            template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
            file?: string;
            design?: Record<string, any>;
        }>>;
    }, "strip", z.ZodTypeAny, {
        geometry?: {
            template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
            file?: string;
            design?: Record<string, any>;
        };
        particles?: ("sparkle" | "flames" | "smoke" | "drip" | "hearts")[];
        scale?: number;
        bodyType?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        primaryColor?: string;
        secondaryColor?: string;
        textureStyle?: "gradient" | "solid" | "spotted" | "striped" | "organic" | "armored";
        eyes?: "normal" | "none" | "glowing" | "red";
        texture?: {
            file?: string;
            generate?: {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            };
            pixelArt?: {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }[];
        };
    }, {
        geometry?: {
            template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
            file?: string;
            design?: Record<string, any>;
        };
        particles?: ("sparkle" | "flames" | "smoke" | "drip" | "hearts")[];
        scale?: number;
        bodyType?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        primaryColor?: string;
        secondaryColor?: string;
        textureStyle?: "gradient" | "solid" | "spotted" | "striped" | "organic" | "armored";
        eyes?: "normal" | "none" | "glowing" | "red";
        texture?: {
            file?: string;
            generate?: {
                type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
                scale?: number;
                seed?: number;
                colors?: (string | {
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                })[];
                factor?: number;
                pixelSize?: number;
            };
            pixelArt?: {
                x?: number;
                y?: number;
                palette?: Record<string, {
                    hex?: string;
                    b?: number;
                    a?: number;
                    g?: number;
                    r?: number;
                }>;
                lines?: string[];
                scaleMode?: "exact" | "unit" | "cover";
            }[];
        };
    }>>;
    families: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    hostile: z.ZodOptional<z.ZodBoolean>;
    tameable: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
        tameItems: z.ZodArray<z.ZodString, "many">;
        chance: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        chance?: number;
        tameItems?: string[];
    }, {
        chance?: number;
        tameItems?: string[];
    }>]>>;
    rideable: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
        seatCount: z.ZodOptional<z.ZodNumber>;
        controllable: z.ZodOptional<z.ZodBoolean>;
        controlItems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        seatCount?: number;
        controllable?: boolean;
        controlItems?: string[];
    }, {
        seatCount?: number;
        controllable?: boolean;
        controlItems?: string[];
    }>]>>;
    breedable: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
        breedItems: z.ZodArray<z.ZodString, "many">;
        breedCooldown: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        breedItems?: string[];
        breedCooldown?: number;
    }, {
        breedItems?: string[];
        breedCooldown?: number;
    }>]>>;
    components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    componentGroups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    geometry: z.ZodOptional<z.ZodObject<{
        file: z.ZodOptional<z.ZodString>;
        template: z.ZodOptional<z.ZodEnum<["humanoid", "quadruped", "quadruped_small", "bird", "fish", "insect", "slime", "flying", "block", "item"]>>;
        design: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    }, "strip", z.ZodTypeAny, {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    }, {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    }>>;
    texture: z.ZodOptional<z.ZodObject<{
        file: z.ZodOptional<z.ZodString>;
        generate: z.ZodOptional<z.ZodObject<{
            type: z.ZodEnum<["none", "solid", "random_noise", "dither_noise", "perlin_noise", "stipple_noise", "gradient"]>;
            colors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
                r: z.ZodNumber;
                g: z.ZodNumber;
                b: z.ZodNumber;
                a: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }, {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>]>, "many">>;
            factor: z.ZodOptional<z.ZodNumber>;
            seed: z.ZodOptional<z.ZodNumber>;
            pixelSize: z.ZodOptional<z.ZodNumber>;
            scale: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        }, {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        }>>;
        pixelArt: z.ZodOptional<z.ZodArray<z.ZodObject<{
            scaleMode: z.ZodOptional<z.ZodEnum<["unit", "exact", "cover"]>>;
            x: z.ZodOptional<z.ZodNumber>;
            y: z.ZodOptional<z.ZodNumber>;
            lines: z.ZodArray<z.ZodString, "many">;
            palette: z.ZodRecord<z.ZodString, z.ZodObject<{
                r: z.ZodOptional<z.ZodNumber>;
                g: z.ZodOptional<z.ZodNumber>;
                b: z.ZodOptional<z.ZodNumber>;
                a: z.ZodOptional<z.ZodNumber>;
                hex: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }, {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    }, {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    }>>;
    sounds: z.ZodOptional<z.ZodObject<{
        ambient: z.ZodOptional<z.ZodString>;
        hurt: z.ZodOptional<z.ZodString>;
        death: z.ZodOptional<z.ZodString>;
        step: z.ZodOptional<z.ZodString>;
        attack: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        step?: string;
        ambient?: string;
        hurt?: string;
        death?: string;
        attack?: string;
    }, {
        step?: string;
        ambient?: string;
        hurt?: string;
        death?: string;
        attack?: string;
    }>>;
    spawning: z.ZodOptional<z.ZodObject<{
        biomes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        weight: z.ZodOptional<z.ZodNumber>;
        groupSize: z.ZodOptional<z.ZodObject<{
            min: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            max?: number;
            min?: number;
        }, {
            max?: number;
            min?: number;
        }>>;
        lightLevel: z.ZodOptional<z.ZodObject<{
            min: z.ZodOptional<z.ZodNumber>;
            max: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            max?: number;
            min?: number;
        }, {
            max?: number;
            min?: number;
        }>>;
        heightRange: z.ZodOptional<z.ZodObject<{
            min: z.ZodNumber;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            max?: number;
            min?: number;
        }, {
            max?: number;
            min?: number;
        }>>;
        timeOfDay: z.ZodOptional<z.ZodEnum<["day", "night", "any"]>>;
        surface: z.ZodOptional<z.ZodBoolean>;
        spawnOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        populationCap: z.ZodOptional<z.ZodNumber>;
        rarity: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        weight?: number;
        biomes?: string[];
        groupSize?: {
            max?: number;
            min?: number;
        };
        lightLevel?: {
            max?: number;
            min?: number;
        };
        heightRange?: {
            max?: number;
            min?: number;
        };
        timeOfDay?: "any" | "day" | "night";
        surface?: boolean;
        spawnOn?: string[];
        populationCap?: number;
        rarity?: number;
    }, {
        weight?: number;
        biomes?: string[];
        groupSize?: {
            max?: number;
            min?: number;
        };
        lightLevel?: {
            max?: number;
            min?: number;
        };
        heightRange?: {
            max?: number;
            min?: number;
        };
        timeOfDay?: "any" | "day" | "night";
        surface?: boolean;
        spawnOn?: string[];
        populationCap?: number;
        rarity?: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    geometry?: {
        template?: "flying" | "item" | "slime" | "humanoid" | "block" | "bird" | "insect" | "fish" | "quadruped" | "quadruped_small";
        file?: string;
        design?: Record<string, any>;
    };
    sounds?: {
        step?: string;
        ambient?: string;
        hurt?: string;
        death?: string;
        attack?: string;
    };
    id?: string;
    scale?: number;
    health?: number;
    components?: Record<string, any>;
    events?: Record<string, any>;
    hostile?: boolean;
    traits?: ("flying" | "neutral" | "boss" | "passive" | "teleporter" | "slime" | "hostile" | "humanoid" | "quadruped" | "quadruped_small" | "aquatic" | "arthropod" | "melee_attacker" | "ranged_attacker" | "exploder" | "trader" | "tameable" | "rideable" | "breedable" | "leasable" | "undead" | "illager" | "aquatic_only" | "baby_variant" | "wanders" | "patrols" | "guards" | "flees_daylight")[];
    tameable?: boolean | {
        chance?: number;
        tameItems?: string[];
    };
    rideable?: boolean | {
        seatCount?: number;
        controllable?: boolean;
        controlItems?: string[];
    };
    breedable?: boolean | {
        breedItems?: string[];
        breedCooldown?: number;
    };
    texture?: {
        file?: string;
        generate?: {
            type?: "none" | "gradient" | "solid" | "random_noise" | "dither_noise" | "perlin_noise" | "stipple_noise";
            scale?: number;
            seed?: number;
            colors?: (string | {
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            })[];
            factor?: number;
            pixelSize?: number;
        };
        pixelArt?: {
            x?: number;
            y?: number;
            palette?: Record<string, {
                hex?: string;
                b?: number;
                a?: number;
                g?: number;
                r?: number;
            }>;
            lines?: string[];
            scaleMode?: "exact" | "unit" | "cover";
        }[];
    };
    displayName?: string;
    attackDamage?: number;
    movementSpeed?: number;
    followRange?: number;
    knockbackResistance?: number;
    collisionWidth?: number;
    collisionHeight?: number;
    behaviors?: ("float" | "wander" | "swim" | "fly_around" | "climb" | "melee_attack" | "ranged_attack" | "target_players" | "target_monsters" | "flee_when_hurt" | "retaliate" | "follow_owner" | "follow_parent" | "herd" | "avoid_players" | "look_at_player" | "beg"