@bagelink/vue 0.0.1078 → 0.0.1082

package/dist/components/Accordion.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Accordion.vue.d.ts","sourceRoot":"","sources":["../../src/components/Accordion.vue"],"names":[],"mappings":"AAgCA,iBAAS,cAAc;WAkCT,OAAO,IAA6B;;yBARrB,GAAG;;;;EAa/B;AAOD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,0RAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAKpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"Accordion.vue.d.ts","sourceRoot":"","sources":["../../src/components/Accordion.vue"],"names":[],"mappings":"AA2BA,iBAAS,cAAc;WAsBT,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAOD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,0RAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/AccordionItem.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccordionItem.vue.d.ts","sourceRoot":"","sources":["../../src/components/AccordionItem.vue"],"names":[],"mappings":"AAmLA,KAAK,WAAW,GAAG;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,aAAa,GAAG,YAAY,CAAA;IACvC,YAAY,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAC;AA0DF,iBAAS,cAAc;WA4FT,OAAO,IAA6B;;sBATxB,GAAG;yBACC,GAAG;;;;EAahC;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;6FAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAWpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"AccordionItem.vue.d.ts","sourceRoot":"","sources":["../../src/components/AccordionItem.vue"],"names":[],"mappings":"AAiLA,KAAK,WAAW,GAAG;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,aAAa,GAAG,YAAY,CAAA;IACvC,YAAY,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAC;AAsDF,iBAAS,cAAc;WAgGT,OAAO,IAA6B;;sBAXxB,GAAG;yBACC,GAAG;;;;EAehC;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;6FAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/AddressSearch.vue.d.ts

@@ -2,6 +2,614 @@ declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import
     addressSelected: (...args: any[]) => void;
 }, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
     onAddressSelected?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    suggestion: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly shown?: boolean | undefined;
+            readonly value?: string | undefined;
+            readonly thin?: boolean | undefined;
+            readonly flat?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly icon?: import('..').MaterialIcons | undefined;
+            readonly triggerClass?: string | undefined;
+            readonly iconEnd?: import('..').MaterialIcons | undefined;
+            readonly border?: boolean | undefined;
+            readonly outline?: boolean | undefined;
+            readonly round?: boolean | undefined;
+            readonly placement?: import('./Dropdown.vue').AlignedPlacement | undefined;
+            readonly noAutoFocus?: boolean | undefined;
+            readonly positioningDisabled?: boolean | undefined;
+            readonly onHide?: ((...args: any[]) => any) | undefined;
+            readonly "onUpdate:shown"?: ((value: boolean) => any) | undefined;
+            readonly onShow?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            ddownRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                theme: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                referenceNode: {
+                    type: import('vue').PropType<() => Element>;
+                    default: any;
+                };
+                shown: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showGroup: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                ariaId: {
+                    default: any;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                positioningDisabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                placement: {
+                    type: import('vue').PropType<import('floating-vue').Placement>;
+                    default: any;
+                };
+                delay: {
+                    type: import('vue').PropType<string | number | {
+                        show: number;
+                        hide: number;
+                    }>;
+                    default: any;
+                };
+                distance: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                skidding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                triggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[]>;
+                    default: any;
+                };
+                showTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                hideTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                popperTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[]>;
+                    default: any;
+                };
+                popperShowTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                popperHideTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                container: {
+                    type: any[];
+                    default: any;
+                };
+                boundary: {
+                    type: any[];
+                    default: any;
+                };
+                strategy: {
+                    type: import('vue').PropType<"absolute" | "fixed">;
+                    default: any;
+                };
+                autoHide: {
+                    type: import('vue').PropType<boolean | ((event: Event) => boolean)>;
+                    default: any;
+                };
+                handleResize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                instantMove: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                eagerMount: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                popperClass: {
+                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+                    default: any;
+                };
+                computeTransformOrigin: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoMinSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoSize: {
+                    type: import('vue').PropType<boolean | "min" | "max">;
+                    default: any;
+                };
+                autoMaxSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoBoundaryMaxSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                preventOverflow: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                overflowPadding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                arrowPadding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                arrowOverflow: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                flip: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                shift: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                shiftCrossAxis: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                noAutoFocus: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                disposeTimeout: {
+                    type: NumberConstructor;
+                    default: any;
+                };
+            }>> & {
+                onResize?: () => any;
+                onShow?: () => any;
+                onHide?: () => any;
+                "onUpdate:shown"?: (shown: boolean) => any;
+                "onApply-show"?: () => any;
+                "onApply-hide"?: () => any;
+                "onClose-group"?: () => any;
+                "onClose-directive"?: () => any;
+                "onAuto-hide"?: () => any;
+            }, unknown, unknown, {
+                finalTheme(): string;
+            }, {
+                getTargetNodes(): unknown[];
+            }, {
+                computed: {
+                    themeClass(): string[];
+                };
+            } | {
+                methods: {
+                    show(...args: any[]): any;
+                    hide(...args: any[]): any;
+                    dispose(...args: any[]): any;
+                    onResize(...args: any[]): any;
+                };
+            }, import('vue').ComponentOptionsMixin, {
+                show: () => true;
+                hide: () => true;
+                'update:shown': (shown: boolean) => true;
+                'apply-show': () => true;
+                'apply-hide': () => true;
+                'close-group': () => true;
+                'close-directive': () => true;
+                'auto-hide': () => true;
+                resize: () => true;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                placement: import('floating-vue').Placement;
+                strategy: "absolute" | "fixed";
+                disabled: boolean;
+                positioningDisabled: boolean;
+                delay: string | number | {
+                    show: number;
+                    hide: number;
+                };
+                distance: string | number;
+                skidding: string | number;
+                triggers: import('floating-vue').TriggerEvent[];
+                showTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                hideTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                popperTriggers: import('floating-vue').TriggerEvent[];
+                popperShowTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                popperHideTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                container: any;
+                boundary: any;
+                autoHide: boolean | ((event: Event) => boolean);
+                handleResize: boolean;
+                instantMove: boolean;
+                eagerMount: boolean;
+                popperClass: string | unknown[] | Record<string, any>;
+                computeTransformOrigin: boolean;
+                autoMinSize: boolean;
+                autoSize: boolean | "min" | "max";
+                autoMaxSize: boolean;
+                autoBoundaryMaxSize: boolean;
+                preventOverflow: boolean;
+                overflowPadding: string | number;
+                arrowPadding: string | number;
+                arrowOverflow: boolean;
+                flip: boolean;
+                shift: boolean;
+                shiftCrossAxis: boolean;
+                noAutoFocus: boolean;
+                disposeTimeout: number;
+                shown: boolean;
+                theme: string;
+                referenceNode: () => Element;
+                showGroup: string;
+                ariaId: any;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {
+                    themeClass(): string[];
+                };
+                M: import('vue').MethodOptions;
+                Defaults: {};
+            } & {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            } & {
+                P: {};
+                B: {};
+                D: {};
+                C: import('vue').ComputedOptions;
+                M: {
+                    show(...args: any[]): any;
+                    hide(...args: any[]): any;
+                    dispose(...args: any[]): any;
+                    onResize(...args: any[]): any;
+                };
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                theme: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                referenceNode: {
+                    type: import('vue').PropType<() => Element>;
+                    default: any;
+                };
+                shown: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showGroup: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                ariaId: {
+                    default: any;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                positioningDisabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                placement: {
+                    type: import('vue').PropType<import('floating-vue').Placement>;
+                    default: any;
+                };
+                delay: {
+                    type: import('vue').PropType<string | number | {
+                        show: number;
+                        hide: number;
+                    }>;
+                    default: any;
+                };
+                distance: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                skidding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                triggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[]>;
+                    default: any;
+                };
+                showTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                hideTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                popperTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[]>;
+                    default: any;
+                };
+                popperShowTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                popperHideTriggers: {
+                    type: import('vue').PropType<import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[])>;
+                    default: any;
+                };
+                container: {
+                    type: any[];
+                    default: any;
+                };
+                boundary: {
+                    type: any[];
+                    default: any;
+                };
+                strategy: {
+                    type: import('vue').PropType<"absolute" | "fixed">;
+                    default: any;
+                };
+                autoHide: {
+                    type: import('vue').PropType<boolean | ((event: Event) => boolean)>;
+                    default: any;
+                };
+                handleResize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                instantMove: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                eagerMount: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                popperClass: {
+                    type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+                    default: any;
+                };
+                computeTransformOrigin: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoMinSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoSize: {
+                    type: import('vue').PropType<boolean | "min" | "max">;
+                    default: any;
+                };
+                autoMaxSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                autoBoundaryMaxSize: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                preventOverflow: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                overflowPadding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                arrowPadding: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: any;
+                };
+                arrowOverflow: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                flip: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                shift: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                shiftCrossAxis: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                noAutoFocus: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                disposeTimeout: {
+                    type: NumberConstructor;
+                    default: any;
+                };
+            }>> & {
+                onResize?: () => any;
+                onShow?: () => any;
+                onHide?: () => any;
+                "onUpdate:shown"?: (shown: boolean) => any;
+                "onApply-show"?: () => any;
+                "onApply-hide"?: () => any;
+                "onClose-group"?: () => any;
+                "onClose-directive"?: () => any;
+                "onAuto-hide"?: () => any;
+            }, {}, {}, {
+                themeClass(): string[];
+            } & import('vue').ComputedOptions & {
+                finalTheme(): string;
+            }, import('vue').MethodOptions & {
+                show(...args: any[]): any;
+                hide(...args: any[]): any;
+                dispose(...args: any[]): any;
+                onResize(...args: any[]): any;
+            } & {
+                getTargetNodes(): unknown[];
+            }, {
+                placement: import('floating-vue').Placement;
+                strategy: "absolute" | "fixed";
+                disabled: boolean;
+                positioningDisabled: boolean;
+                delay: string | number | {
+                    show: number;
+                    hide: number;
+                };
+                distance: string | number;
+                skidding: string | number;
+                triggers: import('floating-vue').TriggerEvent[];
+                showTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                hideTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                popperTriggers: import('floating-vue').TriggerEvent[];
+                popperShowTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                popperHideTriggers: import('floating-vue').TriggerEvent[] | ((triggers: import('floating-vue').TriggerEvent[]) => import('floating-vue').TriggerEvent[]);
+                container: any;
+                boundary: any;
+                autoHide: boolean | ((event: Event) => boolean);
+                handleResize: boolean;
+                instantMove: boolean;
+                eagerMount: boolean;
+                popperClass: string | unknown[] | Record<string, any>;
+                computeTransformOrigin: boolean;
+                autoMinSize: boolean;
+                autoSize: boolean | "min" | "max";
+                autoMaxSize: boolean;
+                autoBoundaryMaxSize: boolean;
+                preventOverflow: boolean;
+                overflowPadding: string | number;
+                arrowPadding: string | number;
+                arrowOverflow: boolean;
+                flip: boolean;
+                shift: boolean;
+                shiftCrossAxis: boolean;
+                noAutoFocus: boolean;
+                disposeTimeout: number;
+                shown: boolean;
+                theme: string;
+                referenceNode: () => Element;
+                showGroup: string;
+                ariaId: any;
+            }> | null;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "hide", ...args: any[]) => void) & ((event: "update:shown", value: boolean) => void) & ((event: "show", ...args: any[]) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            shown?: boolean;
+        } & {
+            value?: string;
+            thin?: boolean;
+            flat?: boolean;
+            disabled?: boolean;
+            icon?: import('..').MaterialIcons;
+            triggerClass?: string;
+            iconEnd?: import('..').MaterialIcons;
+            border?: boolean;
+            outline?: boolean;
+            round?: boolean;
+            placement?: import('./Dropdown.vue').AlignedPlacement;
+            noAutoFocus?: boolean;
+            positioningDisabled?: boolean;
+        }> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            "onUpdate:shown"?: ((value: boolean) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+        }>, {
+            show: () => any;
+            hide: () => any;
+            shown: import('vue').ModelRef<boolean, string, boolean, boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            "update:shown": (value: boolean) => void;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        shown?: boolean;
+    } & {
+        value?: string;
+        thin?: boolean;
+        flat?: boolean;
+        disabled?: boolean;
+        icon?: import('..').MaterialIcons;
+        triggerClass?: string;
+        iconEnd?: import('..').MaterialIcons;
+        border?: boolean;
+        outline?: boolean;
+        round?: boolean;
+        placement?: import('./Dropdown.vue').AlignedPlacement;
+        noAutoFocus?: boolean;
+        positioningDisabled?: boolean;
+    }> & Readonly<{
+        onHide?: ((...args: any[]) => any) | undefined;
+        "onUpdate:shown"?: ((value: boolean) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+    }>, "hide" | "shown" | "show"> & import('vue').ShallowUnwrapRef<{
+        show: () => any;
+        hide: () => any;
+        shown: import('vue').ModelRef<boolean, string, boolean, boolean>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            trigger?(_: {}): any;
+            default?(_: {
+                hide: any;
+                show: any;
+            }): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
 export default _default;
 //# sourceMappingURL=AddressSearch.vue.d.ts.map

package/dist/components/AddressSearch.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AddressSearch.vue.d.ts","sourceRoot":"","sources":["../../src/components/AddressSearch.vue"],"names":[],"mappings":";;;;;AA0MA,wBAOG"}
+{"version":3,"file":"AddressSearch.vue.d.ts","sourceRoot":"","sources":["../../src/components/AddressSearch.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAyKQ,KAAI;;;;;;;;;;;;;;;;;;;;;;;iCAegB,KAAK,kBAC3B,cAAe;;;;iCAC6B,KAAK;;;;;;;;;;;;;;;iCAe5C,KAAK,kBAAkB,cACJ;;;;iCAAyF,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAA0F,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAA4F,KAAK,kBAAkB,cAAgC;;;;iCAA+F,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAAgG,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;;;;;;;;;iCAA2N,KAAK;;;;iCAAoG,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAspB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBApDvtE,GAAG;yBACL,GAAG;4BACnB,GAAG;6BAAoC,GAAG;;;;;;;;;;;;;kCAkDkgH,cAAe;;;;;;;;;;iCAA+Q,cAAgC;qCAA2C,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;qCAA4C,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;uCAA8C,cAAgC;2CAAiD,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;2CAAkD,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAjCpvJ,KAAI;;;;;;;;;;;;;;;;;;;;;;;iCAegB,KAAK,kBAC3B,cAAe;;;;iCAC6B,KAAK;;;;;;;;;;;;;;;iCAe5C,KAAK,kBAAkB,cACJ;;;;iCAAyF,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAA0F,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAA4F,KAAK,kBAAkB,cAAgC;;;;iCAA+F,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;iCAAgG,KAAK,kBAAkB,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;;;;;;;;;iCAA2N,KAAK;;;;iCAAoG,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAspB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAm0C,cAAe;;;;;;;;;;iCAA+Q,cAAgC;qCAA2C,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;qCAA4C,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;uCAA8C,cAAgC;2CAAiD,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;2CAAkD,cAAgC,sCAAsC,cAAgC,4BAA4B,cAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAA6tb,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAV/klB,wBAQG"}

package/dist/components/Alert.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Alert.vue.d.ts","sourceRoot":"","sources":["../../src/components/Alert.vue"],"names":[],"mappings":"AA4EA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAMlD,UAAU,KAAK;IACd,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;IACnC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAA;CAC7B;;UAFO,MAAM,GAAG,SAAS,GAAG,OAAO;;AAkIpC,wBAOG"}
+{"version":3,"file":"Alert.vue.d.ts","sourceRoot":"","sources":["../../src/components/Alert.vue"],"names":[],"mappings":"AA4EA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAIlD,UAAU,KAAK;IACd,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;IACnC,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,CAAA;CAC7B;;UAFO,MAAM,GAAG,SAAS,GAAG,OAAO;;AA4HpC,wBAOG"}

package/dist/components/Avatar.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Avatar.vue.d.ts","sourceRoot":"","sources":["../../src/components/Avatar.vue"],"names":[],"mappings":"AAkDA,KAAK,WAAW,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAC;;UADM,MAAM;;AAwEd,wBAQG"}
+{"version":3,"file":"Avatar.vue.d.ts","sourceRoot":"","sources":["../../src/components/Avatar.vue"],"names":[],"mappings":"AAgDA,KAAK,WAAW,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAC;;UADM,MAAM;;AA6Dd,wBAQG"}

package/dist/components/Badge.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Badge.vue.d.ts","sourceRoot":"","sources":["../../src/components/Badge.vue"],"names":[],"mappings":"AAmFA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAKlD,UAAU,KAAK;IACd,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,OAAO,CAAC,EAAE,aAAa,CAAA;CACvB;;AA8ED,wBAOG"}
+{"version":3,"file":"Badge.vue.d.ts","sourceRoot":"","sources":["../../src/components/Badge.vue"],"names":[],"mappings":"AAmFA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAGlD,UAAU,KAAK;IACd,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,OAAO,CAAC,EAAE,aAAa,CAAA;CACvB;;AA0ED,wBAOG"}

package/dist/components/BglComponent.vue.d.ts

@@ -2,12 +2,12 @@ import { Field } from '..';
 declare const _default: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & Partial<{}> & {
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & {
         field: Field<T>;
         id?: string;
         modelValue?: any;
         parentPath?: string;
-    }> & import('vue').PublicProps;
+    } & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {