udm-rules-vue 0.0.2 → 0.0.4

package/dist/rfl/webview/RuleFlowEditorProvider.d.ts

@@ -3,6 +3,7 @@ import { WebviewCollection } from '../../WebviewCollection';
 import { RuleFlowDocument } from './RuleFlowDocument';
 import * as vscode from "vscode";
 export declare const NEW_RULE_FLOW_FILE_COMMAND_NAME = "udmp.createNewRuleFlowFile";
+export declare const REGISTER_CUSTOM_NODE_TYPE_COMMAND = "udmp.registerCustomNodeType";
 export declare class RuleFlowEditorProvider implements CustomEditorProvider<RuleFlowDocument> {
     readonly context: ExtensionContext;
     private readonly _onDidChangeCustomDocument;
@@ -15,6 +16,9 @@ export declare class RuleFlowEditorProvider implements CustomEditorProvider<Rule
     private sendBomFileData;
     private allBomFileParsed;
     private needSendFileData;
+    private allUuidParsed;
+    private wattingFileData;
+    private allUuidParsedListener;
     constructor(context: ExtensionContext);
     static register(context: ExtensionContext): {
         ruleFlowDisposable: vscode.Disposable;
@@ -29,5 +33,6 @@ export declare class RuleFlowEditorProvider implements CustomEditorProvider<Rule
     backupCustomDocument(document: RuleFlowDocument, context: CustomDocumentBackupContext, cancellation: CancellationToken): Thenable<CustomDocumentBackup>;
     private postMessageWithResponse;
     private postMessage;
+    private postTheFileDataMessage;
     private onMessage;
 }

package/dist/sca/AvaliablePredefineBuilder.d.ts

@@ -0,0 +1,4 @@
+import { Datatype } from '../model/Datatype';
+import { default as monaco } from '../monaco/customMonaco';
+export declare const buildAvaliablePredefineWithSCA: (preConditionMonacoEditor: monaco.editor.IStandaloneCodeEditor | null) => Map<string, Datatype>;
+export declare const buildAvaliablePredefineWithoutSCA: (preConditionMonacoEditor: monaco.editor.IStandaloneCodeEditor | null) => Map<string, Datatype>;

package/dist/sca/ContentEditableController.d.ts

@@ -0,0 +1,50 @@
+import { Datatype } from '../model/Datatype';
+import { default as monaco } from '../monaco/customMonaco';
+import { RulePart } from '../utils';
+import { ScoreCardTable } from './component/ScoreCardTable';
+import { ContentCell } from './model/ScoreCardAttribute';
+/**
+ * 实现代码编辑器的动态可部分编辑区域
+ *
+ * 可编辑区域由多个可编辑范围组成，每个可编辑范围由起始行号、起始列号、结束行号、结束列号组成
+ */
+export declare class ContentEditableController {
+    private readonly editPart;
+    private readonly editor;
+    private readonly loadAvaliablePredefineVariablesMapCallback;
+    private readonly CSS_EDITABLE;
+    private readonly CSS_READONLY;
+    private table?;
+    private contentCell?;
+    private editableRanges;
+    private readonlyMode;
+    constructor(editPart: {
+        part: RulePart;
+    }, editor: monaco.editor.IStandaloneCodeEditor, loadAvaliablePredefineVariablesMapCallback: () => Map<string, Datatype>);
+    setTable(table: ScoreCardTable): void;
+    getAvaliablePredefineVariablesMap(): Map<string, Datatype>;
+    disableContentEditor(): void;
+    setReadonlyMode(value: boolean): void;
+    getReadonlyMode(): boolean;
+    setContent(content: string, contentCell?: ContentCell): void;
+    /**
+     * 当点击列头时，显示当前列头中配置的脚本内容
+     * @param script 要显示的脚本内容
+     */
+    showScript(script: string): void;
+    private initEventListeners;
+    private updateDecorations;
+    private createEditableDecorations;
+    private createReadonlyDecorations;
+    private inEditableRange;
+    private adjustEditableRanges;
+    private findTargetEditableRangeIndex;
+    private isPositionEditable;
+    private findNearestEditablePos;
+    private toNewMonacoRange;
+    private rangeContains;
+    private getStartLineNumber;
+    private getEndLineNumber;
+    private getStartColumn;
+    private getEndColumn;
+}

package/dist/sca/PureWebScoreCardEditor.vue.d.ts

@@ -0,0 +1,71 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, Ref, 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;
+    }[]>;
+    readonly?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serializeToXml: () => any;
+    showQuickTestDialog: () => any;
+    setShowFloatingActions: (value: boolean) => void;
+    setReadonlyMode: (value: boolean) => void;
+    getReadonlyMode: () => any;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    ruleEditor: CreateComponentPublicInstanceWithMixins<Readonly<{
+        loadFileCallback: () => Promise<any>;
+        darkMode?: boolean;
+        readonly?: boolean;
+    }> & Readonly<{
+        "onScore-card-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serializeToXml: () => string;
+        setShowFloatingActions: (value: boolean) => void;
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+        showFloatingActions: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+        "score-card-table-editor-mounted": () => any;
+    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        preConditionCodeEditorContainer: HTMLDivElement;
+        postActionCodeEditorContainer: HTMLDivElement;
+        contentCodeEditorContainer: HTMLDivElement;
+        tableEditorContainer: HTMLDivElement;
+    }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        loadFileCallback: () => Promise<any>;
+        darkMode?: boolean;
+        readonly?: boolean;
+    }> & Readonly<{
+        "onScore-card-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serializeToXml: () => string;
+        setShowFloatingActions: (value: boolean) => void;
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+        showFloatingActions: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/sca/ScoreCardComponent.vue.d.ts

@@ -0,0 +1,45 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, Ref, GlobalComponents, GlobalDirectives } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    scoreCardEditorRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        loadFileCallback: () => Promise<any>;
+        darkMode?: boolean;
+        readonly?: boolean;
+    }> & Readonly<{
+        "onScore-card-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serializeToXml: () => string;
+        setShowFloatingActions: (value: boolean) => void;
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+        showFloatingActions: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+        "score-card-table-editor-mounted": () => any;
+    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        preConditionCodeEditorContainer: HTMLDivElement;
+        postActionCodeEditorContainer: HTMLDivElement;
+        contentCodeEditorContainer: HTMLDivElement;
+        tableEditorContainer: HTMLDivElement;
+    }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        loadFileCallback: () => Promise<any>;
+        darkMode?: boolean;
+        readonly?: boolean;
+    }> & Readonly<{
+        "onScore-card-table-editor-mounted"?: (() => any) | undefined;
+    }>, {
+        serializeToXml: () => string;
+        setShowFloatingActions: (value: boolean) => void;
+        setReadonlyMode: (value: boolean) => void;
+        getReadonlyMode: () => boolean;
+        showFloatingActions: Ref<boolean, boolean>;
+        showQuickTestDialog: () => void;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/sca/ScoreCardDeserialize.d.ts

@@ -0,0 +1,5 @@
+import { Datatype } from '../model/Datatype';
+import { default as ScoreCardTableModel, ScoreCardReason, ScoreCardSetting } from './model/ScoreCardTableModel';
+export declare const deserializeScoreCardTable: (xml: string, model: ScoreCardTableModel) => Map<string, Datatype>;
+export declare const parseReasons: (reasonsNode: any) => ScoreCardReason[] | undefined;
+export declare const parseSetting: (settingNode: any) => ScoreCardSetting;

package/dist/sca/ScoreCardEditor.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, Ref, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    loadFileCallback: () => Promise<any>;
+    darkMode?: boolean;
+    readonly?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {
+    serializeToXml: () => string;
+    setShowFloatingActions: (value: boolean) => void;
+    setReadonlyMode: (value: boolean) => void;
+    getReadonlyMode: () => boolean;
+    showFloatingActions: Ref<boolean, boolean>;
+    showQuickTestDialog: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+    "score-card-table-editor-mounted": () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onScore-card-table-editor-mounted"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    preConditionCodeEditorContainer: HTMLDivElement;
+    postActionCodeEditorContainer: HTMLDivElement;
+    contentCodeEditorContainer: HTMLDivElement;
+    tableEditorContainer: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/sca/ScoreCardModelInitializer.d.ts

@@ -0,0 +1,8 @@
+import { Datatype } from '../model/Datatype';
+import { ScoreCardTable } from './component/ScoreCardTable';
+export default class ScoreCardModelInitializer {
+    private table;
+    private avaliablePredefineVariablesMap;
+    constructor(table: ScoreCardTable, avaliablePredefineVariablesMap: Map<string, Datatype>);
+    initialize(): void;
+}

package/dist/sca/ScoreCardSettingDialog.vue.d.ts

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

package/dist/sca/ScoreCardWebEditor.d.ts

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

package/dist/sca/component/ScoreCardTable.d.ts

@@ -0,0 +1,81 @@
+import { Datatype } from '../../model/Datatype';
+import { ContentEditableController } from '../ContentEditableController';
+import { default as ScoreCardAttribute, ContentCell, ScoreCardCondition } from '../model/ScoreCardAttribute';
+import { default as ScoreCardTableModel } from '../model/ScoreCardTableModel';
+import { default as ScoreCardTableCrossHeader } from './ScoreCardTableCrossHeader';
+import { default as ScoreCardTableHeader } from './ScoreCardTableHeader';
+import { default as ScoreCardTableRowIndicate } from './ScoreCardTableRowIndicate';
+export declare const SELECTION_CELL = "selectionCell";
+export declare const SHOW_SETTING_DIALOG = "showSettingDialog";
+export declare class ScoreCardTable {
+    private readonly container;
+    private readonly editorController;
+    readonly loadPredefineConditionScriptCallback: () => string;
+    readonly loadPostActionCodeScriptCallback: () => string;
+    private model;
+    private headerFloatTable;
+    private indicateRowFloatTable;
+    private crossHeaderFloatTable;
+    private cellsMap;
+    private selectionCells;
+    private readonly table;
+    private readonly headerRow;
+    private readonly headerSection;
+    private readonly bodySection;
+    private readonly redoUndoManager;
+    private readonly inputEditor;
+    constructor(container: HTMLElement, editorController: ContentEditableController, loadPredefineConditionScriptCallback: () => string, loadPostActionCodeScriptCallback: () => string);
+    init(): void;
+    private initHeaders;
+    updateAttributeHeaderTitle(): void;
+    applyHeaderVisible(): void;
+    private showContentCell;
+    applyHeaderWidth(): void;
+    applyRowHeight(): void;
+    changeDarkMode(darkMode: boolean): void;
+    initFromModel(avaliablePredefineVariablesMap: Map<string, Datatype>): void;
+    checkWholeCellContentError(): void;
+    copySelectionCells(): void;
+    pasteCopyCellsValue(): void;
+    cleanSelectionCells(): void;
+    getSelectedCells(): HTMLTableCellElement[];
+    insertNewAttribute(reAttribute: ScoreCardAttribute): ScoreCardAttribute;
+    insertNewAttributeRow(attribute: ScoreCardAttribute, rowIndex: number): HTMLTableRowElement;
+    createIndicateRow(newRowIndex: number): HTMLTableRowElement;
+    insertNewCondition(attribute: ScoreCardAttribute, refCondition?: ScoreCardCondition): ScoreCardCondition;
+    removeAttribute(attribute: ScoreCardAttribute): void;
+    removeCondition(condition: ScoreCardCondition): void;
+    addOtherwise(condition: ScoreCardCondition): void;
+    cancelOtherwise(condition: ScoreCardCondition): void;
+    insertContentCell(row: HTMLTableRowElement, cell: ContentCell): HTMLTableCellElement;
+    private buildReasonCodeSelect;
+    private bindingCellEvents;
+    checkCellContentError(contentCell: ContentCell, avaliablePredefineVariablesMap: Map<string, Datatype>): void;
+    private cleanCellError;
+    private setCellError;
+    buildResizeRowCallback(): (rowIndex: number, newHeight: number) => void;
+    getTargetBodyRow(rowIndex: number): HTMLTableRowElement;
+    buildHighlightRowCallback(): (rowIndex: number, add: boolean) => void;
+    buildHeaderResizeCallback(): (rowIndex: number, columnIndex: number, newWidth: number) => void;
+    buildHeaderHighlightCallback(): (cellIndex: number) => void;
+    highlightCells(tableCell: HTMLTableCellElement): void;
+    private resetCellStyle;
+    private doHighlightTargetRowCells;
+    doHighlightTargetColumnCells(columnIndex: number, add: boolean): void;
+    private triggerSelectionCellEvent;
+    doHighlightCell(td: HTMLTableCellElement, add: boolean): void;
+    doCancelHighlight(): void;
+    isRowColumnHighlight(): boolean;
+    getHighlightCells(): HTMLTableCellElement[];
+    getModel(): ScoreCardTableModel;
+    getCellsMap(): Map<HTMLTableCellElement, ContentCell>;
+    getHeaderSection(): HTMLTableSectionElement;
+    getBodySection(): HTMLTableSectionElement;
+    getHeaderFloatTable(): ScoreCardTableHeader;
+    getIndicateRowFloatTable(): ScoreCardTableRowIndicate;
+    getCrossHeaderFloatTable(): ScoreCardTableCrossHeader;
+}
+export declare enum HeaderPosition {
+    before = 0,
+    after = 1
+}

package/dist/sca/component/ScoreCardTableCrossHeader.d.ts

@@ -0,0 +1,11 @@
+export default class ScoreCardTableCrossHeader {
+    readonly table: HTMLTableElement;
+    private readonly headerSection;
+    constructor(container: HTMLElement);
+    changeDarkMode(darkMode: boolean): void;
+    private bindingContainerScrollEvent;
+    initHeaderRowIndicate(): HTMLTableRowElement;
+    initSubHeaderRow(): HTMLTableRowElement;
+    deleteSubHeaderRow(): void;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/sca/component/ScoreCardTableHeader.d.ts

@@ -0,0 +1,27 @@
+import { ScoreCardTable } from './ScoreCardTable';
+export default class ScoreCardTableHeader {
+    private scoreCardTable;
+    readonly table: HTMLTableElement;
+    private readonly headerSection;
+    private readonly headerRow;
+    /**
+     * 记录当前处于选中状态的列单元格对象
+     */
+    private highlightColumnCell;
+    constructor(container: HTMLElement, scoreCardTable: ScoreCardTable);
+    changeDarkMode(darkMode: boolean): void;
+    /**
+     * 修改浮动表头内容，以及将新表头对象与当前单元格进行绑定
+     * @param newDefinition 新的表头对象
+     */
+    changeHeader(): void;
+    private bindingContainerScrollEvent;
+    getHeaderRow(): HTMLTableRowElement;
+    cancelHighlightColumn(): void;
+    getHightlightColumnCell(): HTMLTableCellElement | null;
+    insertHeaderCell(headerName: string, resizeColumnCallback: (rowIndex: number, columnIndex: number, newWidth: number) => void, highlightColumnCallback: (cellIndex: number) => void): HTMLTableCellElement;
+    updateAttributeHeaderTitle(): void;
+    private bindingHighlightColumnEvent;
+    private bindingColumnResizer;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/sca/component/ScoreCardTableRowIndicate.d.ts

@@ -0,0 +1,26 @@
+import { ScoreCardTable } from './ScoreCardTable';
+export default class ScoreCardTableRowIndicate {
+    readonly table: HTMLTableElement;
+    private scoreCardTable;
+    private readonly headerSection;
+    private readonly bodySection;
+    /**
+     * 记录当行处于选中状态的行对象
+     */
+    private highlightIndicateRowCell;
+    constructor(container: HTMLElement, scoreCardTable: ScoreCardTable);
+    changeDarkMode(darkMode: boolean): void;
+    private bindingContainerScrollEvent;
+    initHeaderIndicateRow(): HTMLTableRowElement;
+    initSubHeaderRow(): HTMLTableRowElement;
+    deleteSubHeaderRow(): void;
+    deleteIndicateRow(rowIndex: number, rowCount: number): void;
+    rowResize(rowIndex: number, newHeight: string): void;
+    createBodyIndicateRow(text: string, resizeRowCallback: (rowIndex: number, newHeight: number) => void, highlightRowCallback: (rowIndex: number, add: boolean) => void, newRowIndex?: number): HTMLTableRowElement;
+    cancelHighlight(): void;
+    getHightlightIndicateRowCell(): HTMLTableCellElement | null;
+    private highlightRowEventBinding;
+    private bindingRowResizer;
+    getBodySection(): HTMLTableSectionElement;
+    getHeaderSection(): HTMLTableSectionElement;
+}

package/dist/sca/component/contextMenuBuilder.d.ts

@@ -0,0 +1,3 @@
+import { ScoreCardTable } from './ScoreCardTable';
+export declare const bindHeaderContextMenu: (td: HTMLTableCellElement, table: ScoreCardTable) => void;
+export declare const bindContentCellContextMenu: (td: HTMLTableCellElement, table: ScoreCardTable) => void;

package/dist/sca/component/edit/ScoreCardChangeEdit.d.ts

@@ -0,0 +1,4 @@
+import { ViewEdit } from '../../../view&document';
+export declare class ScoreCardChangeEdit implements ViewEdit {
+    type: string;
+}

package/dist/sca/model/ScoreCardAttribute.d.ts

@@ -0,0 +1,86 @@
+export interface ContentCell {
+    getValue(): string;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+}
+export default class ScoreCardAttribute implements ContentCell {
+    private value;
+    private cell?;
+    private conditions;
+    constructor(value: string);
+    toXml(): string;
+    getValue(): string;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+    getConditions(): ScoreCardCondition[];
+    addCondition(condition: ScoreCardCondition): void;
+}
+export declare const newScoreCardAttribute: () => ScoreCardAttribute;
+export declare class ScoreCardCondition implements ContentCell {
+    private value;
+    private otherwise;
+    private attribute;
+    private cell?;
+    private score?;
+    private expectedScore?;
+    private maxScore?;
+    private weight?;
+    private reasonCode?;
+    constructor(value: string, attribute: ScoreCardAttribute);
+    toXml(): string;
+    getValue(): string;
+    getOtherwise(): boolean;
+    setOtherwise(otherwise: boolean): void;
+    getAttribute(): ScoreCardAttribute;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+    getScore(): ScoreCardScore | undefined;
+    setScore(score: ScoreCardScore): void;
+    getExpectedScore(): ScoreCardScore | undefined;
+    setExpectedScore(expectedScore: ScoreCardScore): void;
+    getMaxScore(): ScoreCardScore | undefined;
+    setMaxScore(maxScore: ScoreCardScore): void;
+    getWeight(): ScoreCardWeight | undefined;
+    setWeight(weight: ScoreCardWeight): void;
+    getReasonCode(): ScoreCardReasonCode | undefined;
+    setReasonCode(reasonCode: ScoreCardReasonCode): void;
+}
+export declare class ScoreCardScore implements ContentCell {
+    private scoreType;
+    private value;
+    private condition;
+    private cell?;
+    constructor(value: string, condition: ScoreCardCondition, scoreType?: ScoreType);
+    getCondition(): ScoreCardCondition;
+    getValue(): string;
+    getScoreType(): ScoreType;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+}
+export type ScoreType = "Score" | "ExpectedScore" | "MaxScore";
+export declare class ScoreCardWeight implements ContentCell {
+    private value;
+    private condition;
+    private cell?;
+    constructor(value: string, condition: ScoreCardCondition);
+    getCondition(): ScoreCardCondition;
+    getValue(): string;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+}
+export declare class ScoreCardReasonCode implements ContentCell {
+    private value;
+    private condition;
+    private cell?;
+    constructor(value: string, condition: ScoreCardCondition);
+    getCondition(): ScoreCardCondition;
+    getValue(): string;
+    setValue(value: string): void;
+    getCell(): HTMLTableCellElement | undefined;
+    setCell(cell: HTMLTableCellElement): void;
+}

package/dist/sca/model/ScoreCardTableModel.d.ts

@@ -0,0 +1,67 @@
+import { default as ScoreCardAttribute } from './ScoreCardAttribute';
+export default class ScoreCardTableModel {
+    private uuid?;
+    private document?;
+    private preconditions?;
+    private postActions?;
+    private attributeHeader?;
+    private attributes;
+    private quickTestData?;
+    private effectiveDate?;
+    private expirationDate?;
+    private priority?;
+    private status?;
+    private reasons;
+    private setting;
+    private headerWidthMap;
+    private rowHeightMap;
+    private headerVisibleMap;
+    toXml(): string;
+    getUuid(): string | undefined;
+    setUuid(uuid: string): void;
+    getHeaderWidthMap(): Map<number, number>;
+    getRowHeightMap(): Map<number, number>;
+    getHeaderVisibleMap(): Map<number, boolean>;
+    setAttributeHeader(attributeHeader: string): void;
+    getDocument(): string | undefined;
+    setDocument(document: string): void;
+    getPreconditions(): string | undefined;
+    setPreconditions(preconditions: string): void;
+    setPostActions(postActions: string): void;
+    getPostActions(): string | undefined;
+    getAttributeHeader(): string | undefined;
+    getAttributes(): ScoreCardAttribute[];
+    addAttribute(attribute: ScoreCardAttribute): void;
+    setQuickTestData(quickTestData: string): void;
+    setEffectiveDate(effectiveDate: string): void;
+    setExpirationDate(expirationDate: string): void;
+    setPriority(priority: number): void;
+    setStatus(status: string): void;
+    getQuickTestData(): string | undefined;
+    getEffectiveDate(): string | undefined;
+    getExpirationDate(): string | undefined;
+    getPriority(): number | undefined;
+    getStatus(): string | undefined;
+    getReasons(): ScoreCardReason[];
+    addReason(reason: ScoreCardReason): void;
+    getSetting(): ScoreCardSetting;
+    setSetting(setting: ScoreCardSetting): void;
+}
+export declare class ScoreCardReason {
+    reasonCode: string;
+    description: string;
+    priority: number;
+    constructor(reasonCode: string, description: string, priority: number);
+    toXml(): string;
+    toScript(): string;
+}
+export declare class ScoreCardSetting {
+    scoringStrategyType: string;
+    maxReasonCodeReturnCount: number;
+    reasonCodeReturnOrderedType: string;
+    reasonCodeReturnDeviationOrderedType: string;
+    reasonCodeReturnDuplicateStrategyType: string;
+    reasonCodeReturnFilterType: string;
+    toXml(): string;
+    toScript(): string;
+}

package/dist/sca/webview/ScoreCardDocument.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, ExtensionContext, Event } from 'vscode';
+import { CancellationToken, CustomDocument, CustomDocumentBackup, ExtensionContext, Uri, Event } from 'vscode';
 import { DocumentDelegate, ViewEdit } from '../../view&document';
 export declare class ScoreCardDocument implements CustomDocument {
     private readonly _context;

package/dist/sca/webview/ScoreCardEditorProvider.d.ts

@@ -1,7 +1,7 @@
 import { CancellationToken, CustomDocumentBackup, CustomDocumentBackupContext, CustomDocumentEditEvent, CustomDocumentOpenContext, CustomEditorProvider, Disposable, ExtensionContext, Uri, WebviewPanel, Event } from 'vscode';
 import { WebviewCollection } from '../../WebviewCollection';
 import { ScoreCardDocument } from './ScoreCardDocument';
-export declare const NEW_SCORE_CARD_FILE_COMMAND_NAME = "udmp.createScoreCardFile";
+export declare const NEW_SCORE_CARD_FILE_COMMAND_NAME = "udmp.createNewScoreCardFile";
 export declare class ScoreCardEditorProvider implements CustomEditorProvider<ScoreCardDocument> {
     readonly context: ExtensionContext;
     private readonly _onDidChangeCustomDocument;

package/dist/sync/SyncFileUitls.d.ts

@@ -12,3 +12,4 @@ export declare const getServerSyncEntries: (authToken: any, projectUuid: any) =>
 export declare const pullEntries: (authToken: any, projectUuid: any, entries: Array<any>, callback: any) => Promise<void>;
 export declare const buildNewConfigFileContent: () => string;
 export declare const pushEntries: (authToken: any, projectUuid: any, entries: Array<any>, callback: any) => Promise<void>;
+export declare const syncCompiledEntries: (authToken: any, projectUuid: any, entries: Array<any>, callback: any) => Promise<void>;

package/dist/tst/PredictFormDialog.vue.d.ts

@@ -2,5 +2,5 @@ import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOp
 type __VLS_Props = {
     darkMode: boolean;
 };
-declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 export default _default;