playlist-data-engine 1.1.0

package/dist/core/skills/SkillQuery.d.ts

@@ -0,0 +1,159 @@
+/**
+ * SkillQuery
+ *
+ * Central query interface for all skills (default D&D 5e and custom).
+ * Provides skill lookup, validation, and categorization.
+ *
+ * **Design:** This is a query layer on top of ExtensionManager.
+ * All skills are stored in ExtensionManager; SkillQuery provides:
+ * - Query methods with caching for performance
+ * - Skill-related helper methods and validation
+ *
+ * **Registration:** Use ExtensionManager.register('skills', [...]) to add custom skills.
+ *
+ * No duplicate storage - all data lives in ExtensionManager.
+ */
+import type { CustomSkill, SkillQueryStats, SkillValidationResult } from './SkillTypes.js';
+import type { Ability, CharacterSheet } from '../types/Character.js';
+/**
+ * SkillQuery - Singleton class for querying skills
+ *
+ * This is a query layer on top of ExtensionManager.
+ * All skills are stored in ExtensionManager; SkillQuery provides:
+ * - Query methods with caching for performance
+ * - Skill-related helper methods and validation
+ *
+ * **Registration:** Use ExtensionManager.register('skills', [...]) to add custom skills.
+ *
+ * Design principle: No duplicate storage. All data lives in ExtensionManager.
+ */
+export declare class SkillQuery {
+    private static instance;
+    private manager;
+    private allSkillsCache;
+    private abilityCache;
+    private categoryCache;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): SkillQuery;
+    /**
+     * Invalidate all caches
+     *
+     * This method is primarily for internal use and advanced scenarios.
+     *
+     * Call this method after directly manipulating ExtensionManager's skill data
+     * (e.g., after calling ExtensionManager.resetAll()).
+     *
+     * This ensures that SkillQuery's cached data is refreshed to reflect
+     * the current state of ExtensionManager.
+     */
+    invalidateCache(): void;
+    /**
+     * Get a skill by ID
+     *
+     * @param id - Skill ID to look up
+     * @returns Skill or undefined if not found
+     */
+    getSkill(id: string): CustomSkill | undefined;
+    /**
+     * Get all registered skills
+     *
+     * Reads from ExtensionManager with caching.
+     *
+     * @returns Array of all skills
+     */
+    getAllSkills(): CustomSkill[];
+    /**
+     * Get skills by ability score
+     *
+     * Builds index from ExtensionManager data with caching.
+     *
+     * @param ability - Ability score to filter by
+     * @returns Array of skills that use this ability
+     */
+    getSkillsByAbility(ability: Ability): CustomSkill[];
+    /**
+     * Get skills by category
+     *
+     * Builds index from ExtensionManager data with caching.
+     *
+     * @param category - Category to filter by
+     * @returns Array of skills in this category
+     */
+    getSkillsByCategory(category: string): CustomSkill[];
+    /**
+     * Get all categories in use
+     *
+     * @returns Array of category names
+     */
+    getCategories(): string[];
+    /**
+     * Get skills by source
+     *
+     * @param source - 'default' or 'custom'
+     * @returns Array of skills from this source
+     */
+    getSkillsBySource(source: 'default' | 'custom'): CustomSkill[];
+    /**
+     * Validate if a skill ID exists
+     *
+     * @param id - Skill ID to validate
+     * @returns True if skill exists
+     */
+    isValidSkill(id: string): boolean;
+    /**
+     * Validate skill data structure
+     *
+     * Delegates to SkillValidator.
+     *
+     * @param skill - Skill object to validate
+     * @returns Validation result with any errors
+     */
+    validateSkill(skill: CustomSkill): SkillValidationResult;
+    /**
+     * Validate skill prerequisites against a character
+     *
+     * Checks if a character meets all prerequisite requirements for a skill.
+     * This is a convenience method that delegates to SkillValidator.
+     *
+     * @param skill - The skill whose prerequisites to validate
+     * @param character - The character sheet to validate against
+     * @returns Validation result with unmet prerequisites if any
+     */
+    validatePrerequisites(skill: CustomSkill, character: CharacterSheet): SkillValidationResult;
+    /**
+     * Get query statistics
+     *
+     * @returns Statistics about registered skills
+     */
+    getQueryStats(): SkillQueryStats;
+    /**
+     * Get the total count of registered skills
+     *
+     * Returns the total number of skills in the registry.
+     *
+     * @returns Total skill count
+     */
+    getSkillCount(): number;
+    /**
+     * Get skills available to a character based on prerequisites
+     *
+     * Returns all skills whose prerequisites are met by the character.
+     * Skills without prerequisites are always available.
+     *
+     * @param character - The character sheet to validate prerequisites against
+     * @returns Array of skills the character can learn
+     */
+    getAvailableSkills(character: CharacterSheet): CustomSkill[];
+}
+/**
+ * Get the global SkillQuery instance
+ *
+ * Convenience function for accessing the singleton.
+ *
+ * @returns SkillQuery instance
+ */
+export declare function getSkillQuery(): SkillQuery;
+//# sourceMappingURL=SkillQuery.d.ts.map

package/dist/core/skills/SkillQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillQuery.d.ts","sourceRoot":"","sources":["../../../src/core/skills/SkillQuery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACR,WAAW,EACX,eAAe,EACf,qBAAqB,EACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIrE;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAa;IACpC,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,aAAa,CAA2C;IAEhE,OAAO;IAIP;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,UAAU;IAOhC;;;;;;;;;;OAUG;IACH,eAAe,IAAI,IAAI;IAMvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAK7C;;;;;;OAMG;IACH,YAAY,IAAI,WAAW,EAAE;IAQ7B;;;;;;;OAOG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE;IAcnD;;;;;;;OAOG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAkBpD;;;;OAIG;IACH,aAAa,IAAI,MAAM,EAAE;IAazB;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,WAAW,EAAE;IAI9D;;;;;OAKG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIjC;;;;;;;OAOG;IACH,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,qBAAqB;IAIxD;;;;;;;;;OASG;IACH,qBAAqB,CACjB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,cAAc,GAC1B,qBAAqB;IAIxB;;;;OAIG;IACH,aAAa,IAAI,eAAe;IA+BhC;;;;;;OAMG;IACH,aAAa,IAAI,MAAM;IAIvB;;;;;;;;OAQG;IACH,kBAAkB,CAAC,SAAS,EAAE,cAAc,GAAG,WAAW,EAAE;CAY/D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAE1C"}

package/dist/core/skills/SkillTypes.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Skill Types
+ *
+ * Type definitions for the extensible skill system.
+ * Supports default D&D 5e skills plus custom skills with metadata.
+ */
+import type { Ability, Class, Race } from '../types/Character.js';
+/**
+ * Prerequisites for learning or using a skill
+ *
+ * Follows the same pattern as FeaturePrerequisite for consistency.
+ * Skills can require:
+ * - A minimum character level
+ * - Other skills to be proficient first
+ * - Features to be learned first
+ * - Spells to be known first
+ * - Minimum ability scores
+ * - Specific class or race
+ * - Custom conditions
+ */
+export interface SkillPrerequisite {
+    /** Minimum character level required */
+    level?: number;
+    /** Minimum ability scores required */
+    abilities?: Partial<Record<'STR' | 'DEX' | 'CON' | 'INT' | 'WIS' | 'CHA', number>>;
+    /** Specific class required */
+    class?: Class;
+    /** Specific race required */
+    race?: Race;
+    /** Skills that must be proficient first (by skill ID) */
+    skills?: string[];
+    /** Features that must be learned first (by feature ID) */
+    features?: string[];
+    /** Spells that must be known first (by spell name) */
+    spells?: string[];
+    /** Custom condition description */
+    custom?: string;
+}
+/**
+ * Custom Skill Interface
+ *
+ * Defines a skill that can be used by characters. Includes all 18 default D&D 5e skills
+ * plus any custom skills added by users or expansion packs.
+ */
+export interface CustomSkill {
+    /**
+     * Unique identifier for the skill (e.g., 'athletics', 'survival_cold')
+     * - Must be lowercase_with_underscores format
+     * - Must be unique across all skills (default + custom)
+     */
+    id: string;
+    /**
+     * Display name for the skill (e.g., 'Athletics', 'Survival (Cold Environments)')
+     */
+    name: string;
+    /**
+     * Optional description of what the skill covers
+     */
+    description?: string;
+    /**
+     * The ability score used for this skill (STR, DEX, CON, INT, WIS, CHA)
+     */
+    ability: Ability;
+    /**
+     * Whether this skill is affected by armor disadvantage
+     * - true: Skills like Athletics, Acrobatics, Sleight of Hand, Stealth have armor penalty
+     * - false: Most knowledge and social skills don't have armor penalty
+     */
+    armorPenalty?: boolean;
+    /**
+     * Optional custom properties for advanced skill mechanics
+     * - Can contain any game-specific data
+     * - Examples: { toolType: 'musical', requiresTraining: true, synergy: ['nature'] }
+     */
+    customProperties?: Record<string, string | number | boolean | string[]>;
+    /**
+     * Optional categories for grouping and filtering skills
+     * - Examples: 'exploration', 'social', 'knowledge', 'combat', 'environmental'
+     * - Used for background skill preferences and skill list filtering
+     */
+    categories?: string[];
+    /**
+     * Where this skill comes from
+     * - 'default': One of the 18 core D&D 5e skills
+     * - 'custom': Added by user or expansion pack
+     */
+    source: 'default' | 'custom';
+    /**
+     * Optional tags for additional categorization
+     * - Examples: ['secret', 'advanced', 'requires_tool']
+     * - Can be used for filtering or prerequisites
+     */
+    tags?: string[];
+    /**
+     * Optional flavor text or lore about the skill
+     */
+    lore?: string;
+    /** Optional icon URL for small UI display */
+    icon?: string;
+    /** Optional image URL for larger display */
+    image?: string;
+    /**
+     * Prerequisites for learning this skill
+     *
+     * If specified, the skill can only be gained by characters who meet
+     * all the prerequisite requirements. This allows for:
+     * - Advanced skills that require base skills
+     * - Class-specific or race-specific skills
+     * - Skills that require certain features (e.g., Draconic Bloodline)
+     * - Skills that require certain spells (e.g., must know fireball)
+     */
+    prerequisites?: SkillPrerequisite;
+}
+/**
+ * Skill Proficiency Interface
+ *
+ * Represents a character's proficiency level in a specific skill.
+ * Used for tracking proficiencies from various sources.
+ */
+export interface SkillProficiency {
+    /**
+     * The skill ID (references CustomSkill.id)
+     */
+    skillId: string;
+    /**
+     * Proficiency level
+     * - 'none': No proficiency (ability modifier only)
+     * - 'proficient': Proficiency bonus added
+     * - 'expertise': Double proficiency bonus
+     */
+    level: 'none' | 'proficient' | 'expertise';
+    /**
+     * Where this proficiency came from
+     * - 'class': Gained from class at level 1
+     * - 'background': Gained from background
+     * - 'feat': Gained from a feat
+     * - 'custom': Gained from custom feature or homebrew
+     * - 'racial': Gained from racial trait
+     * - 'other': Any other source
+     */
+    source: 'class' | 'background' | 'feat' | 'custom' | 'racial' | 'other';
+    /**
+     * Optional feature ID that granted this proficiency
+     * - Links back to the feature in FeatureQuery
+     * - Example: 'rogue_expertise', 'bard_jack_of_all_trades'
+     */
+    grantedBy?: string;
+}
+/**
+ * Skill Selection Weights
+ *
+ * Used for controlling spawn rates when selecting skills for a character.
+ * Allows custom skills to be more or less likely to be selected.
+ */
+export interface SkillSelectionWeights {
+    /**
+     * Map of skill IDs to their selection weights
+     * - Higher weight = more likely to be selected
+     * - Weight of 0 = never selected
+     * - Unspecified skills use default weight of 1.0
+     */
+    weights: Record<string, number>;
+    /**
+     * Selection mode for applying weights
+     * - 'relative': Custom weights added to pool, normalized (default)
+     * - 'absolute': Custom weights replace distribution entirely
+     * - 'default': Equal weights for all skills (ignore weights)
+     */
+    mode?: 'relative' | 'absolute' | 'default';
+}
+/**
+ * Skill List Definition
+ *
+ * Defines available skills and selection parameters for a class.
+ */
+export interface SkillListDefinition {
+    /**
+     * The class this skill list belongs to
+     */
+    class: string;
+    /**
+     * Number of skills to select from the list
+     */
+    skillCount: number;
+    /**
+     * Array of skill IDs available for this class
+     * - Can include default skills or custom skills
+     */
+    availableSkills: string[];
+    /**
+     * Optional weights for skill selection
+     * - Controls which skills are more likely to be selected
+     */
+    selectionWeights?: SkillSelectionWeights;
+    /**
+     * Whether this class grants expertise
+     * - Classes like Bard and Rogue grant expertise at level 1
+     */
+    hasExpertise?: boolean;
+    /**
+     * Number of expertise selections if hasExpertise is true
+     */
+    expertiseCount?: number;
+}
+/**
+ * Validation Result
+ *
+ * Standard result type for skill validation operations.
+ */
+export interface SkillValidationResult {
+    /** Whether the skill is valid */
+    valid: boolean;
+    /** Array of error messages (empty if valid) */
+    errors: string[];
+}
+/**
+ * Skill Query Statistics
+ *
+ * Statistical information about registered skills.
+ */
+export interface SkillQueryStats {
+    /** Total number of registered skills */
+    totalSkills: number;
+    /** Number of default skills */
+    defaultSkills: number;
+    /** Number of custom skills */
+    customSkills: number;
+    /** Skills per ability */
+    skillsByAbility: Record<Ability, number>;
+    /** All categories in use */
+    categories: string[];
+}
+//# sourceMappingURL=SkillTypes.d.ts.map

package/dist/core/skills/SkillTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillTypes.d.ts","sourceRoot":"","sources":["../../../src/core/skills/SkillTypes.ts"],"names":[],"mappings":"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"}

package/dist/core/skills/SkillValidator.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Skill Validator
+ *
+ * Validates custom skills against strict schemas.
+ * Provides comprehensive validation for all skill properties including:
+ * - Required fields (id, name, ability, source)
+ * - Valid enum values (ability, source)
+ * - ID format validation (lowercase_with_underscores)
+ * - Optional fields (description, categories, tags, customProperties)
+ * Uses shared AbilityConstants for code deduplication.
+ */
+import type { SkillValidationResult, SkillPrerequisite } from './SkillTypes.js';
+import type { CharacterSheet, Ability } from '../types/Character.js';
+export type { SkillValidationResult };
+/**
+ * SkillValidator - Validates custom skills
+ *
+ * Provides strict validation to ensure custom skills
+ * meet all requirements before being registered with SkillQuery.
+ */
+export declare class SkillValidator {
+    /**
+     * Validate a custom skill
+     *
+     * Checks all required fields, enum values, and data constraints.
+     *
+     * @param skill - The custom skill to validate
+     * @returns Validation result with errors if any
+     */
+    static validateSkill(skill: unknown): SkillValidationResult;
+    /**
+     * Validate an array of custom skills
+     *
+     * @param skills - Array of custom skills to validate
+     * @returns Validation result with combined errors
+     */
+    static validateSkills(skills: unknown[]): SkillValidationResult;
+    /**
+     * Validate a skill proficiency
+     *
+     * @param proficiency - The skill proficiency to validate
+     * @returns Validation result with errors if any
+     */
+    static validateSkillProficiency(proficiency: unknown): SkillValidationResult;
+    /**
+     * Validate an array of skill proficiencies
+     *
+     * @param proficiencies - Array of skill proficiencies to validate
+     * @returns Validation result with combined errors
+     */
+    static validateSkillProficiencies(proficiencies: unknown[]): SkillValidationResult;
+    /**
+     * Validate a skill list definition
+     *
+     * @param skillList - The skill list definition to validate
+     * @returns Validation result with errors if any
+     */
+    static validateSkillListDefinition(skillList: unknown): SkillValidationResult;
+    /**
+     * Check if a skill ID follows the correct naming convention
+     *
+     * Skill IDs should use lowercase_with_underscores format.
+     * Examples: 'athletics', 'survival_cold', 'arcana_planar'
+     *
+     * @param id - The skill ID to check
+     * @returns True if the ID format is valid
+     */
+    static isValidSkillId(id: string): boolean;
+    /**
+     * Check if a value is a valid ability score
+     *
+     * Re-exports the shared isValidAbility function for convenience.
+     * Uses the same validation as all other systems for consistency.
+     *
+     * @param ability - The ability value to check
+     * @returns True if the value is a valid ability (STR, DEX, CON, INT, WIS, CHA)
+     */
+    static isValidAbility(ability: string): ability is Ability;
+    /**
+     * Validate skill prerequisites against a character
+     *
+     * Checks if a character meets all prerequisite requirements for a skill.
+     * Uses the shared PrerequisiteValidator for consistency across all systems.
+     *
+     * @param prerequisites - The skill prerequisites to validate
+     * @param character - The character sheet to validate against
+     * @returns Validation result with unmet prerequisites if any
+     */
+    static validateSkillPrerequisites(prerequisites: SkillPrerequisite | undefined, character: CharacterSheet): SkillValidationResult;
+}
+/**
+ * Helper function to validate a single skill
+ *
+ * Convenience function for quick validation.
+ *
+ * @param skill - The custom skill to validate
+ * @returns Validation result with errors if any
+ */
+export declare function validateSkill(skill: unknown): SkillValidationResult;
+/**
+ * Helper function to validate an array of skills
+ *
+ * Convenience function for batch validation.
+ *
+ * @param skills - Array of custom skills to validate
+ * @returns Validation result with combined errors
+ */
+export declare function validateSkills(skills: unknown[]): SkillValidationResult;
+/**
+ * Helper function to validate a skill proficiency
+ *
+ * Convenience function for quick validation.
+ *
+ * @param proficiency - The skill proficiency to validate
+ * @returns Validation result with errors if any
+ */
+export declare function validateSkillProficiency(proficiency: unknown): SkillValidationResult;
+/**
+ * Helper function to validate an array of skill proficiencies
+ *
+ * Convenience function for batch validation.
+ *
+ * @param proficiencies - Array of skill proficiencies to validate
+ * @returns Validation result with combined errors
+ */
+export declare function validateSkillProficiencies(proficiencies: unknown[]): SkillValidationResult;
+/**
+ * Helper function to validate a skill list definition
+ *
+ * Convenience function for quick validation.
+ *
+ * @param skillList - The skill list definition to validate
+ * @returns Validation result with errors if any
+ */
+export declare function validateSkillListDefinition(skillList: unknown): SkillValidationResult;
+/**
+ * Helper function to validate skill prerequisites against a character
+ *
+ * Convenience function for quick validation.
+ *
+ * @param prerequisites - The skill prerequisites to validate
+ * @param character - The character sheet to validate against
+ * @returns Validation result with unmet prerequisites if any
+ */
+export declare function validateSkillPrerequisites(prerequisites: SkillPrerequisite | undefined, character: CharacterSheet): SkillValidationResult;
+//# sourceMappingURL=SkillValidator.d.ts.map

package/dist/core/skills/SkillValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillValidator.d.ts","sourceRoot":"","sources":["../../../src/core/skills/SkillValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAMrE,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAiBtC;;;;;GAKG;AACH,qBAAa,cAAc;IACvB;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB;IA2G3D;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,qBAAqB;IAuB/D;;;;;OAKG;IACH,MAAM,CAAC,wBAAwB,CAAC,WAAW,EAAE,OAAO,GAAG,qBAAqB;IA2C5E;;;;;OAKG;IACH,MAAM,CAAC,0BAA0B,CAAC,aAAa,EAAE,OAAO,EAAE,GAAG,qBAAqB;IAuBlF;;;;;OAKG;IACH,MAAM,CAAC,2BAA2B,CAAC,SAAS,EAAE,OAAO,GAAG,qBAAqB;IA+D7E;;;;;;;;OAQG;IACH,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAO1C;;;;;;;;OAQG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,OAAO;IAI1D;;;;;;;;;OASG;IACH,MAAM,CAAC,0BAA0B,CAC7B,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,SAAS,EAAE,cAAc,GAC1B,qBAAqB;CAG3B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,CAEnE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAEvE;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,OAAO,GAAG,qBAAqB,CAEpF;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,aAAa,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAE1F;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,OAAO,GAAG,qBAAqB,CAErF;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACtC,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,SAAS,EAAE,cAAc,GAC1B,qBAAqB,CAEvB"}

package/dist/core/skills/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Skills Module Index
+ *
+ * Exports all skill-related types and utilities.
+ */
+export type { CustomSkill, SkillPrerequisite, SkillProficiency, SkillSelectionWeights, SkillListDefinition, SkillQueryStats, } from './SkillTypes.js';
+export type { SkillValidationResult } from './SkillValidator.js';
+export { SkillQuery, getSkillQuery } from './SkillQuery.js';
+export { DEFAULT_SKILLS, DEFAULT_SKILL_CATEGORIES } from '../../constants/DefaultSkills.js';
+export { SkillValidator, validateSkill, validateSkills, validateSkillProficiency, validateSkillProficiencies, validateSkillListDefinition, validateSkillPrerequisites } from './SkillValidator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/skills/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACR,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,GAClB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAG5F,OAAO,EACH,cAAc,EACd,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC7B,MAAM,qBAAqB,CAAC"}