@trilogy-data/trilogy-studio-components 0.1.0

package/dist/components/sidebar/ModelSidebar.vue.d.ts

@@ -0,0 +1,558 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    activeModelKey: StringConstructor;
+    testTag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    creatorVisible: import('vue').Ref<boolean, boolean>;
+    flatList: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        indent: number;
+        count: number;
+        type: string;
+        concept: any;
+    }[]>;
+    collapsed: import('vue').Ref<Record<string, boolean>, Record<string, boolean>>;
+    saveModels: Function;
+    fetchParseResults: (model: string) => Promise<void>;
+    trilogyIcon: string;
+    navigationStore: import('../../stores/useScreenNavigation').NavigationStore;
+    handleClick: (id: string) => void;
+    handleToggle: (id: string) => void;
+    modelStore: import('pinia').Store<"models", {
+        models: Record<string, import('../../models').ModelConfig>;
+    }, {
+        modelList: (state: {
+            models: Record<string, import('../../models').ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, import('../../models').ModelConfig>;
+        }>) => import('../../models').ModelConfig[];
+        unsavedModels: (state: {
+            models: Record<string, import('../../models').ModelConfig>;
+        } & import('pinia').PiniaCustomStateProperties<{
+            models: Record<string, import('../../models').ModelConfig>;
+        }>) => number;
+    }, {
+        newModelConfig(name: string, force?: boolean): import('../../models').ModelConfig;
+        addModelConfig(model: import('../../models').ModelConfig): void;
+        removeModelConfig(name: string): void;
+        updateModelName(name: string, newName: string): void;
+        addEditorAsModelSource(model: string, editor: import('../../editors').Editor): void;
+        addModelConfigSource(name: string, contents: import('../../models').ModelSource): void;
+        removeModelConfigSource(name: string, contents: string): void;
+        setModelConfigParseResults(name: string, results: import('../../models').ModelParseResults): void;
+        setModelParseError(name: string, error: string): void;
+    }>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    activeModelKey: StringConstructor;
+    testTag: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    testTag: string;
+}, {}, {
+    SidebarList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {
+        title: string;
+        isMobile: boolean | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    SidebarItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        itemId: {
+            type: StringConstructor;
+            required: true;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isCollapsible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isCollapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        icon: {
+            type: StringConstructor;
+            default: string;
+        };
+        extraInfo: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: string;
+        };
+        itemType: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {}, {}, {}, {
+        handleClick(): void;
+        handleToggle(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "click")[], "toggle" | "click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        itemId: {
+            type: StringConstructor;
+            required: true;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        indent: {
+            type: NumberConstructor;
+            default: number;
+        };
+        isSelected: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isCollapsible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isCollapsed: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        icon: {
+            type: StringConstructor;
+            default: string;
+        };
+        extraInfo: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: string;
+        };
+        itemType: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onToggle?: ((...args: any[]) => any) | undefined;
+    }>, {
+        icon: string;
+        indent: number;
+        isSelected: boolean;
+        isCollapsible: boolean;
+        isCollapsed: boolean;
+        extraInfo: string | number;
+        itemType: string;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ModelCreator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        formDefaults: {
+            type: ObjectConstructor;
+            required: false;
+            default: () => {};
+        };
+        visible: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        testTag: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+    }>, {
+        modelDetails: import('vue').Ref<{
+            name: any;
+            importAddress: any;
+            connection: any;
+            options: {
+                mdToken: string;
+                projectId: string;
+                username: string;
+                password: string;
+                account: string;
+                sshPrivateKey: string;
+            };
+        }, {
+            name: any;
+            importAddress: any;
+            connection: any;
+            options: {
+                mdToken: string;
+                projectId: string;
+                username: string;
+                password: string;
+                account: string;
+                sshPrivateKey: string;
+            };
+        } | {
+            name: any;
+            importAddress: any;
+            connection: any;
+            options: {
+                mdToken: string;
+                projectId: string;
+                username: string;
+                password: string;
+                account: string;
+                sshPrivateKey: string;
+            };
+        }>;
+        connections: Record<string, import('../../connections').Connection>;
+        createModel: () => void;
+        performSubmit: () => Promise<void>;
+        validateForm: () => void;
+        isFormValid: import('vue').Ref<boolean, boolean>;
+        text: string;
+        isPopupControl: boolean;
+    }, {}, {}, {
+        close(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        formDefaults: {
+            type: ObjectConstructor;
+            required: false;
+            default: () => {};
+        };
+        visible: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        testTag: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        testTag: string;
+        formDefaults: Record<string, any>;
+    }, {}, {
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            errorMessage: import('vue').Ref<string | null, string | null>;
+            isLoading: import('vue').Ref<boolean, boolean>;
+            status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+            handleClick: () => Promise<void>;
+            handleKeydown: (event: KeyboardEvent) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            action: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            useDefaultStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyCombination: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: null;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            testId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            useDefaultStyle: boolean;
+            keyCombination: string[];
+            testId: string;
+        }, {}, {
+            Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {}, {
+                visible: boolean;
+                hoverTimeout: ReturnType<typeof setTimeout> | null;
+            }, {
+                positionClass(): string;
+            }, {
+                showTooltip(): void;
+                hideTooltip(): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                content: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                position: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                inline: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                position: string;
+                inline: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LoadingButton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        errorMessage: import('vue').Ref<string | null, string | null>;
+        isLoading: import('vue').Ref<boolean, boolean>;
+        status: import('vue').Ref<"success" | "error" | null, "success" | "error" | null>;
+        handleClick: () => Promise<void>;
+        handleKeydown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        action: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        useDefaultStyle: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keyCombination: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: null;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        testId: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        useDefaultStyle: boolean;
+        keyCombination: string[];
+        testId: string;
+    }, {}, {
+        Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            visible: boolean;
+            hoverTimeout: ReturnType<typeof setTimeout> | null;
+        }, {
+            positionClass(): string;
+        }, {
+            showTooltip(): void;
+            hideTooltip(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            content: {
+                type: StringConstructor;
+                required: true;
+            };
+            position: {
+                type: StringConstructor;
+                default: string;
+            };
+            inline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            position: string;
+            inline: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        visible: boolean;
+        hoverTimeout: ReturnType<typeof setTimeout> | null;
+    }, {
+        positionClass(): string;
+    }, {
+        showTooltip(): void;
+        hideTooltip(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        content: {
+            type: StringConstructor;
+            required: true;
+        };
+        position: {
+            type: StringConstructor;
+            default: string;
+        };
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        position: string;
+        inline: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ModelSidebar.vue.d.ts.map

package/dist/components/sidebar/ModelSidebar.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSidebar.vue.d.ts","sourceRoot":"","sources":["../../../components/sidebar/ModelSidebar.vue"],"names":[],"mappings":"AA+DA;;;;;;;;;;YA+ZY,MAAM;cACJ,MAAM;gBACJ,MAAM;eACP,MAAM;cACP,MAAM;iBACH,GAAG;;;;+BAkFkB,MAAM;;;sBAkBf,MAAM;uBAOL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/KpC,wBAyMC"}

package/dist/components/sidebar/SidebarList.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    title: string;
+    isMobile: boolean | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=SidebarList.vue.d.ts.map

package/dist/components/sidebar/SidebarList.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SidebarList.vue.d.ts","sourceRoot":"","sources":["../../../components/sidebar/SidebarList.vue"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;AA+DA,wBAgBC"}