udm-rules-vue 0.0.1

package/dist/monaco/MonacoCodeEditor.d.ts

@@ -0,0 +1,34 @@
+import { Datatype } from '../model/Datatype';
+import { RulePart, RulePartConfig } from '../utils';
+import { default as monaco } from './customMonaco';
+import { MonacoParseResult } from './MonacoDiagnosticsBuilder';
+import { default as __DTS_DEFAULT_0__ } from '../grammar/parser/BoostRuleParser';
+import { CommonTokenStream } from 'antlr4ng';
+import { PreconditionContext, ExpressionContext, ActionsContext, RuleStatementContext } from '../grammar/rule/RuleParser';
+import { PlaceholderExpression } from '../model/expression/PlaceholderExpression';
+import { SemanticErrorData } from '..';
+export declare const LIGHT_MONACO_THEME = "udmp-light-theme";
+export declare const DARK_MONACO_THEME = "udmp-dark-theme";
+export declare const createMonacoCodeEditor: (domElement: HTMLElement, configuration: CodeEditorConfiguration) => monaco.editor.IStandaloneCodeEditor;
+export declare const buildExternalEditorModel: (uri: monaco.Uri) => monaco.editor.ITextModel;
+export declare const triggerCodeSuggest: (monacoEditor: monaco.editor.IStandaloneCodeEditor) => void;
+export declare const getMonacoParseResultForCompletion: (model: monaco.editor.ITextModel, position: monaco.Position, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => {
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+    parser: __DTS_DEFAULT_0__;
+    tokensStream: CommonTokenStream;
+    precondition: PreconditionContext | undefined;
+    condition: ExpressionContext | undefined;
+    actionExpression: ExpressionContext | undefined;
+    actionsContext: ActionsContext | undefined;
+    ruleStatement: RuleStatementContext | undefined;
+    placeholderExpressions: PlaceholderExpression[];
+    errorList: SemanticErrorData[];
+};
+export declare const getMonacoParseResult: (model: monaco.editor.ITextModel, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => MonacoParseResult;
+export declare const loadMonacoSemanticTokens: (model: monaco.editor.ITextModel, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => monaco.languages.SemanticTokens;
+export type CodeEditorConfiguration = {
+    id: string;
+    rulePartConfigCallback: () => RulePartConfig;
+    loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>;
+    readOnly?: boolean;
+};

package/dist/monaco/MonacoCompletionProvider.d.ts

@@ -0,0 +1,10 @@
+import { Datatype } from '../model/Datatype';
+import { RulePartConfig } from '../utils';
+import { default as monaco } from './customMonaco';
+export declare class MonacoCompletionItemProvider implements monaco.languages.CompletionItemProvider {
+    private readonly rulePartConfigCallback;
+    private readonly loadAvaliablePredefineVariablesMapCallback;
+    triggerCharacters: string[];
+    constructor(rulePartConfigCallback: () => RulePartConfig, loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>);
+    provideCompletionItems(model: monaco.editor.ITextModel, position: monaco.Position, context: monaco.languages.CompletionContext, token: monaco.CancellationToken): Promise<monaco.languages.CompletionList | null>;
+}

package/dist/monaco/MonacoDefinitionProvider.d.ts

@@ -0,0 +1,7 @@
+import { RulePart } from '../utils';
+import { default as monaco } from './customMonaco';
+export default class MonacoDefinitionProvider implements monaco.languages.DefinitionProvider {
+    private rulePart;
+    constructor(rulePart: RulePart);
+    provideDefinition(model: monaco.editor.ITextModel, position: monaco.Position, token: monaco.CancellationToken): monaco.languages.ProviderResult<monaco.languages.Definition | monaco.languages.LocationLink[]>;
+}

package/dist/monaco/MonacoDiagnosticsBuilder.d.ts

@@ -0,0 +1,21 @@
+import { CommonTokenStream } from 'antlr4ng';
+import { default as BoostRuleParser } from '../grammar/parser/BoostRuleParser';
+import { ActionsContext, ExpressionContext, PreconditionContext, RuleStatementContext } from '../grammar/rule/RuleParser';
+import { Datatype } from '../model/Datatype';
+import { PlaceholderExpression } from '../model/expression/PlaceholderExpression';
+import { RulePart } from '../utils';
+import { default as monaco } from './customMonaco';
+export declare const updateMonacoDiagnostics: (model: monaco.editor.ITextModel, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => MonacoParseResult;
+export type MonacoParseResult = {
+    markerData: monaco.editor.IMarkerData[];
+    parser: BoostRuleParser;
+    semanticTokens: monaco.languages.SemanticTokens;
+    ruleStatement?: RuleStatementContext;
+    precondition?: PreconditionContext;
+    actionExpression?: ExpressionContext;
+    actionsContext?: ActionsContext;
+    condition?: ExpressionContext;
+    tokensStream: CommonTokenStream;
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+};
+export declare const loadPlaceholderExpressions: (id: string, part: RulePart) => PlaceholderExpression[];

package/dist/monaco/MonacoEditorOpener.d.ts

@@ -0,0 +1,4 @@
+import { default as monaco } from './customMonaco';
+export declare class MonacoCodeEditorOpener implements monaco.editor.ICodeEditorOpener {
+    openCodeEditor(source: monaco.editor.ICodeEditor, resource: monaco.Uri, selectionOrPosition?: monaco.IRange | monaco.IPosition): boolean | Promise<boolean>;
+}

package/dist/monaco/MonacoHoverProvider.d.ts

@@ -0,0 +1,16 @@
+import { Datatype } from '../model/Datatype';
+import { RulePartConfig } from '../utils';
+import { default as monaco } from './customMonaco';
+export declare class MonacoHoverProvider implements monaco.languages.HoverProvider<monaco.languages.Hover> {
+    private readonly rulePartConfigCallback;
+    private readonly loadAvaliablePredefineVariablesMapCallback;
+    constructor(rulePartConfigCallback: () => RulePartConfig, loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>);
+    provideHover(model: monaco.editor.ITextModel, position: monaco.Position, token: monaco.CancellationToken, context?: monaco.languages.HoverContext<monaco.languages.Hover>): monaco.languages.ProviderResult<monaco.languages.Hover>;
+    private buildTip;
+    private buildVariable;
+    private findTargetVariableFields;
+    private buildMethodTip;
+    private buildMatchedMethodsDocumentation;
+    private findTagetMethods;
+    private caretInContext;
+}

package/dist/monaco/MonacoJavaEditor.d.ts

@@ -0,0 +1,2 @@
+import { default as monaco } from './customMonaco';
+export declare const createJavaEditor: (domElement: HTMLElement) => monaco.editor.IStandaloneCodeEditor;

package/dist/monaco/MonacoLanguageConfiguration.d.ts

@@ -0,0 +1,3 @@
+import { default as monaco } from './customMonaco';
+declare const monacoLanguageConfiguration: monaco.languages.LanguageConfiguration;
+export default monacoLanguageConfiguration;

package/dist/monaco/MonacoLinkProvider.d.ts

@@ -0,0 +1,7 @@
+import { default as monaco } from './customMonaco';
+import { CodeEditorConfiguration } from './MonacoCodeEditor';
+export default class MonacoLinkProvider implements monaco.languages.LinkProvider {
+    private readonly configuration;
+    constructor(configuration: CodeEditorConfiguration);
+    provideLinks(model: monaco.editor.ITextModel): monaco.languages.ProviderResult<monaco.languages.ILinksList>;
+}

package/dist/monaco/MonacoSemanticTokensProvider.d.ts

@@ -0,0 +1,11 @@
+import { Datatype } from '../model/Datatype';
+import { RulePartConfig } from '../utils';
+import { default as monaco } from './customMonaco';
+export default class MonacoSemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
+    private readonly rulePartConfigCallback;
+    private readonly loadAvaliablePredefineVariablesMapCallback;
+    constructor(rulePartConfigCallback: () => RulePartConfig, loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>);
+    getLegend(): monaco.languages.SemanticTokensLegend;
+    provideDocumentSemanticTokens(model: monaco.editor.ITextModel, lastResultId: string | null, token: monaco.CancellationToken): monaco.languages.ProviderResult<monaco.languages.SemanticTokens | monaco.languages.SemanticTokensEdits>;
+    releaseDocumentSemanticTokens(resultId: string | undefined): void;
+}

package/dist/monaco/MonacoTokenStyleRules.d.ts

@@ -0,0 +1,3 @@
+import { default as monaco } from './customMonaco';
+export declare const lightMonacoTokenStyleRules: monaco.editor.ITokenThemeRule[];
+export declare const darkMonacoTokenStyleRules: monaco.editor.ITokenThemeRule[];

package/dist/monaco/MonacoWorkerInitialize.d.ts

@@ -0,0 +1,2 @@
+export declare const initMonacoWorkers: () => void;
+export declare const terminateMonacoWorker: () => void;

package/dist/monaco/ReadonlyMonacoCodeEditor.d.ts

@@ -0,0 +1,6 @@
+import { default as monaco } from './customMonaco';
+export declare const LIGHT_MONACO_THEME = "udmp-light-theme";
+export declare const DARK_MONACO_THEME = "udmp-dark-theme";
+export declare const createReadonlyMonacoCodeEditor: (domElement: HTMLElement) => monaco.editor.IStandaloneCodeEditor;
+export declare const buildExternalEditorModel: (uri: monaco.Uri) => monaco.editor.ITextModel;
+export declare const triggerCodeSuggest: (monacoEditor: monaco.editor.IStandaloneCodeEditor) => void;

package/dist/monaco/buildTargetPartExpressionSemantics.d.ts

@@ -0,0 +1,31 @@
+import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
+import { ActionsContext, ExpressionContext, PreconditionContext, RuleStatementContext } from '../grammar/rule/RuleParser';
+import { Datatype } from '../model/Datatype';
+import { RulePart } from '../utils';
+import { default as __DTS_DEFAULT_0__ } from '../grammar/parser/BoostRuleParser';
+import { CommonTokenStream } from 'antlr4ng';
+import { PlaceholderExpression } from '../model/expression/PlaceholderExpression';
+export declare const buildTargetPartExpression: (expression: string, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => {
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+    parser: __DTS_DEFAULT_0__;
+    tokensStream: CommonTokenStream;
+    precondition: PreconditionContext | undefined;
+    condition: ExpressionContext | undefined;
+    actionExpression: ExpressionContext | undefined;
+    actionsContext: ActionsContext | undefined;
+    ruleStatement: RuleStatementContext | undefined;
+    placeholderExpressions: PlaceholderExpression[];
+    errorList: SemanticErrorData[];
+};
+export declare const buildTargetPartExpressionSemantics: (expression: string, part: RulePart, initAvaliablePredefineVariablesMap: Map<string, Datatype>) => {
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+    parser: __DTS_DEFAULT_0__;
+    tokensStream: CommonTokenStream;
+    precondition: PreconditionContext | undefined;
+    condition: ExpressionContext | undefined;
+    actionExpression: ExpressionContext | undefined;
+    actionsContext: ActionsContext | undefined;
+    ruleStatement: RuleStatementContext | undefined;
+    placeholderExpressions: PlaceholderExpression[];
+    errorList: SemanticErrorData[];
+};

package/dist/monaco/customMonaco.d.ts

@@ -0,0 +1,2 @@
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+export default monaco;

package/dist/monaco/parseTargetPartRuleScript.d.ts

@@ -0,0 +1,13 @@
+import { CommonTokenStream } from 'antlr4ng';
+import { default as BoostRuleLexer } from '../grammar/parser/BoostRuleLexer';
+import { default as BoostRuleParser } from '../grammar/parser/BoostRuleParser';
+import { Datatype } from '../model/Datatype';
+import { RulePart } from '../utils';
+export declare const parseTargetPartRuleScript: (text: string, part: RulePart, avaliablePredefineVariablesMap: Map<string, Datatype>) => ParsePartResult;
+export type ParsePartResult = {
+    lexer: BoostRuleLexer;
+    parser: BoostRuleParser;
+    tokensStream: CommonTokenStream;
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+    part: RulePart;
+};

package/dist/projectprops/Category.vue.d.ts

@@ -0,0 +1,8 @@
+import { Category } from './ProjectProperties';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    categories: Category[];
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/projectprops/Parameter.vue.d.ts

@@ -0,0 +1,8 @@
+import { Parameter } from './ProjectProperties';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    parameters: Parameter[];
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/projectprops/ProjectProperties.d.ts

@@ -0,0 +1,33 @@
+declare class ProjectProperties {
+    private uuid;
+    private sourceFolder;
+    categories: Category[];
+    parameters: Parameter[];
+    getUuid(): string;
+    setUuid(uuid: string): void;
+    getSourceFolder(): string;
+    checkValid(): string | undefined;
+    toXml(): string;
+    parseXml(xml: string): void;
+}
+declare const projectProperties: ProjectProperties;
+export default projectProperties;
+export type Category = {
+    name: string;
+    value: string;
+};
+export type Parameter = {
+    name: string;
+    nameEditable?: boolean;
+    verbalization: string;
+    genericity?: string;
+    verbalizationEditable?: boolean;
+    genericityEditable?: boolean;
+    type: string;
+    typeEditable?: boolean;
+    initialValue: string;
+    initialValueEditable?: boolean;
+    direction: ParameterScope;
+    directionEditable?: boolean;
+};
+export type ParameterScope = "IN" | "OUT" | "IN_OUT";

package/dist/projectprops/ProjectPropertiesEditor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/projectprops/ProjectPropertiesEditor.vue.d.ts

@@ -0,0 +1,8 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    loadFileCallback: () => Promise<any>;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serialize: () => string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/projectprops/ProjectPropertiesEditorComponent.vue.d.ts

@@ -0,0 +1,3 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/projectprops/PureWebProjectPropertiesEditor.vue.d.ts

@@ -0,0 +1,41 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, GlobalComponents, GlobalDirectives } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    loadFileCallback: () => Promise<any>;
+    loadBomFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadVocFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadVarFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+    loadProjectFilesCallback: () => Promise<{
+        fileName: string;
+        content: string;
+    }[]>;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serialize: () => any;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    projectPropertiesEditor: CreateComponentPublicInstanceWithMixins<Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{}>, {
+        serialize: () => string;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        loadFileCallback: () => Promise<any>;
+    }> & Readonly<{}>, {
+        serialize: () => string;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/projectprops/webview/ProjectPropertiesDocument.d.ts

@@ -0,0 +1,67 @@
+import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, Event } from 'vscode';
+import { DocumentDelegate, ViewEdit } from '../../view&document';
+export declare class ProjectPropertiesDocument implements CustomDocument {
+    static create(uri: Uri, backupId: string | undefined, delegate: DocumentDelegate): Promise<ProjectPropertiesDocument | PromiseLike<ProjectPropertiesDocument>>;
+    private static readFile;
+    private readonly _uri;
+    private _documentData;
+    private _edits;
+    private _savedEdits;
+    private readonly _delegate;
+    private constructor();
+    get uri(): Uri;
+    get documentData(): string;
+    private readonly _onDidDispose;
+    /**
+     * Fired when the document is disposed of.
+     */
+    readonly onDidDispose: Event<void>;
+    private readonly _onDidChangeDocument;
+    /**
+     * Fired to notify webviews that the document has changed.
+     */
+    readonly onDidChangeContent: Event<{
+        readonly edit: ViewEdit;
+    }>;
+    private readonly _onDidChange;
+    /**
+     * Fired to tell VS Code that an edit has occurred in the document.
+     *
+     * This updates the document's dirty indicator.
+     */
+    readonly onDidChange: Event<{
+        readonly label: string;
+        undo(): void;
+        redo(): void;
+    }>;
+    /**
+     * Called by VS Code when there are no more references to the document.
+     *
+     * This happens when all editors for it have been closed.
+     */
+    dispose(): void;
+    /**
+     * Called when the user edits the document in a webview.
+     *
+     * This fires an event to notify VS Code that the document has been edited.
+     */
+    makeEdit(edit: ViewEdit): void;
+    /**
+     * Called by VS Code when the user saves the document.
+     */
+    save(cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code when the user saves the document to a new location.
+     */
+    saveAs(targetResource: Uri, cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code when the user calls `revert` on a document.
+     */
+    revert(_cancellation: CancellationToken): Promise<void>;
+    /**
+     * Called by VS Code to backup the edited document.
+     *
+     * These backups are used to implement hot exit.
+     */
+    backup(destination: Uri, cancellation: CancellationToken): Promise<CustomDocumentBackup>;
+}

package/dist/projectprops/webview/ProjectPropertiesEditorProvider.d.ts

@@ -0,0 +1,26 @@
+import { CancellationToken, CustomDocumentBackup, CustomDocumentBackupContext, CustomDocumentEditEvent, CustomDocumentOpenContext, CustomEditorProvider, Disposable, ExtensionContext, Uri, WebviewPanel, Event } from 'vscode';
+import { ProjectPropertiesDocument } from './ProjectPropertiesDocument';
+export declare const OPEN_PROJECT_PROPERTIES_COMMAND_NAME = "udmp.openProjectProperties";
+export declare class ProjectPropertiesProvider implements CustomEditorProvider<ProjectPropertiesDocument> {
+    readonly context: ExtensionContext;
+    private readonly _onDidChangeCustomDocument;
+    readonly onDidChangeCustomDocument: Event<CustomDocumentEditEvent<ProjectPropertiesDocument>>;
+    private readonly webviews;
+    private static readonly viewType;
+    private _requestId;
+    private readonly _callbacks;
+    private sendBomFileData;
+    private allBomFileParsed;
+    private needSendFileData;
+    constructor(context: ExtensionContext);
+    static register(context: ExtensionContext): Disposable;
+    resolveCustomEditor(document: ProjectPropertiesDocument, webviewPanel: WebviewPanel, token: CancellationToken): Thenable<void> | void;
+    openCustomDocument(uri: Uri, openContext: CustomDocumentOpenContext, token: CancellationToken): Promise<ProjectPropertiesDocument>;
+    saveCustomDocument(document: ProjectPropertiesDocument, cancellation: CancellationToken): Thenable<void>;
+    saveCustomDocumentAs(document: ProjectPropertiesDocument, destination: Uri, cancellation: CancellationToken): Thenable<void>;
+    revertCustomDocument(document: ProjectPropertiesDocument, cancellation: CancellationToken): Thenable<void>;
+    backupCustomDocument(document: ProjectPropertiesDocument, context: CustomDocumentBackupContext, cancellation: CancellationToken): Thenable<CustomDocumentBackup>;
+    private postMessageWithResponse;
+    private postMessage;
+    private onMessage;
+}

package/dist/projectprops/webview/webviewHTMLContent.d.ts

@@ -0,0 +1,8 @@
+import { ExtensionContext, Webview } from 'vscode';
+/**
+ * 构建变量编辑器对应的webview html内容
+ * @param webview webview对象
+ * @param context 插件上下文对象
+ * @returns 返回变量编辑器对应的webview html内容
+ */
+export declare const buildEditorWebviewHtml: (webview: Webview, context: ExtensionContext) => string;

package/dist/quicktest/Log.d.ts

@@ -0,0 +1,49 @@
+export declare const buildLogTreeNodes: (log: Log, clickCallback: (log: Log) => void) => LogTreeNode[];
+export type LogTreeNode = {
+    name: string;
+    log: Log;
+    icon: string;
+    click?: (event: MouseEvent) => void;
+    children: LogTreeNode[];
+};
+export declare const cleanInfo: (info: string) => string;
+export type Log = {
+    type: string;
+    info: string;
+    originalText: string;
+};
+export type GroupLog = Log & {
+    logs: Log[];
+};
+export type ExpressionLog = Log & {};
+export type MatchRuleLog = Log & {
+    ruleInformation: RuleFileInfo;
+};
+export type MethodLog = ExpressionLog & {};
+export type ConditionLog = Log & ExpressionLog & {
+    matched: boolean;
+};
+export type ActionLog = Log & ExpressionLog & {};
+export type TaskLog = Log & GroupLog & {
+    taskInformation: TaskInfo;
+};
+export type RootLog = Log & GroupLog & {};
+export type RuleLog = Log & GroupLog & {
+    ruleInformation: RuleFileInfo;
+};
+export type FlowLog = Log & GroupLog & {
+    flowFileInfo: FlowFileInfo;
+};
+export type FileInfo = {
+    packageName: string;
+};
+export type TaskInfo = FileInfo & {};
+export type FlowFileInfo = FileInfo & {
+    main: boolean;
+};
+export type RuleFileInfo = FileInfo & {
+    priority: number;
+    status: string;
+    effectiveDate: string;
+    expirationDate: string;
+};

package/dist/quicktest/LogDashboard.vue.d.ts

@@ -0,0 +1,8 @@
+import { Log } from './Log';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    log: Log;
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/quicktest/LogDialog.vue.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/quicktest/OutputDashboard.vue.d.ts

@@ -0,0 +1,7 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    jsonData: JSON;
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/quicktest/PasteJsonDialog.vue.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/quicktest/QuickTestDialog.vue.d.ts

@@ -0,0 +1,7 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode: boolean;
+    title?: string;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/quicktest/TestUtils.d.ts

@@ -0,0 +1,42 @@
+import { MenuItem } from '../components/menu/types';
+export declare const doQuickTest: (variableObjects: VariableObject[], config: {
+    fileUuid: string;
+    serverUrl: string;
+    authToken: string;
+    testFileBase64Content: string;
+}) => Promise<Response>;
+export declare const buildVariableObjectData: (variableObjects: VariableObject[]) => Record<string, any>;
+export declare const buildVariableObjectName: (variableObject: VariableObject) => string;
+export declare const buildInvisibleVariablesMenu: (invisibleVariables: VariableObject[], clickCallback: (variableObject: VariableObject) => void) => MenuItem<string>[];
+export declare class VariableObject {
+    id: string;
+    label: string;
+    datatype: string;
+    withInitialScript: boolean;
+    genericity?: string;
+    value: string | VariableObject[] | undefined;
+    fields: VariableObject[];
+    existFieldsSet: Set<string>;
+    constructor(id: string, label: string, datatype: string, withInitialScript: boolean, value?: string);
+    buildData(): Record<string, any>;
+}
+export declare const buildVariableObjectsJsonData: (variableObjects: VariableObject[], format?: boolean) => string;
+export declare const buildVariableObjects: (variables: Variable[], quickTestData: string) => {
+    variables: VariableObject[];
+    invisibleVariables: VariableObject[];
+};
+export declare const buildVariableObject: (variableObject: VariableObject) => VariableObject;
+export type Variable = {
+    id: string;
+    verbalization: string;
+    type: string;
+    value: string;
+    initialScript: string;
+    genericity?: string;
+    defaultValue: string;
+};
+export declare const sampleDatatype: (datatype: string, genericity?: string) => boolean;
+export declare const typeIsCollection: (datatype: string) => boolean;
+export declare const buildObjectFieldsMenu: (variableObject: VariableObject) => MenuItem<string>[];
+export declare const buildSimpleTypeEditor: (type: string) => "number" | "text" | "checkbox" | "date";
+export declare const buildDatatypeGenericity: (datatype: string) => string | undefined;

package/dist/quicktest/VariableForm.vue.d.ts

@@ -0,0 +1,11 @@
+import { VariableObject } from './TestUtils';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    variableObject: VariableObject;
+    darkMode: boolean;
+    enableDelete?: boolean;
+    deleteIndex?: number;
+    deleteCallback?: (index: number) => void;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/refactor/DecisionTableFileRefactor.d.ts

@@ -0,0 +1,6 @@
+import { FileRefactor, RefactorData, RefactorType } from './FileRefactor';
+export declare class DecisionTableFileRefactor implements FileRefactor {
+    refactor(content: string, refactorDataMap: Map<RefactorType, RefactorData[]>): string | undefined;
+    private refactorPartition;
+    support(path: string): boolean;
+}