narrat 2.3.0 → 2.3.1

package/dist/utils/logger.d.ts

@@ -1,11 +1,11 @@
-export declare class LogManager {
-    debug: boolean;
-    logger: {
-        [key: string]: (...args: any[]) => void;
-    };
-    setupDebugger(debug: boolean): void;
-}
-export declare const logManager: LogManager;
-export declare const logger: {
-    [key: string]: (...args: any[]) => void;
-};
+export declare class LogManager {
+    debug: boolean;
+    logger: {
+        [key: string]: (...args: any[]) => void;
+    };
+    setupDebugger(debug: boolean): void;
+}
+export declare const logManager: LogManager;
+export declare const logger: {
+    [key: string]: (...args: any[]) => void;
+};

package/dist/utils/object-iterators.d.ts

@@ -1,8 +1,8 @@
-export declare const everyObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => boolean;
-export declare const someObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => true | undefined;
-export declare const mapObject: <T, U>(object: T, mapper: (value: T[keyof T]) => U) => {
-    [key: string]: U;
-};
-export declare const filterObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => {
-    [key: string]: T[keyof T];
-};
+export declare const everyObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => boolean;
+export declare const someObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => true | undefined;
+export declare const mapObject: <T, U>(object: T, mapper: (value: T[keyof T]) => U) => {
+    [key: string]: U;
+};
+export declare const filterObject: <T>(object: T, predicate: (value: T[keyof T]) => boolean) => {
+    [key: string]: T[keyof T];
+};

package/dist/utils/promises.d.ts

@@ -1 +1 @@
-export declare function timeout(durationMs: number): Promise<unknown>;
+export declare function timeout(durationMs: number): Promise<unknown>;

package/dist/utils/randomId.d.ts

@@ -1 +1 @@
-export declare function randomId(): string;
+export declare function randomId(): string;

package/dist/utils/save-helpers.d.ts

@@ -1,18 +1,18 @@
-import { GameSave, SaveFile, SaveSlotMetadata } from '../types/game-save';
-export declare const CURRENT_SAVE_VERSION = "1.3.0";
-export declare function getSaveFile(): SaveFile;
-export declare function saveSlot(saveData: GameSave, slot: string): void;
-export declare function setSaveSlot(slot: string): void;
-export declare function save(): void;
-export declare function getFreeSlot(): string;
-export declare function getSlotIndex(slotId: string): number;
-export declare function getSaveSlot(slotId: string): GameSave | undefined;
-export declare function findAutoSave(): GameSave | undefined;
-export declare function deleteSave(id: string): void;
-export declare function renameSave(id: string, newName: string): void;
-export declare function migrateSaveSlot(save: GameSave | null, index: number): void;
-export declare function generateMetadata(): SaveSlotMetadata;
-export declare type ChosenSlot = {
-    saveData: GameSave | null;
-    slotId: string;
-};
+import { GameSave, SaveFile, SaveSlotMetadata } from '../types/game-save';
+export declare const CURRENT_SAVE_VERSION = "1.3.0";
+export declare function getSaveFile(): SaveFile;
+export declare function saveSlot(saveData: GameSave, slot: string): void;
+export declare function setSaveSlot(slot: string): void;
+export declare function save(): void;
+export declare function getFreeSlot(): string;
+export declare function getSlotIndex(slotId: string): number;
+export declare function getSaveSlot(slotId: string): GameSave | undefined;
+export declare function findAutoSave(): GameSave | undefined;
+export declare function deleteSave(id: string): void;
+export declare function renameSave(id: string, newName: string): void;
+export declare function migrateSaveSlot(save: GameSave | null, index: number): void;
+export declare function generateMetadata(): SaveSlotMetadata;
+export declare type ChosenSlot = {
+    saveData: GameSave | null;
+    slotId: string;
+};

package/dist/utils/skillchecks.d.ts

@@ -1,17 +1,17 @@
-import { SkillCheckParams } from '../vm/vm-helpers';
-export declare function getSkillCheckDifficultyScore(value: number, level: number): number;
-export declare function getSkillCheckDifficultyText(value: number, level: number): string;
-export declare function getSkillCheckText({ skill, skillCheckId, value, }: {
-    skill: string;
-    skillCheckId: string;
-    value: number;
-}): {
-    difficultyText: string;
-    allowed: boolean;
-};
-export declare function getPassiveSkillCheckText(success: boolean, params: SkillCheckParams): string;
-export declare function calculateSkillCheckRoll(skill: string): {
-    roll: number;
-    unmodifiedRoll: number;
-};
-export declare function resolveSkillCheck(params: SkillCheckParams): boolean;
+import { SkillCheckParams } from '../vm/vm-helpers';
+export declare function getSkillCheckDifficultyScore(value: number, level: number): number;
+export declare function getSkillCheckDifficultyText(value: number, level: number): string;
+export declare function getSkillCheckText({ skill, skillCheckId, value, }: {
+    skill: string;
+    skillCheckId: string;
+    value: number;
+}): {
+    difficultyText: string;
+    allowed: boolean;
+};
+export declare function getPassiveSkillCheckText(success: boolean, params: SkillCheckParams): string;
+export declare function calculateSkillCheckRoll(skill: string): {
+    roll: number;
+    unmodifiedRoll: number;
+};
+export declare function resolveSkillCheck(params: SkillCheckParams): boolean;

package/dist/utils/string-helpers.d.ts

@@ -1,3 +1,3 @@
-export declare function processText(text: string): string;
-export declare const stringRegex: RegExp;
-export declare const isParsedTokenString: (arg: any) => boolean;
+export declare function processText(text: string): string;
+export declare const stringRegex: RegExp;
+export declare const isParsedTokenString: (arg: any) => boolean;

package/dist/utils/time-helpers.d.ts

@@ -1,2 +1,2 @@
-export declare function getPlayTime(startedAt: number, previousTime: number): number;
-export declare function toHHMMSS(time: number | string): string;
+export declare function getPlayTime(startedAt: number, previousTime: number): number;
+export declare function toHHMMSS(time: number | string): string;

package/dist/utils/transition.d.ts

@@ -1,15 +1,15 @@
-export declare type TransitionMode = 'screen' | 'button';
-export declare function isTransitionMode(mode: any): mode is TransitionMode;
-export interface TransitionSettings {
-    delay?: number;
-    duration?: number;
-}
-export declare const transitionSettings: {
-    [key: string]: TransitionSettings;
-};
-export declare function getTransitionSettings(name: string): TransitionSettings;
-export declare type AddTransition = {
-    transition: string;
-    duration?: number;
-    delay?: number;
-};
+export declare type TransitionMode = 'screen' | 'button';
+export declare function isTransitionMode(mode: any): mode is TransitionMode;
+export interface TransitionSettings {
+    delay?: number;
+    duration?: number;
+}
+export declare const transitionSettings: {
+    [key: string]: TransitionSettings;
+};
+export declare function getTransitionSettings(name: string): TransitionSettings;
+export declare type AddTransition = {
+    transition: string;
+    duration?: number;
+    delay?: number;
+};

package/dist/utils/type-utils.d.ts

@@ -1,2 +1 @@
-export declare const generateObjectFromList: <T extends readonly string[]>(list: T) => { [K in T[number]]: K; };
-export declare const isPromise: <T>(value: any) => value is Promise<T>;
+export declare const generateObjectFromList: <T extends readonly string[]>(list: T) => { [K in T[number]]: K; };

package/dist/utils/typed-emitter.d.ts

@@ -1,18 +1,18 @@
-export interface InputEvents {
-    keydown: (event: KeyboardEvent) => void;
-}
-export declare type EventsList<List> = {
-    [key in keyof List]: (...args: any[]) => void;
-};
-export declare type EventsMap<List extends EventsList<List>> = {
-    [key in keyof List]: Set<List[key]>;
-};
-export declare class TypedEmitter<List extends EventsList<List>> {
-    listeners: EventsMap<List>;
-    on<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    off<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    once<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
-    emit<Event extends keyof List>(event: Event, ...args: any[]): void;
-    clear(): void;
-    private addEventToMap;
-}
+export interface InputEvents {
+    keydown: (event: KeyboardEvent) => void;
+}
+export declare type EventsList<List> = {
+    [key in keyof List]: (...args: any[]) => void;
+};
+export declare type EventsMap<List extends EventsList<List>> = {
+    [key in keyof List]: Set<List[key]>;
+};
+export declare class TypedEmitter<List extends EventsList<List>> {
+    listeners: EventsMap<List>;
+    on<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    off<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    once<Event extends keyof List>(event: Event, listener: List[Event]): List[Event];
+    emit<Event extends keyof List>(event: Event, ...args: any[]): void;
+    clear(): void;
+    private addEventToMap;
+}

package/dist/vm/commands/arithmetic-commands.d.ts

@@ -1,23 +1,23 @@
-import { CommandPlugin } from './command-plugin';
-export declare const additionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const substractionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const negPlugin: CommandPlugin<{
-    a: number;
-}, {}>;
-export declare const absPlugin: CommandPlugin<{
-    a: number;
-}, {}>;
-export declare const multiplicationPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
-export declare const divisionPlugin: CommandPlugin<{
-    a: number;
-    b: number;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const additionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const substractionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const negPlugin: CommandPlugin<{
+    a: number;
+}, {}>;
+export declare const absPlugin: CommandPlugin<{
+    a: number;
+}, {}>;
+export declare const multiplicationPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;
+export declare const divisionPlugin: CommandPlugin<{
+    a: number;
+    b: number;
+}, {}>;

package/dist/vm/commands/audio-commands.d.ts

@@ -1,15 +1,15 @@
-import { CommandPlugin } from './command-plugin';
-export interface PlayCommandArgs {
-    mode: string;
-    audio: string;
-    channel?: number;
-}
-export declare const playCommand: CommandPlugin<PlayCommandArgs, {}>;
-export declare const pauseCommand: CommandPlugin<{
-    mode: string;
-    channel?: number | undefined;
-}, {}>;
-export declare const stopCommand: CommandPlugin<{
-    mode: string;
-    channel?: number | undefined;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export interface PlayCommandArgs {
+    mode: string;
+    audio: string;
+    channel?: number;
+}
+export declare const playCommand: CommandPlugin<PlayCommandArgs, {}>;
+export declare const pauseCommand: CommandPlugin<{
+    mode: string;
+    channel?: number | undefined;
+}, {}>;
+export declare const stopCommand: CommandPlugin<{
+    mode: string;
+    channel?: number | undefined;
+}, {}>;

package/dist/vm/commands/choice.d.ts

@@ -1,37 +1,37 @@
-import { CommandParserFunction, CommandParsingContext, CommandPlugin, CommandRunner } from './command-plugin';
-import { Parser } from '../../types/parser';
-export declare const runChoice: CommandRunner<ChoiceOptions, StaticChoiceOptions>;
-export declare function parseChoiceOption(ctx: CommandParsingContext, choice: Parser.Line): BranchingChoiceInfo;
-export interface BranchingChoiceInfo {
-    prompt: Parser.ParsedExpression;
-    branch?: Parser.Branch;
-    skillBranches?: {
-        success: Parser.Branch;
-        failure: Parser.Branch;
-    };
-}
-export interface StaticChoiceOptions {
-    choices: BranchingChoiceInfo[];
-    prompt: Parser.ParsedExpression;
-}
-export interface ChoiceOptions {
-}
-export declare const choiceParser: CommandParserFunction<ChoiceOptions, StaticChoiceOptions>;
-export declare const choicePlugin: CommandPlugin<ChoiceOptions, StaticChoiceOptions>;
-export interface ChoicePromptOptions {
-    promptText: string;
-    condition: boolean;
-}
-export interface ChoicePromptReturnValue {
-    text: string | null;
-    skillCheck?: {
-        allowed: boolean;
-        skillId: string;
-        skillCheckId: string;
-        difficulty: number;
-        hideAfterRoll: boolean;
-    };
-}
-export declare type ChoicePromptReturn = ChoicePromptReturnValue;
-/** Custom "fake" instruction generated on choice prompts to process their optional conditions */
-export declare const choicePromptCommandPlugin: CommandPlugin<ChoicePromptOptions, {}>;
+import { CommandParserFunction, CommandParsingContext, CommandPlugin, CommandRunner } from './command-plugin';
+import { Parser } from '../../types/parser';
+export declare const runChoice: CommandRunner<ChoiceOptions, StaticChoiceOptions>;
+export declare function parseChoiceOption(ctx: CommandParsingContext, choice: Parser.Line): BranchingChoiceInfo;
+export interface BranchingChoiceInfo {
+    prompt: Parser.ParsedExpression;
+    branch?: Parser.Branch;
+    skillBranches?: {
+        success: Parser.Branch;
+        failure: Parser.Branch;
+    };
+}
+export interface StaticChoiceOptions {
+    choices: BranchingChoiceInfo[];
+    prompt: Parser.ParsedExpression;
+}
+export interface ChoiceOptions {
+}
+export declare const choiceParser: CommandParserFunction<ChoiceOptions, StaticChoiceOptions>;
+export declare const choicePlugin: CommandPlugin<ChoiceOptions, StaticChoiceOptions>;
+export interface ChoicePromptOptions {
+    promptText: string;
+    condition: boolean;
+}
+export interface ChoicePromptReturnValue {
+    text: string | null;
+    skillCheck?: {
+        allowed: boolean;
+        skillId: string;
+        skillCheckId: string;
+        difficulty: number;
+        hideAfterRoll: boolean;
+    };
+}
+export declare type ChoicePromptReturn = ChoicePromptReturnValue;
+/** Custom "fake" instruction generated on choice prompts to process their optional conditions */
+export declare const choicePromptCommandPlugin: CommandPlugin<ChoicePromptOptions, {}>;

package/dist/vm/commands/clear_dialog.d.ts

@@ -1,2 +1,2 @@
-import { CommandPlugin } from './command-plugin';
-export declare const clearDialogPlugin: CommandPlugin<{}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const clearDialogPlugin: CommandPlugin<{}, {}>;

package/dist/vm/commands/command-helpers.d.ts

@@ -1,3 +1,3 @@
-import { Parser } from '../../types/parser';
-export declare function commandRuntimeError(cmd: Parser.Command<any, any>, errorText: string): void;
-export declare function commandLog(cmd: Parser.Command<any, any>, ...log: any[]): void;
+import { Parser } from '../../types/parser';
+export declare function commandRuntimeError(cmd: Parser.Command<any, any>, errorText: string): void;
+export declare function commandLog(cmd: Parser.Command<any, any>, ...log: any[]): void;

package/dist/vm/commands/command-plugin.d.ts

@@ -1,43 +1,43 @@
-import { Parser } from '../../types/parser';
-import { ParserContext } from '../vm-parser';
-import { DialogChoice } from '../../stores/dialog-store';
-export declare type CommandRunner<Options, StaticOptions = {}> = (cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]) => Promise<any>;
-export declare type CommandParserFunction<Options, StaticOptions = {}> = (ctx: CommandParsingContext, command: Parser.ParsedExpression<Options, StaticOptions>) => {
-    newLine: number;
-};
-export declare type ProcessCommandsFunction = (ctx: ParserContext, lines: Parser.Line[], parentLine: Parser.Line | undefined) => Parser.Branch;
-export interface CommandParsingContext {
-    parserContext: ParserContext;
-    processCommandsFunction: ProcessCommandsFunction;
-    line: Parser.Line;
-    lines: Parser.Line[];
-    currentLine: number;
-}
-export declare type OnPlayerAnswered<Options, StaticOptions> = (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<any>;
-export interface CommandPluginOptions<Options, StaticOptions = {}> {
-    keyword: string;
-    argTypes: ArgTypes;
-    runner: CommandRunner<Options, StaticOptions>;
-    parser?: CommandParserFunction<Options, StaticOptions>;
-    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
-    returnAfterPlayerAnswer?: boolean;
-}
-export declare class CommandPlugin<Options, StaticOptions = {}> {
-    keyword: string;
-    runner: CommandRunner<Options, StaticOptions>;
-    argTypes: ArgTypes;
-    parser: CommandParserFunction<Options, StaticOptions>;
-    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
-    returnAfterPlayerAnswer: boolean;
-    constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
-    run(cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]): Promise<any>;
-    processPlayerAnswer(cmd: Parser.Command<Options, StaticOptions>, choice: number | string): Promise<any>;
-    static FromOptions<Options, StaticOptions = {}>(options: CommandPluginOptions<Options, StaticOptions>): CommandPlugin<Options, StaticOptions>;
-}
-export declare type ArgTypes = ArgumentDescription[] | 'any';
-export interface ArgumentDescription {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'any';
-    optional?: boolean;
-}
-export declare function generateParser<Options, StaticOptions = {}>(keyword: string, argTypes: ArgTypes): CommandParserFunction<Options, StaticOptions>;
+import { Parser } from '../../types/parser';
+import { ParserContext } from '../vm-parser';
+import { DialogChoice } from '../../stores/dialog-store';
+export declare type CommandRunner<Options, StaticOptions = {}> = (cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]) => Promise<any>;
+export declare type CommandParserFunction<Options, StaticOptions = {}> = (ctx: CommandParsingContext, command: Parser.ParsedExpression<Options, StaticOptions>) => {
+    newLine: number;
+};
+export declare type ProcessCommandsFunction = (ctx: ParserContext, lines: Parser.Line[], parentLine: Parser.Line | undefined) => Parser.Branch;
+export interface CommandParsingContext {
+    parserContext: ParserContext;
+    processCommandsFunction: ProcessCommandsFunction;
+    line: Parser.Line;
+    lines: Parser.Line[];
+    currentLine: number;
+}
+export declare type OnPlayerAnswered<Options, StaticOptions> = (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<any>;
+export interface CommandPluginOptions<Options, StaticOptions = {}> {
+    keyword: string;
+    argTypes: ArgTypes;
+    runner: CommandRunner<Options, StaticOptions>;
+    parser?: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer?: boolean;
+}
+export declare class CommandPlugin<Options, StaticOptions = {}> {
+    keyword: string;
+    runner: CommandRunner<Options, StaticOptions>;
+    argTypes: ArgTypes;
+    parser: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer: boolean;
+    constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
+    run(cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]): Promise<any>;
+    processPlayerAnswer(cmd: Parser.Command<Options, StaticOptions>, choice: number | string): Promise<any>;
+    static FromOptions<Options, StaticOptions = {}>(options: CommandPluginOptions<Options, StaticOptions>): CommandPlugin<Options, StaticOptions>;
+}
+export declare type ArgTypes = ArgumentDescription[] | 'any';
+export interface ArgumentDescription {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'any';
+    optional?: boolean;
+}
+export declare function generateParser<Options, StaticOptions = {}>(keyword: string, argTypes: ArgTypes): CommandParserFunction<Options, StaticOptions>;

package/dist/vm/commands/flow-commands.d.ts

@@ -1,24 +1,24 @@
-import { CommandPlugin } from './command-plugin';
-export declare const jumpCommand: CommandPlugin<{
-    label: string;
-}, {}>;
-export declare const runLabelPlugin: CommandPlugin<{
-    label: string;
-}, {}>;
-export declare const defineVariablePlugin: CommandPlugin<{
-    name: string;
-    value: any;
-}, {}>;
-export declare const returnPlugin: CommandPlugin<{
-    value: any;
-}, {}>;
-export declare const logPlugin: CommandPlugin<{
-    value: any;
-}, {}>;
-export declare const returnMainMenuPlugin: CommandPlugin<{}, {}>;
-export declare const savePlugin: CommandPlugin<{
-    name?: string | undefined;
-}, {}>;
-export declare const savePromptPlugin: CommandPlugin<{
-    name?: string | undefined;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export declare const jumpCommand: CommandPlugin<{
+    label: string;
+}, {}>;
+export declare const runLabelPlugin: CommandPlugin<{
+    label: string;
+}, {}>;
+export declare const defineVariablePlugin: CommandPlugin<{
+    name: string;
+    value: any;
+}, {}>;
+export declare const returnPlugin: CommandPlugin<{
+    value: any;
+}, {}>;
+export declare const logPlugin: CommandPlugin<{
+    value: any;
+}, {}>;
+export declare const returnMainMenuPlugin: CommandPlugin<{}, {}>;
+export declare const savePlugin: CommandPlugin<{
+    name?: string | undefined;
+}, {}>;
+export declare const savePromptPlugin: CommandPlugin<{
+    name?: string | undefined;
+}, {}>;

package/dist/vm/commands/if.d.ts

@@ -1,10 +1,10 @@
-import { CommandPlugin } from './command-plugin';
-import { Parser } from '../../types/parser';
-export interface IfOptions {
-    condition: boolean;
-}
-export interface IfStaticOptions {
-    success: Parser.Branch;
-    failure?: Parser.Branch;
-}
-export declare const ifCommand: CommandPlugin<IfOptions, IfStaticOptions>;
+import { CommandPlugin } from './command-plugin';
+import { Parser } from '../../types/parser';
+export interface IfOptions {
+    condition: boolean;
+}
+export interface IfStaticOptions {
+    success: Parser.Branch;
+    failure?: Parser.Branch;
+}
+export declare const ifCommand: CommandPlugin<IfOptions, IfStaticOptions>;

package/dist/vm/commands/index.d.ts

@@ -1,2 +1,2 @@
-import { VM } from '../vm';
-export declare function registerBaseCommands(vm: VM): void;
+import { VM } from '../vm';
+export declare function registerBaseCommands(vm: VM): void;

package/dist/vm/commands/inventory-commands.d.ts

@@ -1,15 +1,15 @@
-import { CommandPlugin } from './command-plugin';
-export interface InventoryChangeArgs {
-    id: string;
-    amount: number;
-}
-export declare const addItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
-export declare const removeItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
-export declare const hasItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
-export declare const itemAmountPlugin: CommandPlugin<InventoryChangeArgs, {}>;
-export declare const enableInteractionPlugin: CommandPlugin<{
-    tag: string;
-}, {}>;
-export declare const disableInteractionPlugin: CommandPlugin<{
-    tag: string;
-}, {}>;
+import { CommandPlugin } from './command-plugin';
+export interface InventoryChangeArgs {
+    id: string;
+    amount: number;
+}
+export declare const addItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const removeItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const hasItemPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const itemAmountPlugin: CommandPlugin<InventoryChangeArgs, {}>;
+export declare const enableInteractionPlugin: CommandPlugin<{
+    tag: string;
+}, {}>;
+export declare const disableInteractionPlugin: CommandPlugin<{
+    tag: string;
+}, {}>;