@dialpad/dialtone-vue 3.219.0 → 3.220.0-next.2

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

@@ -0,0 +1,226 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "change" | "update:modelValue" | "before-change", ...args: any[]) => void;
+    disabled: boolean;
+    modelValue: string;
+    id: string;
+    size: string | number;
+    labelClass: string | unknown[] | Record<string, any>;
+    borderless: boolean;
+    spread: string;
+    orientation: string;
+    activationMode: string;
+    showIndicatorTransition: boolean;
+    showDivider: boolean;
+    ariaLabel?: string | undefined;
+    $props: {
+        readonly disabled?: boolean | undefined;
+        readonly modelValue?: string | undefined;
+        readonly id?: string | undefined;
+        readonly size?: string | number | undefined;
+        readonly labelClass?: string | unknown[] | Record<string, any> | undefined;
+        readonly borderless?: boolean | undefined;
+        readonly spread?: string | undefined;
+        readonly orientation?: string | undefined;
+        readonly activationMode?: string | undefined;
+        readonly showIndicatorTransition?: boolean | undefined;
+        readonly showDivider?: boolean | undefined;
+        readonly ariaLabel?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    container: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        direction: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (direction: unknown) => boolean;
+        };
+        as: {
+            type: StringConstructor;
+            default: string;
+        };
+        gap: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (gap: unknown) => boolean;
+        };
+        align: {
+            type: (ObjectConstructor | StringConstructor)[];
+            validator: (align: unknown) => boolean;
+        };
+        justify: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (justify: unknown) => boolean;
+        };
+    }>> & Readonly<{}>, {}, {
+        DT_STACK_DIRECTION: {
+            [x: string]: string;
+        };
+        DT_STACK_GAP: string[];
+        DT_STACK_RESPONSIVE_BREAKPOINTS: string[];
+        DT_STACK_ALIGN: string[];
+        DT_STACK_JUSTIFY: string[];
+    }, {
+        defaultGap(): string | null;
+        defaultDirection(): string | null;
+        defaultAlign(): string | null;
+        defaultJustify(): string | null;
+        stackResponsive(): any[];
+    }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        direction: string | Record<string, any>;
+        as: string;
+        gap: string | Record<string, any>;
+        justify: string | Record<string, any>;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        direction: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (direction: unknown) => boolean;
+        };
+        as: {
+            type: StringConstructor;
+            default: string;
+        };
+        gap: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (gap: unknown) => boolean;
+        };
+        align: {
+            type: (ObjectConstructor | StringConstructor)[];
+            validator: (align: unknown) => boolean;
+        };
+        justify: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: string;
+            validator: (justify: unknown) => boolean;
+        };
+    }>> & Readonly<{}>, {}, {
+        DT_STACK_DIRECTION: {
+            [x: string]: string;
+        };
+        DT_STACK_GAP: string[];
+        DT_STACK_RESPONSIVE_BREAKPOINTS: string[];
+        DT_STACK_ALIGN: string[];
+        DT_STACK_JUSTIFY: string[];
+    }, {
+        defaultGap(): string | null;
+        defaultDirection(): string | null;
+        defaultAlign(): string | null;
+        defaultJustify(): string | null;
+        stackResponsive(): any[];
+    }, {}, {
+        direction: string | Record<string, any>;
+        as: string;
+        gap: string | Record<string, any>;
+        justify: string | Record<string, any>;
+    }> | null;
+}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        container: CreateComponentPublicInstanceWithMixins<ToResolvedProps<ExtractPropTypes<{
+            direction: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (direction: unknown) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                default: string;
+            };
+            gap: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (gap: unknown) => boolean;
+            };
+            align: {
+                type: (ObjectConstructor | StringConstructor)[];
+                validator: (align: unknown) => boolean;
+            };
+            justify: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (justify: unknown) => boolean;
+            };
+        }>, {}>, {}, {
+            DT_STACK_DIRECTION: {
+                [x: string]: string;
+            };
+            DT_STACK_GAP: string[];
+            DT_STACK_RESPONSIVE_BREAKPOINTS: string[];
+            DT_STACK_ALIGN: string[];
+            DT_STACK_JUSTIFY: string[];
+        }, {
+            defaultGap(): string | null;
+            defaultDirection(): string | null;
+            defaultAlign(): string | null;
+            defaultJustify(): string | null;
+            stackResponsive(): any[];
+        }, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+            direction: string | Record<string, any>;
+            as: string;
+            gap: string | Record<string, any>;
+            justify: string | Record<string, any>;
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, OptionTypesType<{}, {}, {}, {}, {}, {}>, Readonly<ExtractPropTypes<{
+            direction: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (direction: unknown) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                default: string;
+            };
+            gap: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (gap: unknown) => boolean;
+            };
+            align: {
+                type: (ObjectConstructor | StringConstructor)[];
+                validator: (align: unknown) => boolean;
+            };
+            justify: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: string;
+                validator: (justify: unknown) => boolean;
+            };
+        }>> & Readonly<{}>, {}, {
+            DT_STACK_DIRECTION: {
+                [x: string]: string;
+            };
+            DT_STACK_GAP: string[];
+            DT_STACK_RESPONSIVE_BREAKPOINTS: string[];
+            DT_STACK_ALIGN: string[];
+            DT_STACK_JUSTIFY: string[];
+        }, {
+            defaultGap(): string | null;
+            defaultDirection(): string | null;
+            defaultAlign(): string | null;
+            defaultJustify(): string | null;
+            stackResponsive(): any[];
+        }, {}, {
+            direction: string | Record<string, any>;
+            as: string;
+            gap: string | Record<string, any>;
+            justify: string | Record<string, any>;
+        }> | null;
+    };
+    rootEl: any;
+};
+//# sourceMappingURL=segmented_control.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segmented_control.vue.d.ts","sourceRoot":"","sources":["../../../components/segmented_control/segmented_control.vue"],"names":[],"mappings":"AAiBA;wBA2wBqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUG"}

package/dist/components/segmented_control/segmented_control_constants.d.ts

@@ -0,0 +1,41 @@
+export const SEGMENTED_CONTROL_SIZES: string[];
+export const SEGMENTED_CONTROL_SIZE_DEFAULT: 200;
+export const SEGMENTED_CONTROL_SIZE_MODIFIERS: {
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export const SEGMENTED_CONTROL_ORIENTATIONS: string[];
+export const SEGMENTED_CONTROL_ORIENTATION_DEFAULT: "horizontal";
+export const SEGMENTED_CONTROL_ACTIVATION_MODES: string[];
+export const SEGMENTED_CONTROL_ACTIVATION_MODE_DEFAULT: "auto";
+export const SEGMENTED_CONTROL_SPREADS: string[];
+export const SEGMENTED_CONTROL_SPREAD_DEFAULT: "grow";
+export const SEGMENTED_CONTROL_ITEM_SELECTOR: "[role=\"radio\"]";
+export const SEGMENTED_CONTROL_DATA_VALUE_ATTR: "data-value";
+export const SEGMENTED_CONTROL_CONTEXT_KEY: unique symbol;
+export const SEGMENTED_CONTROL_SELECT_KEY: unique symbol;
+export const SEGMENTED_CONTROL_FOCUS_KEY: unique symbol;
+declare namespace _default {
+    export { SEGMENTED_CONTROL_SIZES };
+    export { SEGMENTED_CONTROL_SIZE_DEFAULT };
+    export { SEGMENTED_CONTROL_SIZE_MODIFIERS };
+    export { SEGMENTED_CONTROL_ORIENTATIONS };
+    export { SEGMENTED_CONTROL_ORIENTATION_DEFAULT };
+    export { SEGMENTED_CONTROL_ACTIVATION_MODES };
+    export { SEGMENTED_CONTROL_ACTIVATION_MODE_DEFAULT };
+    export { SEGMENTED_CONTROL_SPREADS };
+    export { SEGMENTED_CONTROL_SPREAD_DEFAULT };
+    export { SEGMENTED_CONTROL_CONTEXT_KEY };
+    export { SEGMENTED_CONTROL_SELECT_KEY };
+    export { SEGMENTED_CONTROL_FOCUS_KEY };
+}
+export default _default;
+//# sourceMappingURL=segmented_control_constants.d.ts.map

package/dist/components/segmented_control/segmented_control_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmented_control_constants.d.ts","sourceRoot":"","sources":["../../../components/segmented_control/segmented_control_constants.js"],"names":[],"mappings":"AAAA,+CAAyG;AACzG,6CAA8C,GAAG,CAAC;AAElD;;;;;;;;;;;EAaE;AAEF,sDAAyE;AACzE,oDAAqD,YAAY,CAAC;AAElE,0DAAqE;AACrE,wDAAyD,MAAM,CAAC;AAEhE,iDAA4D;AAC5D,+CAAgD,MAAM,CAAC;AAEvD,8CAA+C,kBAAgB,CAAC;AAChE,gDAAiD,YAAY,CAAC;AAE9D,0DAAiF;AACjF,yDAA+E;AAC/E,wDAA6E"}

package/dist/components/segmented_control/segmented_control_item.vue.d.ts

@@ -0,0 +1,35 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "click" | "focus", ...args: any[]) => void;
+    disabled: boolean;
+    value: string;
+    label?: string | undefined;
+    labelClass?: string | unknown[] | Record<string, any> | undefined;
+    $props: {
+        readonly disabled?: boolean | undefined;
+        readonly value?: string | undefined;
+        readonly label?: string | undefined;
+        readonly labelClass?: string | unknown[] | Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        startIcon?(_: {
+            iconSize: any;
+        }): any;
+        endIcon?(_: {
+            iconSize: any;
+        }): any;
+        leading?(_: {}): any;
+        trailing?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=segmented_control_item.vue.d.ts.map

package/dist/components/segmented_control/segmented_control_item.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmented_control_item.vue.d.ts","sourceRoot":"","sources":["../../../components/segmented_control/segmented_control_item.vue"],"names":[],"mappings":"AA0DA;wBAuYqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;;2OAQG"}

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

@@ -1,9 +1,13 @@
-import { hasSlotContent, removeClassStyleAttrs, addClassStyleAttrs } from '../../common/utils';
+import { hasSlotContent, removeClassStyleAttrs } from '../../common/utils';
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     label: {
         type: StringConstructor;
         default: string;
     };
+    showLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     description: {
         type: StringConstructor;
         default: string;
@@ -14,8 +18,8 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         validator: (options: unknown) => any;
     };
     size: {
-        type: StringConstructor;
-        default: string;
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
         validator: (s: unknown) => boolean;
     };
     labelClass: {
@@ -50,30 +54,27 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
-    rootClass: {
-        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
-        default: string;
-    };
     modelValue: {
         type: (StringConstructor | NumberConstructor)[];
         default: string;
     };
-}>, {}, {
-    LABEL_SIZE_MODIFIERS: {
-        xs: string;
-        sm: string;
-        md: string;
-        lg: string;
-        xl: string;
+    labelSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+        validator: (s: unknown) => boolean;
     };
-    DESCRIPTION_SIZE_MODIFIERS: {
-        xs: string;
-        sm: string;
-        md: string;
-        lg: string;
-        xl: string;
+    labelStrength: {
+        type: StringConstructor;
+        default: null;
+        validator: (s: unknown) => boolean;
     };
+}>, {}, {
     SELECT_SIZE_MODIFIERS: {
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
         xs: string;
         sm: string;
         md: string;
@@ -81,12 +82,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         xl: string;
     };
     SELECT_STATE_MODIFIERS: {
-        error: string;
+        critical: string;
         warning: string;
-        success: string;
+        positive: string;
     };
     hasSlotContent: typeof hasSlotContent;
 }, {
+    resolvedLabelSize(): string | number;
+    resolvedDescriptionSize(): any;
+    resolvedDescriptionDensity(): "300" | undefined;
     selectListeners(): {
         input: () => void;
         change: (event: any) => void;
@@ -97,10 +101,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     labelAriaDetails(): unknown;
 }, {
     removeClassStyleAttrs: typeof removeClassStyleAttrs;
-    addClassStyleAttrs: typeof addClassStyleAttrs;
     emitValue(value: any, event: any): void;
     getOptionKey(value: any): string;
     validateOptionsPresence(): void;
+    runValidations(): void;
 }, {
     props: {
         messagesClass: {
@@ -129,6 +133,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: StringConstructor;
         default: string;
     };
+    showLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     description: {
         type: StringConstructor;
         default: string;
@@ -139,8 +147,8 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         validator: (options: unknown) => any;
     };
     size: {
-        type: StringConstructor;
-        default: string;
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
         validator: (s: unknown) => boolean;
     };
     labelClass: {
@@ -175,14 +183,20 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
-    rootClass: {
-        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
-        default: string;
-    };
     modelValue: {
         type: (StringConstructor | NumberConstructor)[];
         default: string;
     };
+    labelSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
+    labelStrength: {
+        type: StringConstructor;
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
 }>> & Readonly<{
     onInput?: ((...args: any[]) => any) | undefined;
     onChange?: ((...args: any[]) => any) | undefined;
@@ -191,10 +205,12 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     label: string;
     disabled: boolean;
     modelValue: string | number;
-    size: string;
+    size: string | number;
     description: string;
     labelClass: string | unknown[] | Record<string, any>;
-    rootClass: string | unknown[] | Record<string, any>;
+    showLabel: boolean;
+    labelSize: string | number;
+    labelStrength: string;
     options: unknown[];
     descriptionClass: string | unknown[] | Record<string, any>;
     selectClass: string | unknown[] | Record<string, any>;
@@ -243,6 +259,148 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         validationMessages: unknown[];
         showMessages: boolean;
     }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    DtText: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        as: {
+            type: StringConstructor;
+            default: string;
+        };
+        kind: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: null;
+        };
+        tone: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        align: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        truncate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLines: {
+            type: NumberConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        numeric: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wrap: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        textBoxTrim: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        strength: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        density: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+    }>, {}, {}, {
+        textClasses(): string[];
+        textStyles(): {
+            '--dt-text-line-clamp': number;
+        } | undefined;
+    }, {
+        getVariantClass(): string | null;
+        getModifierClass(value: any, modifiers: any, propName: any): any;
+        getAlignClass(): any;
+        getToneClass(): any;
+        getWrapClass(): any;
+        getTextBoxTrimClass(): any;
+        getStrengthClass(): any;
+        getDensityClass(): any;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        as: {
+            type: StringConstructor;
+            default: string;
+        };
+        kind: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        size: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: null;
+        };
+        tone: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        align: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        truncate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLines: {
+            type: NumberConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        numeric: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wrap: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        textBoxTrim: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        strength: {
+            type: StringConstructor;
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+        density: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: null;
+            validator: (value: unknown) => boolean;
+        };
+    }>> & Readonly<{}>, {
+        wrap: string;
+        size: string | number;
+        kind: string;
+        as: string;
+        tone: string;
+        align: string;
+        truncate: boolean;
+        maxLines: number;
+        numeric: boolean;
+        textBoxTrim: string;
+        strength: string;
+        density: string | number;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=select_menu.vue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"select_menu.vue.d.ts","sourceRoot":"","sources":["../../../components/select_menu/select_menu.vue"],"names":[],"mappings":"AA+EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAsWO,gBAAgB;sCAAhB,gBAAgB;mCAAhB,gBAAgB"}
+{"version":3,"file":"select_menu.vue.d.ts","sourceRoot":"","sources":["../../../components/select_menu/select_menu.vue"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAsZO,gBAAgB;sCAAhB,gBAAgB"}

package/dist/components/select_menu/select_menu_constants.d.ts

@@ -1,14 +1,19 @@
-export namespace SELECT_SIZE_MODIFIERS {
-    let xs: string;
-    let sm: string;
-    let md: string;
-    let lg: string;
-    let xl: string;
-}
+export const SELECT_SIZE_MODIFIERS: {
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
 export namespace SELECT_STATE_MODIFIERS {
-    let error: string;
+    let critical: string;
     let warning: string;
-    let success: string;
+    let positive: string;
 }
 declare namespace _default {
     export { SELECT_SIZE_MODIFIERS };

package/dist/components/select_menu/select_menu_constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select_menu_constants.d.ts","sourceRoot":"","sources":["../../../components/select_menu/select_menu_constants.js"],"names":[],"mappings":""}
+{"version":3,"file":"select_menu_constants.d.ts","sourceRoot":"","sources":["../../../components/select_menu/select_menu_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;EAaE"}