unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/gameplay/manage-inventory/inventory.data.js

@@ -1,331 +0,0 @@
-import { IP, inventoryRecord } from './schema.js';
-import { P } from '../properties.js';
-export const INVENTORY_RECORDS = [
-    inventoryRecord({
-        action: 'add_loot_entry',
-        summary: 'Add an entry to a loot table asset.',
-        whenToUse: [
-            'A loot table needs another item entry with a drop weight and a quantity range.',
-            'The entry is stored under the key LootEntry_<n>, one past the highest n in use, and n comes back as entryIndex; an earlier removal never makes a new entry overwrite a surviving one.',
-        ],
-        whenNotToUse: [
-            'The loot table asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The table only needs to be read (use manage_inventory.get_inventory_info).',
-        ],
-        inputProps: {
-            lootTablePath: IP.lootTablePath,
-            itemPath: IP.itemPath,
-            lootWeight: IP.lootWeight,
-            minQuantity: IP.minQuantity,
-            maxQuantity: IP.maxQuantity,
-            save: IP.save,
-        },
-        required: ['lootTablePath', 'itemPath'],
-        exampleInput: {
-            action: 'add_loot_entry',
-            lootTablePath: '/Game/Data/LootTables/LT_Common',
-            itemPath: '/Game/Items/DA_Potion',
-            lootWeight: 1,
-        },
-    }),
-    inventoryRecord({
-        action: 'add_recipe_ingredient',
-        summary: 'Add an ingredient to a crafting recipe asset.',
-        whenToUse: [
-            'A recipe needs one more ingredient item with the quantity it consumes.',
-            'The ingredient is stored under the key Ingredient_<n>, one past the highest n in use (the first is Ingredient_0).',
-        ],
-        whenNotToUse: [
-            'The recipe asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The recipe is a custom class, not one made by manage_inventory.create_inventory_asset (use inspect.set_property).',
-        ],
-        inputProps: {
-            recipePath: IP.recipePath,
-            ingredientItemPath: IP.ingredientItemPath,
-            quantity: IP.quantity,
-            save: IP.save,
-        },
-        required: ['recipePath', 'ingredientItemPath'],
-        exampleInput: {
-            action: 'add_recipe_ingredient',
-            recipePath: '/Game/Data/Recipes/R_Potion',
-            ingredientItemPath: '/Game/Items/DA_Herb',
-            quantity: 2,
-        },
-    }),
-    inventoryRecord({
-        action: 'assign_item_category',
-        summary: 'Assign a category to an item asset.',
-        whenToUse: ['An item must be filed under an existing item category asset.'],
-        whenNotToUse: [
-            'The item asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The category asset does not exist yet, and its path is stored without a check (use manage_inventory.create_inventory_asset, kind=item_category).',
-        ],
-        inputProps: { itemPath: IP.itemPath, categoryPath: IP.categoryPath, save: IP.save },
-        required: ['itemPath', 'categoryPath'],
-        exampleInput: {
-            action: 'assign_item_category',
-            itemPath: '/Game/Items/DA_Potion',
-            categoryPath: '/Game/Items/Categories/DA_Consumable',
-            save: true,
-        },
-    }),
-    inventoryRecord({
-        action: 'configure_item_stacking',
-        summary: 'Configure persistent item stacking rules.',
-        whenToUse: [
-            'An item must be marked stackable with a maximum stack size, or flagged as unique.',
-            'All three stacking fields should be given together, since an omitted one resets to stackable, 99 or not unique.',
-        ],
-        whenNotToUse: [
-            'The item asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The item is a custom class with no stacking properties such as bStackable or MaxStackSize: the call fails with PROPERTY_NOT_FOUND and writes nothing (use inspect.set_property).',
-        ],
-        inputProps: {
-            itemPath: IP.itemPath,
-            stackable: IP.stackable,
-            maxStackSize: IP.maxStackSize,
-            uniqueItems: IP.uniqueItems,
-            save: IP.save,
-        },
-        required: ['itemPath'],
-        exampleInput: {
-            action: 'configure_item_stacking',
-            itemPath: '/Game/Items/DA_Potion',
-            stackable: true,
-            maxStackSize: 99,
-        },
-    }),
-    inventoryRecord({
-        action: 'configure_recipe_requirements',
-        summary: 'Configure persistent crafting requirements.',
-        whenToUse: [
-            'A recipe must require a minimum character level or a named crafting station.',
-            'Level and station should be given together, since an omitted one resets to level 0 or station None.',
-        ],
-        whenNotToUse: [
-            'The recipe asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The recipe is a custom class, not one made by manage_inventory.create_inventory_asset (use inspect.set_property).',
-        ],
-        inputProps: {
-            recipePath: IP.recipePath,
-            requiredLevel: IP.requiredLevel,
-            requiredStation: IP.requiredStation,
-            save: IP.save,
-        },
-        required: ['recipePath'],
-        exampleInput: {
-            action: 'configure_recipe_requirements',
-            recipePath: '/Game/Data/Recipes/R_Potion',
-            requiredLevel: 5,
-        },
-    }),
-    inventoryRecord({
-        action: 'create_crafting_recipe',
-        summary: 'Create a crafting recipe asset.',
-        whenToUse: ['A recipe is needed that produces an output item in a set quantity and craft time.'],
-        whenNotToUse: ['Ingredients or requirements must be added to an existing recipe (use manage_inventory.configure_crafting).'],
-        inputProps: {
-            name: IP.name,
-            path: IP.path,
-            outputItemPath: IP.outputItemPath,
-            outputQuantity: IP.outputQuantity,
-            craftTime: IP.craftTime,
-            save: IP.save,
-        },
-        required: ['name', 'outputItemPath'],
-        exampleInput: {
-            action: 'create_crafting_recipe',
-            name: 'R_Potion',
-            outputItemPath: '/Game/Items/DA_Potion',
-            outputQuantity: 1,
-        },
-    }),
-    inventoryRecord({
-        action: 'create_crafting_station',
-        summary: 'Create a crafting station Blueprint asset.',
-        whenToUse: ['A crafting station Blueprint is needed with a station mesh and an interaction box.'],
-        whenNotToUse: ['An actor Blueprint with a different component set is needed (use blueprint.create).'],
-        inputProps: { name: IP.name, path: IP.path, stationType: IP.stationType, save: IP.save },
-        required: ['name'],
-        exampleInput: { action: 'create_crafting_station', name: 'BP_Forge', stationType: 'Basic' },
-    }),
-    inventoryRecord({
-        action: 'create_item_category',
-        summary: 'Create an item category asset.',
-        whenToUse: ['A group such as Consumable or Weapon is needed so items can be filed under it.'],
-        whenNotToUse: ['An existing item only needs to be filed under an existing category (use manage_inventory.configure_item).'],
-        inputProps: { name: IP.name, path: IP.path, save: IP.save },
-        required: ['name'],
-        exampleInput: { action: 'create_item_category', name: 'DA_Consumable', path: '/Game/Items/Categories' },
-    }),
-    inventoryRecord({
-        action: 'create_item_data_asset',
-        summary: 'Create an item data asset.',
-        whenToUse: ['A new item is needed as a data asset that item settings, loot entries and recipes can point at.'],
-        whenNotToUse: ['The item already exists and only its properties, icon, stacking or category change (use manage_inventory.configure_item).'],
-        inputProps: { name: IP.name, path: IP.path, save: IP.save },
-        required: ['name'],
-        exampleInput: { action: 'create_item_data_asset', name: 'DA_Potion', path: '/Game/Items' },
-    }),
-    inventoryRecord({
-        action: 'create_loot_table',
-        summary: 'Create a loot table asset.',
-        whenToUse: ['A loot table asset is needed to hold weighted item entries and quality tiers.'],
-        whenNotToUse: ['Entries or tiers must go into an existing loot table (use manage_inventory.configure_loot).'],
-        inputProps: { name: IP.name, path: IP.path, save: IP.save },
-        required: ['name'],
-        exampleInput: { action: 'create_loot_table', name: 'LT_Common', path: '/Game/Data/LootTables' },
-    }),
-    inventoryRecord({
-        action: 'get_inventory_info',
-        summary: 'Read an inventory asset: an item (properties), loot table (entries with item, weight and quantity range), recipe (ingredients, output item, station, craft time), or a pickup or inventory Blueprint (components, variables).',
-        topics: ['item properties', 'list loot table entries', 'recipe ingredients', 'pickup blueprint variables'],
-        whenToUse: [
-            'The stored fields of an item, loot table or recipe asset must be checked, for example after changing it.',
-            'The components and variable defaults of a pickup or inventory Blueprint must be read.',
-        ],
-        whenNotToUse: [
-            'Assets must first be found by name, class or folder (use asset.query_asset).',
-            'The functions, events or graph node counts of a Blueprint are needed (use inspect.get_blueprint_details).',
-        ],
-        read: true,
-        inputProps: {
-            blueprintPath: IP.blueprintPath,
-            itemPath: IP.itemPath,
-            lootTablePath: IP.lootTablePath,
-            recipePath: IP.recipePath,
-            pickupPath: IP.pickupPath,
-        },
-        outputProps: {
-            assetPath: P.assetPath,
-            assetType: { type: 'string', description: 'Resolved asset type (item, lootTable, recipe, pickup, blueprint).' },
-            className: { type: 'string', description: 'UClass or data asset class name.' },
-            itemPath: IP.itemPath,
-            lootTablePath: IP.lootTablePath,
-            recipePath: IP.recipePath,
-            pickupPath: IP.pickupPath,
-            blueprintPath: IP.blueprintPath,
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Authored item properties.' },
-            category: { type: 'string', description: 'Item category asset path.' },
-            stackable: IP.stackable,
-            maxStackSize: IP.maxStackSize,
-            icon: IP.iconPath,
-            weight: { type: 'number', description: 'Item weight.' },
-            replication: { type: 'string', description: 'Replication condition applied to inventory state.' },
-            lootEntries: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Loot table entries.' },
-            tiers: IP.tiers,
-            lootEntryCount: { type: 'number', description: 'Number of loot entries.' },
-            ingredients: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Recipe ingredients.' },
-            outputItem: { type: 'string', description: 'Recipe output item asset path.' },
-            outputQuantity: IP.outputQuantity,
-            craftTime: IP.craftTime,
-            requiredLevel: IP.requiredLevel,
-            requiredStation: IP.requiredStation,
-            components: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Blueprint SCS components.' },
-            variables: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Blueprint NewVariables (recipes, station settings).' },
-            recipes: IP.recipePaths,
-            unsupportedFields: { type: 'array', items: { type: 'string' }, description: 'Categories the handler could not project.' },
-        },
-        exampleInput: { action: 'get_inventory_info', blueprintPath: '/Game/Blueprints/BP_Player' },
-    }),
-    inventoryRecord({
-        action: 'remove_loot_entry',
-        summary: 'Remove an entry from a loot table asset.',
-        whenToUse: ['A loot table entry must be dropped, chosen by the entryIndex that adding it returned or by its item, which removes every entry for that item.'],
-        whenNotToUse: [
-            'The loot table asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The table only needs to be read (use manage_inventory.get_inventory_info).',
-        ],
-        inputProps: {
-            lootTablePath: IP.lootTablePath,
-            entryIndex: IP.entryIndex,
-            itemPath: IP.itemPath,
-            save: IP.save,
-        },
-        required: ['lootTablePath'],
-        requiredOneOf: ['entryIndex', 'itemPath'],
-        exampleInput: {
-            action: 'remove_loot_entry',
-            lootTablePath: '/Game/Data/LootTables/LT_Common',
-            entryIndex: 0,
-        },
-    }),
-    inventoryRecord({
-        action: 'set_inventory_replication',
-        topics: ['replicate inventory'],
-        summary: 'Set inventory component replication metadata.',
-        whenToUse: [
-            'A Blueprint with InventorySlots, MaxSlots, CurrentWeight and MaxWeight variables must replicate them to clients, or stop (replicated defaults to false).',
-            'Those variables need a replication condition such as OwnerOnly, SkipOwner, SimulatedOnly or InitialOnly.',
-            'A RepNotify function already set on those variables is kept: replicated=true sets only the replication flag and condition, and replicated=false clears the flag and condition and leaves the function name in place.',
-        ],
-        whenNotToUse: [
-            'The Blueprint keeps inventory state in differently named variables (use manage_networking.configure_replication).',
-            'None of the four inventory variables exist yet (add them with blueprint.edit_variable).',
-        ],
-        inputProps: {
-            blueprintPath: IP.blueprintPath,
-            replicated: IP.replicated,
-            replicationCondition: IP.replicationCondition,
-            save: IP.save,
-        },
-        required: ['blueprintPath'],
-        exampleInput: {
-            action: 'set_inventory_replication',
-            blueprintPath: '/Game/Blueprints/BP_Player',
-            replicated: true,
-        },
-    }),
-    inventoryRecord({
-        action: 'set_item_icon',
-        summary: 'Set the icon reference on an item asset.',
-        whenToUse: ['An item needs an icon texture or material path recorded on it.'],
-        whenNotToUse: [
-            'The item asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The icon image is not in the project yet (use asset.import).',
-            'The item is a custom class with none of the properties Icon, ItemIcon, Thumbnail, DisplayIcon or InventoryIcon, so the call fails and names the missing property (use inspect.set_property on the class\'s own icon property).',
-        ],
-        inputProps: { itemPath: IP.itemPath, iconPath: IP.iconPath, save: IP.save },
-        required: ['itemPath'],
-        exampleInput: {
-            action: 'set_item_icon',
-            itemPath: '/Game/Items/DA_Potion',
-            iconPath: '/Game/UI/Icons/T_Potion',
-        },
-    }),
-    inventoryRecord({
-        action: 'set_item_properties',
-        summary: 'Set persistent item asset properties.',
-        whenToUse: ['An item needs custom fields such as a name, description, weight or value written onto its data asset.'],
-        whenNotToUse: [
-            'The item asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The target is a Blueprint or class default rather than an item data asset (use inspect.set_property).',
-        ],
-        inputProps: { itemPath: IP.itemPath, properties: IP.properties, save: IP.save },
-        required: ['itemPath'],
-        exampleInput: {
-            action: 'set_item_properties',
-            itemPath: '/Game/Items/DA_Potion',
-            properties: { DisplayName: 'Potion' },
-            save: true,
-        },
-    }),
-    inventoryRecord({
-        action: 'set_loot_quality_tiers',
-        summary: 'Set quality tiers on a loot table asset.',
-        whenToUse: ['A loot table needs quality tiers with drop weights; the tier list is replaced whole, and five default tiers apply if none are given.'],
-        whenNotToUse: [
-            'The loot table asset does not exist yet (use manage_inventory.create_inventory_asset).',
-            'The table only needs to be read (use manage_inventory.get_inventory_info).',
-        ],
-        inputProps: { lootTablePath: IP.lootTablePath, tiers: IP.tiers, save: IP.save },
-        required: ['lootTablePath'],
-        exampleInput: {
-            action: 'set_loot_quality_tiers',
-            lootTablePath: '/Game/Data/LootTables/LT_Common',
-            tiers: [{ name: 'Rare', dropWeight: 0.1 }],
-        },
-    }),
-];
-//# sourceMappingURL=inventory.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-inventory/schema.d.ts

@@ -1,19 +0,0 @@
-import type { CapabilityRecordSource, JsonObject } from '../../../model.js';
-import type { PropertyMap } from '../properties.js';
-export declare const IP: PropertyMap;
-export interface InventoryActionSpec {
-    readonly action: string;
-    readonly summary: string;
-    readonly topics?: readonly string[];
-    readonly inputProps: PropertyMap;
-    readonly required?: readonly string[];
-    readonly requiredOneOf?: readonly string[];
-    readonly exampleInput: JsonObject;
-    readonly read?: boolean;
-    readonly outputProps?: PropertyMap;
-    readonly outputRequired?: readonly string[];
-    readonly whenToUse?: readonly string[];
-    readonly whenNotToUse?: readonly string[];
-}
-export declare function inventoryRecord(spec: InventoryActionSpec): CapabilityRecordSource;
-//# sourceMappingURL=schema.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-inventory/schema.js

@@ -1,71 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { str, num, bool } from '../../shared/schema-props.js';
-export const IP = {
-    name: P.name,
-    path: P.path,
-    save: bool('Save the asset to disk after the change (default true, for every inventory action). With false the change stays in memory only and is lost when the editor restarts.'),
-    properties: P.properties,
-    blueprintPath: P.blueprintPath,
-    itemPath: P.itemPath,
-    lootTablePath: P.lootTablePath,
-    categoryPath: str('Canonical /Game item category asset path.'),
-    replicated: bool('Whether the inventory component replicates.'),
-    replicationCondition: str('Replication condition name applied to inventory state.'),
-    pickupPath: str('Canonical /Game pickup Blueprint asset path.'),
-    lootWeight: num('Relative selection weight for the loot entry.'),
-    minQuantity: num('Minimum quantity granted by the loot entry.'),
-    maxQuantity: num('Maximum quantity granted by the loot entry.'),
-    entryIndex: num('Number n of the LootEntry_<n> key of the entry to remove: the entryIndex add_loot_entry returned, or the n in a LootEntry_<n> key of get_inventory_info properties. It is a key suffix, not a position: removing an entry renumbers nothing, and a new entry takes one past the highest suffix in use.'),
-    tiers: {
-        type: 'array',
-        items: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                name: { type: 'string', description: 'Quality tier name.' },
-                dropWeight: { type: 'number', description: 'Relative drop weight for the tier.' },
-            },
-            required: ['name', 'dropWeight'],
-        },
-        description: 'Quality tiers, each with a name and a dropWeight.',
-    },
-    outputItemPath: str('Canonical /Game item asset path produced by the recipe.'),
-    outputQuantity: num('Quantity produced per craft.'),
-    craftTime: num('Craft duration in seconds.'),
-    recipePath: str('Canonical /Game crafting recipe asset path.'),
-    requiredLevel: num('Minimum character level required to craft.'),
-    requiredStation: str('Crafting station type required by the recipe.'),
-    ingredientItemPath: str('Canonical /Game ingredient item asset path.'),
-    quantity: num('Ingredient quantity consumed per craft.'),
-    stationType: str('Crafting station type.'),
-    recipePaths: P.arrayOfStrings,
-    iconPath: str('Canonical /Game texture or material path used as the item icon.'),
-    stackable: bool('Whether the item stacks.'),
-    maxStackSize: num('Maximum stack size.'),
-    uniqueItems: bool('Whether duplicate instances of the item are disallowed.'),
-};
-export function inventoryRecord(spec) {
-    return buildRecord({
-        parentTool: 'manage_inventory',
-        id: `manage_inventory.${spec.action}`,
-        action: spec.action,
-        family: 'inventory',
-        summary: spec.summary,
-        topics: spec.topics,
-        whenToUse: [...(spec.whenToUse ?? [])],
-        whenNotToUse: [...(spec.whenNotToUse ?? [])],
-        inputProps: { ...spec.inputProps },
-        required: [...(spec.required ?? [])],
-        requiredOneOf: spec.requiredOneOf,
-        outputProps: spec.outputProps ?? { assetPath: P.assetPath },
-        outputRequired: spec.outputRequired ?? [],
-        effect: spec.read === true ? 'read' : 'write',
-        latency: 'interactive',
-        resources: 'medium',
-        editorStates: ['edit'],
-        exampleInput: spec.exampleInput,
-        exampleOutput: { success: true, message: `${spec.action} handled` },
-    });
-}
-//# sourceMappingURL=schema.js.map

package/dist/tools/catalog/capabilities/records/gameplay/properties.d.ts

@@ -1,4 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const P: PropertyMap;
-export type PropertyMap = Record<string, JsonObject>;
-//# sourceMappingURL=properties.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/properties.js

@@ -1,94 +0,0 @@
-import { bool, num, str, vec3 } from '../shared/schema-props.js';
-export const P = {
-    name: str('Name for the created asset or actor.'),
-    path: str('Canonical /Game output path for the created asset.'),
-    assetPath: str('Canonical /Game asset path.'),
-    blueprintPath: str('Canonical /Game Blueprint asset path.'),
-    skeletalMeshPath: str('Canonical /Game SkeletalMesh asset path.'),
-    physicsAssetPath: str('Canonical /Game PhysicsAsset path.'),
-    skeletonPath: str('Canonical /Game Skeleton asset path.'),
-    animationPath: str('Canonical /Game Animation asset path.'),
-    actorName: str('Target actor name in the current level.'),
-    boneName: str('Target bone name.'),
-    socketName: str('Target socket name.'),
-    meshPath: str('Canonical /Game mesh asset path.'),
-    location: vec3('World or relative location as [x, y, z].'),
-    rotation: vec3('Rotation as [pitch, yaw, roll] in degrees.'),
-    value: { description: 'Property value (any type).' },
-    num_: num('Numeric parameter.'),
-    bool_: bool('Boolean parameter.'),
-    string_: str('String parameter.'),
-    arrayOfStrings: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'List of string values.',
-    },
-    effectPath: str('Canonical /Game gameplay effect asset path.'),
-    abilityPath: str('Canonical /Game gameplay ability asset path.'),
-    attributeSetPath: str('Canonical /Game attribute set asset path.'),
-    damageTypePath: str('Canonical /Game damage type asset path.'),
-    controllerPath: str('Canonical /Game AI controller asset path.'),
-    behaviorTreePath: str('Canonical /Game Behavior Tree asset path.'),
-    blackboardPath: str('Canonical /Game Blackboard asset path.'),
-    stateTreePath: str('Canonical /Game State Tree asset path.'),
-    itemPath: str('Canonical /Game item definition asset path.'),
-    lootTablePath: str('Canonical /Game loot table asset path.'),
-    save: bool('Persist the created/modified asset to disk.'),
-    overwrite: bool('Overwrite an existing asset with the same name.'),
-    duration: num('Duration in seconds.'),
-    time: num('Time in seconds.'),
-    startTime: num('Start time in seconds.'),
-    endTime: num('End time in seconds.'),
-    blendTime: num('Blend duration in seconds.'),
-    frame: num('Frame index.'),
-    length: num('Sequence length.'),
-    frameRate: num('Frames per second.'),
-    minValue: num('Minimum numeric value.'),
-    maxValue: num('Maximum numeric value.'),
-    sampleValue: num('Blend sample coordinate.'),
-    mass: num('Mass value.'),
-    playRate: num('Playback rate.'),
-    linearDamping: num('Linear damping value.'),
-    angularDamping: num('Angular damping value.'),
-    dragCoefficient: num('Drag coefficient.'),
-    tag: str('Gameplay tag string.'),
-    attributeName: str('Target attribute name.'),
-    radius: num('Radius in world units.'),
-    nodeName: str('Graph node name.'),
-    propertyName: str('Property name.'),
-    machineName: str('State machine name.'),
-    stateName: str('State name.'),
-    fromState: str('Source state name.'),
-    toState: str('Target state name.'),
-    cacheName: str('Cached pose name.'),
-    slotName: str('Slot name.'),
-    sectionName: str('Montage section name.'),
-    fromSection: str('Source montage section.'),
-    toSection: str('Target montage section.'),
-    notifyName: str('Animation notify name.'),
-    markerName: str('Animation sync marker name.'),
-    curveName: str('Animation curve name.'),
-    axisName: str('Axis name.'),
-    interpolationType: str('Interpolation mode.'),
-    parentBoneName: str('Parent bone name.'),
-    newBoneName: str('Replacement bone name.'),
-    sourceBoneName: str('Source bone name.'),
-    targetBoneName: str('Target bone name.'),
-    morphTargetName: str('Morph target name.'),
-    addMissing: bool('Whether to add the morph target when the component does not already carry it.'),
-    vehicleType: str('Vehicle type.'),
-    bodyA: str('First physics body.'),
-    bodyB: str('Second physics body.'),
-    activate: bool('Whether to activate the target.'),
-    simulatePhysics: bool('Whether physics simulation is enabled.'),
-    collisionEnabled: bool('Whether collision is enabled.'),
-    compileReferencers: bool('Whether referring assets are compiled.'),
-    rebuildBlendParameters: bool('Whether blend parameters are rebuilt.'),
-    properties: {
-        type: 'object',
-        description: 'Key-value property map.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/inspect/component-actor.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const COMPONENT_ACTOR_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=component-actor.data.d.ts.map