@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/editor/ConsolePro.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @file ConsolePro.ts
+ * @description Advanced Console System with filtering and object inspection
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Log levels (info, warn, error, debug, verbose, custom)
+ * - Stack trace capture
+ * - Object inspection/serialization
+ * - Filtering by level, tag, regex
+ * - Search within logs
+ * - Log groups (collapsible)
+ * - Console commands with auto-complete
+ * - Expression evaluation
+ * - Watch expressions
+ * - Export logs
+ * - Log persistence
+ */
+export type LogLevel = 'verbose' | 'debug' | 'info' | 'warn' | 'error' | 'assert' | 'custom';
+export type LogIcon = 'none' | 'info' | 'warn' | 'error' | 'debug' | 'success' | 'failure' | 'network' | 'system';
+export interface StackFrame {
+    functionName: string;
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+    source: string;
+}
+export interface InspectedValue {
+    type: 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' | 'function' | 'symbol' | 'bigint' | 'date' | 'regexp' | 'error' | 'map' | 'set' | 'promise' | 'dom';
+    preview: string;
+    value?: unknown;
+    expandable: boolean;
+    children?: InspectedProperty[];
+    className?: string;
+}
+export interface InspectedProperty {
+    name: string;
+    value: InspectedValue;
+    enumerable: boolean;
+    configurable: boolean;
+    writable: boolean;
+    isGetter: boolean;
+    isSetter: boolean;
+}
+export interface LogEntry {
+    id: string;
+    level: LogLevel;
+    icon: LogIcon;
+    timestamp: number;
+    message: string;
+    formattedMessage?: string;
+    values: InspectedValue[];
+    tags: string[];
+    source?: string;
+    stackTrace?: StackFrame[];
+    count: number;
+    groupId?: string;
+    isGroupStart?: boolean;
+    isGroupEnd?: boolean;
+    isGroupCollapsed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface LogGroup {
+    id: string;
+    label: string;
+    collapsed: boolean;
+    entries: LogEntry[];
+    parent?: string;
+    depth: number;
+}
+export interface ConsoleCommand {
+    name: string;
+    description: string;
+    usage: string;
+    examples: string[];
+    execute: (args: string[], console: ConsolePro) => string | void | Promise<string | void>;
+    autocomplete?: (partial: string, args: string[]) => string[];
+}
+export interface WatchExpression {
+    id: string;
+    expression: string;
+    lastValue: InspectedValue | null;
+    lastError: string | null;
+    breakOnChange: boolean;
+}
+export interface ConsoleProConfig {
+    maxEntries: number;
+    showTimestamps: boolean;
+    showSource: boolean;
+    captureStackTrace: boolean;
+    stackTraceDepth: number;
+    collapseRepeated: boolean;
+    preserveLog: boolean;
+    autoScroll: boolean;
+    wordWrap: boolean;
+    showIcons: boolean;
+    timestampFormat: 'absolute' | 'relative' | 'both';
+    defaultLevelFilter: LogLevel[];
+    defaultTagFilter: string[];
+    enableCommands: boolean;
+    commandPrefix: string;
+}
+export declare const DEFAULT_CONSOLE_CONFIG: ConsoleProConfig;
+export declare function inspectValue(value: unknown, depth?: number, maxDepth?: number): InspectedValue;
+export declare function captureStackTrace(depth?: number): StackFrame[];
+export declare class ConsolePro {
+    private config;
+    private entries;
+    private groups;
+    private currentGroupId;
+    private groupStack;
+    private commands;
+    private watchExpressions;
+    private lastEntryHash;
+    private onEntryAdded?;
+    private onChange?;
+    private onClear?;
+    private levelFilter;
+    private tagFilter;
+    private searchFilter;
+    private regexFilter;
+    private evalContext;
+    constructor(config?: Partial<ConsoleProConfig>);
+    setConfig(config: Partial<ConsoleProConfig>): void;
+    getConfig(): ConsoleProConfig;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    verbose(...args: unknown[]): void;
+    assert(condition: boolean, ...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    network(...args: unknown[]): void;
+    system(...args: unknown[]): void;
+    /**
+     * Log with tags for filtering
+     */
+    tagged(tags: string[], ...args: unknown[]): void;
+    group(label: string): void;
+    groupCollapsed(label: string): void;
+    groupEnd(): void;
+    toggleGroupCollapse(groupId: string): void;
+    table(data: unknown, columns?: string[]): void;
+    private timers;
+    time(label?: string): void;
+    timeLog(label?: string, ...args: unknown[]): void;
+    timeEnd(label?: string): void;
+    private counters;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    clear(): void;
+    private addEntry;
+    private createEntry;
+    private pushEntry;
+    private computeEntryHash;
+    setLevelFilter(levels: LogLevel[]): void;
+    toggleLevelFilter(level: LogLevel): void;
+    setTagFilter(tags: string[]): void;
+    setSearchFilter(search: string): void;
+    setRegexFilter(pattern: string | null): void;
+    getFilteredEntries(): LogEntry[];
+    getAllEntries(): ReadonlyArray<LogEntry>;
+    getEntry(id: string): LogEntry | undefined;
+    getStats(): {
+        total: number;
+        byLevel: Record<LogLevel, number>;
+    };
+    registerCommand(command: ConsoleCommand): void;
+    unregisterCommand(name: string): void;
+    getCommands(): Map<string, ConsoleCommand>;
+    executeCommand(input: string): Promise<string | void>;
+    getAutocomplete(input: string): string[];
+    private registerBuiltInCommands;
+    setEvalContext(context: Record<string, unknown>): void;
+    addToEvalContext(key: string, value: unknown): void;
+    evaluate(expression: string): string | void;
+    addWatchExpression(expression: string, breakOnChange?: boolean): void;
+    removeWatchExpression(expression: string): void;
+    getWatchExpressions(): WatchExpression[];
+    updateWatchExpressions(): void;
+    exportLogs(): string;
+    importLogs(json: string): void;
+    setOnEntryAdded(callback: (entry: LogEntry) => void): void;
+    setOnChange(callback: () => void): void;
+    setOnClear(callback: () => void): void;
+    formatTimestamp(timestamp: number): string;
+}
+export declare function createConsolePro(config?: Partial<ConsoleProConfig>): ConsolePro;
+export declare function createGlobalConsole(config?: Partial<ConsoleProConfig>): ConsolePro;

package/dist/types/editor/CraftingEditor.d.ts

@@ -0,0 +1,222 @@
+/**
+ * @file CraftingEditor.ts
+ * @description Visual Crafting Recipe Editor system
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Recipe definition with ingredients
+ * - Crafting stations/workbenches
+ * - Recipe categories and discovery
+ * - Skill requirements
+ * - Recipe variants and tiers
+ * - Crafting time and progress
+ * - By-products and waste
+ * - Recipe chains
+ * - Salvaging/recycling
+ * - Quality system
+ */
+export type CraftingCategory = 'smithing' | 'alchemy' | 'cooking' | 'tailoring' | 'woodworking' | 'engineering' | 'enchanting' | 'jewelcrafting' | 'inscription' | 'brewing' | 'construction' | 'custom';
+export type RecipeQuality = 'poor' | 'normal' | 'fine' | 'superior' | 'masterwork' | 'legendary';
+export type DiscoveryMethod = 'known' | 'purchased' | 'found' | 'taught' | 'researched' | 'achievement' | 'quest' | 'reputation';
+export interface CraftingIngredient {
+    itemId: string;
+    amount: number;
+    isConsumed: boolean;
+    quality?: RecipeQuality;
+    alternativeIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CraftingOutput {
+    itemId: string;
+    minAmount: number;
+    maxAmount: number;
+    chance: number;
+    quality?: RecipeQuality;
+    bonusFromSkill?: number;
+}
+export interface CraftingRequirement {
+    type: 'skill' | 'level' | 'station' | 'tool' | 'buff' | 'time' | 'location' | 'custom';
+    target: string;
+    value: number | string;
+    description?: string;
+}
+export interface CraftingStation {
+    id: string;
+    name: string;
+    description: string;
+    categories: CraftingCategory[];
+    tier: number;
+    upgradeFrom?: string;
+    icon?: string;
+    modelId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Recipe {
+    id: string;
+    name: string;
+    description: string;
+    category: CraftingCategory;
+    ingredients: CraftingIngredient[];
+    outputs: CraftingOutput[];
+    byproducts?: CraftingOutput[];
+    waste?: CraftingOutput[];
+    requirements: CraftingRequirement[];
+    stationId?: string;
+    skillId?: string;
+    skillRequired: number;
+    craftingTime: number;
+    experienceGained: number;
+    isStackable: boolean;
+    maxBatch: number;
+    discoveryMethod: DiscoveryMethod;
+    discoveredBy: Set<string>;
+    tier: number;
+    previousTier?: string;
+    nextTier?: string;
+    variants?: string[];
+    baseQuality: RecipeQuality;
+    qualityFactors: QualityFactor[];
+    icon?: string;
+    color?: string;
+    tags: string[];
+    isFavorite: boolean;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface QualityFactor {
+    type: 'skill' | 'tool' | 'ingredient' | 'station' | 'buff' | 'random';
+    weight: number;
+    description?: string;
+}
+export interface RecipeChain {
+    id: string;
+    name: string;
+    description: string;
+    recipeIds: string[];
+    automatable: boolean;
+}
+export interface SalvageRule {
+    sourceItemId: string;
+    outputs: CraftingOutput[];
+    skillRequired?: number;
+    toolRequired?: string;
+    preserveEnchantments: boolean;
+}
+export interface CraftingProgress {
+    id: string;
+    recipeId: string;
+    playerId: string;
+    startedAt: number;
+    completesAt: number;
+    quantity: number;
+    isPaused: boolean;
+    pausedAt?: number;
+    accumulatedTime: number;
+    stationId?: string;
+    cancelled: boolean;
+}
+export interface CraftingQueueItem {
+    recipeId: string;
+    quantity: number;
+    priority: number;
+}
+export declare class CraftingEditor {
+    private recipes;
+    private stations;
+    private chains;
+    private salvageRules;
+    private activeProgress;
+    private craftingQueues;
+    private playerSkills;
+    private playerInventory;
+    private discoveredRecipes;
+    private onRecipeDiscovered?;
+    private onCraftingStarted?;
+    private onCraftingProgress?;
+    private onCraftingCompleted?;
+    private onCraftingFailed?;
+    private onQualityDetermined?;
+    private onExperienceGained?;
+    createRecipe(name: string, category: CraftingCategory): Recipe;
+    getRecipe(id: string): Recipe | undefined;
+    updateRecipe(id: string, updates: Partial<Recipe>): boolean;
+    deleteRecipe(id: string): boolean;
+    getAllRecipes(): Recipe[];
+    getRecipesByCategory(category: CraftingCategory): Recipe[];
+    addIngredient(recipeId: string, itemId: string, amount: number, isConsumed?: boolean): boolean;
+    removeIngredient(recipeId: string, index: number): boolean;
+    setIngredientAlternatives(recipeId: string, ingredientIndex: number, alternativeIds: string[]): boolean;
+    addOutput(recipeId: string, itemId: string, minAmount: number, maxAmount?: number, chance?: number): boolean;
+    addByproduct(recipeId: string, itemId: string, chance: number, amount?: number): boolean;
+    addRequirement(recipeId: string, type: CraftingRequirement['type'], target: string, value: number | string, description?: string): boolean;
+    createStation(name: string, categories: CraftingCategory[]): CraftingStation;
+    getStation(id: string): CraftingStation | undefined;
+    getAllStations(): CraftingStation[];
+    getStationsForCategory(category: CraftingCategory): CraftingStation[];
+    createChain(name: string): RecipeChain;
+    addRecipeToChain(chainId: string, recipeId: string): boolean;
+    createSalvageRule(sourceItemId: string): SalvageRule;
+    addSalvageOutput(sourceItemId: string, outputItemId: string, chance: number, amount?: number): boolean;
+    getAvailableRecipes(playerId: string, stationId?: string): Recipe[];
+    canCraft(recipeId: string, playerId: string, quantity?: number): {
+        canCraft: boolean;
+        reason?: string;
+    };
+    private checkRequirement;
+    startCrafting(recipeId: string, playerId: string, quantity?: number): CraftingProgress | null;
+    updateCraftingProgress(_deltaTime: number): void;
+    private completeCrafting;
+    private determineQuality;
+    pauseCrafting(progressId: string): boolean;
+    resumeCrafting(progressId: string): boolean;
+    cancelCrafting(progressId: string, refundIngredients?: boolean): boolean;
+    addToQueue(playerId: string, recipeId: string, quantity: number, priority?: number): boolean;
+    getQueue(playerId: string): CraftingQueueItem[];
+    processQueueItem(playerId: string): CraftingProgress | null;
+    discoverRecipe(recipeId: string, playerId: string): boolean;
+    isRecipeDiscovered(recipeId: string): boolean;
+    canSalvage(itemId: string, playerId: string): boolean;
+    salvageItem(itemId: string, _playerId: string, quantity?: number): CraftingOutput[] | null;
+    setPlayerSkill(skillId: string, level: number): void;
+    setPlayerItem(itemId: string, count: number): void;
+    getPlayerInventory(): Map<string, number>;
+    setOnRecipeDiscovered(callback: (recipe: Recipe, playerId: string) => void): void;
+    setOnCraftingStarted(callback: (progress: CraftingProgress) => void): void;
+    setOnCraftingProgress(callback: (progress: CraftingProgress, percent: number) => void): void;
+    setOnCraftingCompleted(callback: (recipe: Recipe, outputs: CraftingOutput[], quality: RecipeQuality) => void): void;
+    setOnCraftingFailed(callback: (recipe: Recipe, reason: string) => void): void;
+    setOnQualityDetermined(callback: (recipe: Recipe, quality: RecipeQuality, factors: string[]) => void): void;
+    setOnExperienceGained(callback: (skillId: string, amount: number) => void): void;
+    getActiveProgress(): CraftingProgress[];
+    getProgressForPlayer(playerId: string): CraftingProgress[];
+    searchRecipes(query: string): Recipe[];
+    getRecipesByTags(tags: string[]): Recipe[];
+    exportRecipes(): string;
+    importRecipes(json: string): boolean;
+    exportProgress(): string;
+    importProgress(json: string): boolean;
+    getRecipeGraph(recipeId: string): RecipeGraph | null;
+}
+export interface RecipeGraph {
+    nodes: RecipeGraphNode[];
+    edges: RecipeGraphEdge[];
+}
+export interface RecipeGraphNode {
+    id: string;
+    type: 'recipe' | 'ingredient' | 'output' | 'station';
+    name: string;
+    amount?: number | string;
+    x: number;
+    y: number;
+}
+export interface RecipeGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'consumed' | 'catalyst' | 'produces' | 'requires';
+    chance?: number;
+}
+export declare function createCraftingEditor(): CraftingEditor;
+export declare function createIngredient(itemId: string, amount: number, isConsumed?: boolean): CraftingIngredient;
+export declare function createOutput(itemId: string, amount: number, chance?: number): CraftingOutput;

package/dist/types/editor/DialogueSystem.d.ts

@@ -0,0 +1,251 @@
+/**
+ * @file DialogueSystem.ts
+ * @description Branching Dialogue System with localization support
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Dialogue nodes and connections
+ * - Branching conversations
+ * - Conditions for dialogue options
+ * - Variables and state tracking
+ * - Localization support (multiple languages)
+ * - Character/speaker definitions
+ * - Emotions/expressions
+ * - Voice line references
+ * - Custom commands/events
+ * - Import/Export (JSON, Ink, Yarn)
+ * - Dialogue preview/testing
+ */
+export type DialogueNodeType = 'start' | 'dialogue' | 'choice' | 'condition' | 'action' | 'random' | 'hub' | 'end';
+export type ConditionOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'startsWith' | 'endsWith';
+export type LogicalOperator = 'and' | 'or' | 'not';
+export interface DialogueCondition {
+    type: 'variable' | 'flag' | 'item' | 'quest' | 'custom';
+    variable: string;
+    operator: ConditionOperator;
+    value: string | number | boolean;
+    negate?: boolean;
+}
+export interface ConditionGroup {
+    logic: LogicalOperator;
+    conditions: (DialogueCondition | ConditionGroup)[];
+}
+export interface DialogueAction {
+    type: 'setVariable' | 'setFlag' | 'addItem' | 'removeItem' | 'startQuest' | 'completeQuest' | 'playSound' | 'playAnimation' | 'custom';
+    target: string;
+    value?: string | number | boolean;
+    params?: Record<string, unknown>;
+}
+export interface DialogueChoice {
+    id: string;
+    text: LocalizedText;
+    targetNodeId: string;
+    condition?: ConditionGroup;
+    actions?: DialogueAction[];
+    isDefault?: boolean;
+    isHidden?: boolean;
+    once?: boolean;
+    priority?: number;
+    shortcut?: string;
+}
+export interface LocalizedText {
+    key: string;
+    default: string;
+    translations: Map<string, string>;
+}
+export interface Speaker {
+    id: string;
+    name: LocalizedText;
+    displayName?: LocalizedText;
+    portrait?: string;
+    color?: string;
+    voiceId?: string;
+    tags?: string[];
+}
+export interface Emotion {
+    id: string;
+    name: string;
+    portrait?: string;
+    animation?: string;
+    voiceModifier?: number;
+}
+export interface DialogueLine {
+    speakerId: string;
+    text: LocalizedText;
+    emotion?: string;
+    voiceLine?: string;
+    duration?: number;
+    animation?: string;
+    effects?: string[];
+}
+export interface DialogueNode {
+    id: string;
+    type: DialogueNodeType;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    lines?: DialogueLine[];
+    choices?: DialogueChoice[];
+    nextNodeId?: string;
+    condition?: ConditionGroup;
+    randomWeights?: number[];
+    entryActions?: DialogueAction[];
+    exitActions?: DialogueAction[];
+    tags?: string[];
+    notes?: string;
+    color?: string;
+}
+export interface DialogueTree {
+    id: string;
+    name: string;
+    description: string;
+    version: number;
+    nodes: Map<string, DialogueNode>;
+    startNodeId: string;
+    speakers: Map<string, Speaker>;
+    variables: Map<string, DialogueVariable>;
+    flags: Set<string>;
+    defaultLanguage: string;
+    supportedLanguages: string[];
+    tags: string[];
+    createdAt: number;
+    modifiedAt: number;
+}
+export interface DialogueVariable {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    defaultValue: string | number | boolean;
+    description?: string;
+    minValue?: number;
+    maxValue?: number;
+    options?: string[];
+}
+export interface DialogueState {
+    treeId: string;
+    currentNodeId: string;
+    currentLineIndex: number;
+    variables: Map<string, string | number | boolean>;
+    flags: Set<string>;
+    visitedNodes: Set<string>;
+    selectedChoices: Set<string>;
+    history: DialogueHistoryEntry[];
+}
+export interface DialogueHistoryEntry {
+    nodeId: string;
+    lineIndex?: number;
+    choiceId?: string;
+    timestamp: number;
+}
+export interface DialogueRenderData {
+    speaker?: Speaker;
+    emotion?: Emotion;
+    text: string;
+    choices?: {
+        id: string;
+        text: string;
+        available: boolean;
+        shortcut?: string;
+    }[];
+    isEnd: boolean;
+    autoAdvance?: number;
+}
+export declare class DialogueManager {
+    private trees;
+    private speakers;
+    private emotions;
+    private currentState;
+    private currentLanguage;
+    private onDialogueStart?;
+    private onDialogueEnd?;
+    private onNodeEnter?;
+    private onLineDisplay?;
+    private onChoicesDisplay?;
+    private onAction?;
+    private customConditionEvaluator?;
+    createTree(name: string, defaultLanguage?: string): DialogueTree;
+    getTree(id: string): DialogueTree | undefined;
+    deleteTree(id: string): boolean;
+    addNode(treeId: string, node: Partial<DialogueNode>): DialogueNode | null;
+    updateNode(treeId: string, nodeId: string, updates: Partial<DialogueNode>): boolean;
+    deleteNode(treeId: string, nodeId: string): boolean;
+    connectNodes(treeId: string, fromNodeId: string, toNodeId: string, choiceId?: string): boolean;
+    addLine(treeId: string, nodeId: string, line: Partial<DialogueLine>): DialogueLine | null;
+    addChoice(treeId: string, nodeId: string, choice: Partial<DialogueChoice>): DialogueChoice | null;
+    addSpeaker(treeId: string, speaker: Partial<Speaker>): Speaker | null;
+    getSpeaker(id: string): Speaker | undefined;
+    addEmotion(emotion: Emotion): void;
+    getEmotion(id: string): Emotion | undefined;
+    addVariable(treeId: string, variable: DialogueVariable): boolean;
+    setFlag(treeId: string, flag: string, value?: boolean): void;
+    createLocalizedText(defaultText: string, language: string): LocalizedText;
+    setTranslation(text: LocalizedText, language: string, translation: string): void;
+    getText(text: LocalizedText, language?: string): string;
+    setLanguage(language: string): void;
+    addLanguageSupport(treeId: string, language: string): boolean;
+    startDialogue(treeId: string): boolean;
+    endDialogue(): void;
+    private processCurrentNode;
+    private displayDialogueLine;
+    private displayChoices;
+    private getAvailableChoices;
+    advanceLine(): void;
+    selectChoice(choiceId: string): void;
+    private advanceToNextNode;
+    private gotoNode;
+    private evaluateConditionNode;
+    private executeNodeActions;
+    private selectRandomPath;
+    private evaluateConditions;
+    private evaluateCondition;
+    private executeAction;
+    getVariable(name: string): string | number | boolean | undefined;
+    setVariable(name: string, value: string | number | boolean): void;
+    hasFlag(name: string): boolean;
+    isNodeVisited(nodeId: string): boolean;
+    getCurrentState(): DialogueState | null;
+    setOnDialogueStart(callback: (tree: DialogueTree) => void): void;
+    setOnDialogueEnd(callback: (tree: DialogueTree) => void): void;
+    setOnNodeEnter(callback: (node: DialogueNode) => void): void;
+    setOnLineDisplay(callback: (data: DialogueRenderData) => void): void;
+    setOnChoicesDisplay(callback: (choices: DialogueRenderData['choices']) => void): void;
+    setOnAction(callback: (action: DialogueAction) => void): void;
+    setCustomConditionEvaluator(evaluator: (condition: DialogueCondition) => boolean): void;
+    exportToJson(treeId: string): string | null;
+    importFromJson(json: string): DialogueTree | null;
+    exportStringsForLocalization(treeId: string): Map<string, string>;
+    importTranslations(treeId: string, language: string, translations: Map<string, string>): boolean;
+    getGraphData(treeId: string): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    } | null;
+}
+export interface GraphNode {
+    id: string;
+    type: DialogueNodeType;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    color?: string;
+    hasLines: boolean;
+    hasChoices: boolean;
+    hasCondition: boolean;
+}
+export interface GraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'default' | 'choice' | 'condition';
+    label?: string;
+    hasCondition?: boolean;
+}
+export declare function createDialogueManager(): DialogueManager;
+export declare function createDialogueNode(type: DialogueNodeType, name: string, position: {
+    x: number;
+    y: number;
+}): Partial<DialogueNode>;
+export declare function createConditionGroup(logic: LogicalOperator, conditions: (DialogueCondition | ConditionGroup)[]): ConditionGroup;
+export declare function createCondition(type: DialogueCondition['type'], variable: string, operator: ConditionOperator, value: string | number | boolean): DialogueCondition;