@omnia/fx 8.0.32-vnext → 8.0.34-vnext

package/internal-do-not-import-from-here/shared/models/Equals.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const _equalsObject = {};
-Object.defineProperty(String.prototype, "equals", {
-    value: function () {
-        return _equalsObject;
-    },
-    writable: false,
-    configurable: false,
-    enumerable: false
-});
+// only add extension methods when running in browser, not in node.js
+if (globalThis.omnia) {
+    Object.defineProperty(String.prototype, "equals", {
+        value: function () {
+            return _equalsObject;
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+}

package/internal-do-not-import-from-here/ux/confirmdialog/IVueConfirmDialog.d.ts

@@ -9,6 +9,7 @@ export interface ConfirmDialogOptions {
     contentClass?: string;
     buttonClass?: string;
     icon?: string;
+    variant?: "toolbar";
     maxWidth?: number;
     displayMode?: "message" | "confirm";
 }

package/internal-do-not-import-from-here/ux/features/FeaturesJourney.css.d.ts

@@ -7,5 +7,4 @@ export declare const FeaturesJourneyStyles: {
     cotentRowActive: string;
     titleWithLength: string;
     subtitle: string;
-    tableFullWidth: string;
 };

package/internal-do-not-import-from-here/ux/journey/v2/JourneyBlade.d.ts

@@ -63,6 +63,7 @@ declare const _default: {
             readonly save?: boolean;
             "onClick:cancel"?: (id: string) => any;
             "onClick:delete"?: (id: string) => any;
+            readonly home?: boolean;
             "onClick:back"?: (id: string) => any;
             readonly searchable?: boolean;
             onSearch?: (searchText: string) => any;
@@ -113,6 +114,11 @@ declare const _default: {
             } & {
                 type: import("vue").PropType<boolean>;
             };
+            home: {
+                type: import("vue").PropType<boolean>;
+            } & {
+                type: import("vue").PropType<boolean>;
+            };
             size: {
                 type: import("vue").PropType<BladeSizes>;
                 required: false;
@@ -192,6 +198,11 @@ declare const _default: {
         } & {
             type: import("vue").PropType<boolean>;
         };
+        home: {
+            type: import("vue").PropType<boolean>;
+        } & {
+            type: import("vue").PropType<boolean>;
+        };
         size: {
             type: import("vue").PropType<BladeSizes>;
             required: false;
@@ -248,6 +259,11 @@ declare const _default: {
     } & {
         type: import("vue").PropType<boolean>;
     };
+    home: {
+        type: import("vue").PropType<boolean>;
+    } & {
+        type: import("vue").PropType<boolean>;
+    };
     size: {
         type: import("vue").PropType<BladeSizes>;
         required: false;
@@ -290,6 +306,7 @@ declare const _default: {
         };
         create?: boolean;
         save?: boolean;
+        home?: boolean;
         searchable?: boolean;
     }>, "onClick:cancel" | "onClick:delete" | "onClick:back" | "onSearch" | "onClick:add" | "onClick:save"> & {
         "onClick:cancel"?: (id: string) => any;

package/internal-do-not-import-from-here/ux/oxide/appbar/Appbar.css.d.ts

@@ -1,6 +1,10 @@
 import { ColorDefinition } from "../../velcron/core";
+import { useColorSchemaSetup } from "../..";
+export declare const AppBarTypeDefinition: string[];
+export type AppBarType = typeof AppBarTypeDefinition[number];
 export declare const AppbarStyles: {
     templateTitle: string;
     content: string;
+    wrapper: (variant: AppBarType, colors: ReturnType<typeof useColorSchemaSetup>) => string;
     navigation: (color: ColorDefinition) => string;
 };

package/internal-do-not-import-from-here/ux/oxide/appbar/Appbar.d.ts

@@ -62,6 +62,7 @@ declare const _default: {
             } & {
                 actionButtons?: Func<[VNodeChild]>;
             };
+            readonly variant?: string;
             readonly navigation?: boolean;
             readonly closable?: boolean;
             readonly subTitle?: string;
@@ -109,6 +110,11 @@ declare const _default: {
             } & {
                 type: import("vue").PropType<boolean>;
             };
+            variant: {
+                type: import("vue").PropType<string>;
+            } & {
+                type: import("vue").PropType<string>;
+            };
             absolute: {
                 type: import("vue").PropType<boolean>;
             } & {
@@ -187,6 +193,11 @@ declare const _default: {
         } & {
             type: import("vue").PropType<boolean>;
         };
+        variant: {
+            type: import("vue").PropType<string>;
+        } & {
+            type: import("vue").PropType<string>;
+        };
         absolute: {
             type: import("vue").PropType<boolean>;
         } & {
@@ -240,6 +251,11 @@ declare const _default: {
     } & {
         type: import("vue").PropType<boolean>;
     };
+    variant: {
+        type: import("vue").PropType<string>;
+    } & {
+        type: import("vue").PropType<string>;
+    };
     absolute: {
         type: import("vue").PropType<boolean>;
     } & {
@@ -288,6 +304,7 @@ declare const _default: {
         } & {
             actionButtons?: Func<[VNodeChild]>;
         };
+        variant?: string;
         navigation?: boolean;
         closable?: boolean;
         subTitle?: string;

package/internal-do-not-import-from-here/ux/oxide/datatable/DataTable.css.d.ts

@@ -1,4 +1,4 @@
 import { useColorSchemaStore } from "../../theming-v2";
 export declare const DataTableStyles: {
-    wrapper: (colors: ReturnType<typeof useColorSchemaStore>, hideFooter: boolean) => string;
+    wrapper: (colors: ReturnType<typeof useColorSchemaStore>, hideFooter: boolean, hover: boolean, clickable: boolean) => string;
 };

package/internal-do-not-import-from-here/ux/oxide/datatable/DataTable.d.ts

@@ -70,6 +70,7 @@ declare const _default: {
             readonly showExpand?: boolean;
             readonly itemsPerPage?: number;
             readonly "onUpdate:expanded"?: (value: string[]) => any;
+            readonly clickable?: boolean;
             readonly "v-model:expanded"?: string[];
         };
         $attrs: {
@@ -116,6 +117,10 @@ declare const _default: {
             } & {
                 type: import("vue").PropType<string | number>;
             };
+            clickable: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
             hover: {
                 type: import("vue").PropType<boolean>;
                 required: false;
@@ -206,6 +211,10 @@ declare const _default: {
         } & {
             type: import("vue").PropType<string | number>;
         };
+        clickable: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
         hover: {
             type: import("vue").PropType<boolean>;
             required: false;
@@ -274,6 +283,10 @@ declare const _default: {
     } & {
         type: import("vue").PropType<string | number>;
     };
+    clickable: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
     hover: {
         type: import("vue").PropType<boolean>;
         required: false;
@@ -337,6 +350,7 @@ declare const _default: {
         showExpand?: boolean;
         itemsPerPage?: number;
         "onUpdate:expanded"?: (value: string[]) => any;
+        clickable?: boolean;
         "v-model:expanded"?: string[];
     }>, never>;
 };

package/internal-do-not-import-from-here/ux/oxide/dialog/Dialog.css.d.ts

@@ -4,6 +4,7 @@ export declare const DialogStyles: {
     templateTitle: string;
     titleWrapper: string;
     fixedContent: (backgroundColor: string) => string;
+    navigationDrawer: (dark: boolean) => string;
     activator: string;
     contentScrollWrapper: (customScroll: boolean, hasButtons: boolean, fullSize: boolean, staticContent: boolean, variant: DialogType) => string;
     notScrollOutside: string;

package/internal-do-not-import-from-here/ux/oxide/progress/Progress.css.d.ts

@@ -0,0 +1 @@
+export declare const ProgressStyles: {};

package/internal-do-not-import-from-here/ux/oxide/progress/Progress.d.ts

@@ -0,0 +1,577 @@
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            [x: number]: unknown;
+            toString: (() => string) | ((() => string) & (() => string));
+            readonly concat: unknown;
+            readonly indexOf: unknown;
+            readonly lastIndexOf: unknown;
+            readonly slice: unknown;
+            readonly length: unknown;
+            readonly includes: unknown;
+            readonly at: unknown;
+            toLocaleString: (() => string) | ((() => string) & (() => string));
+            readonly join: unknown;
+            readonly every: unknown;
+            readonly some: unknown;
+            readonly forEach: unknown;
+            readonly map: unknown;
+            readonly filter: unknown;
+            readonly reduce: unknown;
+            readonly reduceRight: unknown;
+            readonly find: unknown;
+            readonly findIndex: unknown;
+            readonly entries: unknown;
+            readonly keys: unknown;
+            readonly values: unknown;
+            readonly flatMap: unknown;
+            readonly flat: unknown;
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        } | {
+            [x: number]: unknown;
+            toString: (() => string) | ((() => string) & (() => string));
+            readonly concat: unknown;
+            readonly indexOf: unknown;
+            readonly lastIndexOf: unknown;
+            readonly slice: unknown;
+            readonly length: unknown;
+            readonly includes: unknown;
+            readonly at: unknown;
+            toLocaleString: (() => string) | ((() => string) & (() => string));
+            readonly join: unknown;
+            readonly every: unknown;
+            readonly some: unknown;
+            readonly forEach: unknown;
+            readonly map: unknown;
+            readonly filter: unknown;
+            readonly reduce: unknown;
+            readonly reduceRight: unknown;
+            readonly find: unknown;
+            readonly findIndex: unknown;
+            readonly entries: unknown;
+            readonly keys: unknown;
+            readonly values: unknown;
+            readonly flatMap: unknown;
+            readonly flat: unknown;
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<{
+            [x: number]: string;
+            readonly length: number;
+            toString: () => string;
+            toLocaleString: () => string;
+            concat: {
+                (...items: ConcatArray<string>[]): string[];
+                (...items: (string | ConcatArray<string>)[]): string[];
+            };
+            join: (separator?: string) => string;
+            slice: (start?: number, end?: number) => string[];
+            indexOf: (searchElement: string, fromIndex?: number) => number;
+            lastIndexOf: (searchElement: string, fromIndex?: number) => number;
+            every: {
+                <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
+                (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
+            };
+            some: (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any) => boolean;
+            forEach: (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any) => void;
+            map: <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any) => U[];
+            filter: {
+                <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): S_1[];
+                (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
+            };
+            reduce: {
+                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+                <U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: readonly string[]) => U_1, initialValue: U_1): U_1;
+            };
+            reduceRight: {
+                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+                <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
+            };
+            find: {
+                <S_2 extends string>(predicate: (value: string, index: number, obj: readonly string[]) => value is S_2, thisArg?: any): S_2;
+                (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
+            };
+            findIndex: (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any) => number;
+            entries: () => IterableIterator<[number, string]>;
+            keys: () => IterableIterator<number>;
+            values: () => IterableIterator<string>;
+            includes: (searchElement: string, fromIndex?: number) => boolean;
+            flatMap: <U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This) => U_3[];
+            flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
+            [Symbol.iterator]: () => IterableIterator<string>;
+            readonly [Symbol.unscopables]: {
+                [x: number]: boolean;
+                readonly length?: boolean;
+                toString?: boolean;
+                toLocaleString?: boolean;
+                concat?: boolean;
+                join?: boolean;
+                slice?: boolean;
+                indexOf?: boolean;
+                lastIndexOf?: boolean;
+                every?: boolean;
+                some?: boolean;
+                forEach?: boolean;
+                map?: boolean;
+                filter?: boolean;
+                reduce?: boolean;
+                reduceRight?: boolean;
+                find?: boolean;
+                findIndex?: boolean;
+                entries?: boolean;
+                keys?: boolean;
+                values?: boolean;
+                includes?: boolean;
+                flatMap?: boolean;
+                flat?: boolean;
+                [Symbol.iterator]?: boolean;
+                readonly [Symbol.unscopables]?: boolean;
+                at?: boolean;
+            };
+            at: (index: number) => string;
+        }> | Readonly<import("vue").ExtractPropTypes<{
+            [x: string]: import("vue").Prop<unknown, unknown>;
+        }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {} | {}, {}, string, {}> & {
+            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, 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_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & (Readonly<{
+        [x: number]: string;
+        readonly length: number;
+        toString: () => string;
+        toLocaleString: () => string;
+        concat: {
+            (...items: ConcatArray<string>[]): string[];
+            (...items: (string | ConcatArray<string>)[]): string[];
+        };
+        join: (separator?: string) => string;
+        slice: (start?: number, end?: number) => string[];
+        indexOf: (searchElement: string, fromIndex?: number) => number;
+        lastIndexOf: (searchElement: string, fromIndex?: number) => number;
+        every: {
+            <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
+        };
+        some: (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any) => boolean;
+        forEach: (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any) => void;
+        map: <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any) => U[];
+        filter: {
+            <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): S_1[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
+        };
+        reduce: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: readonly string[]) => U_1, initialValue: U_1): U_1;
+        };
+        reduceRight: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
+        };
+        find: {
+            <S_2 extends string>(predicate: (value: string, index: number, obj: readonly string[]) => value is S_2, thisArg?: any): S_2;
+            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
+        };
+        findIndex: (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any) => number;
+        entries: () => IterableIterator<[number, string]>;
+        keys: () => IterableIterator<number>;
+        values: () => IterableIterator<string>;
+        includes: (searchElement: string, fromIndex?: number) => boolean;
+        flatMap: <U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This) => U_3[];
+        flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
+        [Symbol.iterator]: () => IterableIterator<string>;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean;
+            readonly length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            slice?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+            [Symbol.iterator]?: boolean;
+            readonly [Symbol.unscopables]?: boolean;
+            at?: boolean;
+        };
+        at: (index: number) => string;
+    }> | Readonly<import("vue").ExtractPropTypes<{
+        [x: string]: import("vue").Prop<unknown, unknown>;
+    }>>) & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {} & Readonly<{
+        [x: number]: string;
+        readonly length: number;
+        toString: () => string;
+        toLocaleString: () => string;
+        concat: {
+            (...items: ConcatArray<string>[]): string[];
+            (...items: (string | ConcatArray<string>)[]): string[];
+        };
+        join: (separator?: string) => string;
+        slice: (start?: number, end?: number) => string[];
+        indexOf: (searchElement: string, fromIndex?: number) => number;
+        lastIndexOf: (searchElement: string, fromIndex?: number) => number;
+        every: {
+            <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
+        };
+        some: (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any) => boolean;
+        forEach: (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any) => void;
+        map: <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any) => U[];
+        filter: {
+            <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): S_1[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
+        };
+        reduce: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: readonly string[]) => U_1, initialValue: U_1): U_1;
+        };
+        reduceRight: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
+        };
+        find: {
+            <S_2 extends string>(predicate: (value: string, index: number, obj: readonly string[]) => value is S_2, thisArg?: any): S_2;
+            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
+        };
+        findIndex: (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any) => number;
+        entries: () => IterableIterator<[number, string]>;
+        keys: () => IterableIterator<number>;
+        values: () => IterableIterator<string>;
+        includes: (searchElement: string, fromIndex?: number) => boolean;
+        flatMap: <U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This) => U_3[];
+        flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
+        [Symbol.iterator]: () => IterableIterator<string>;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean;
+            readonly length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            slice?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+            [Symbol.iterator]?: boolean;
+            readonly [Symbol.unscopables]?: boolean;
+            at?: boolean;
+        };
+        at: (index: number) => string;
+    } | import("vue").ExtractPropTypes<{
+        [x: string]: import("vue").Prop<unknown, unknown>;
+    }>>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<{
+    [x: number]: string;
+    readonly length: number;
+    toString: () => string;
+    toLocaleString: () => string;
+    concat: {
+        (...items: ConcatArray<string>[]): string[];
+        (...items: (string | ConcatArray<string>)[]): string[];
+    };
+    join: (separator?: string) => string;
+    slice: (start?: number, end?: number) => string[];
+    indexOf: (searchElement: string, fromIndex?: number) => number;
+    lastIndexOf: (searchElement: string, fromIndex?: number) => number;
+    every: {
+        <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
+        (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
+    };
+    some: (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any) => boolean;
+    forEach: (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any) => void;
+    map: <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any) => U[];
+    filter: {
+        <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): S_1[];
+        (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
+    };
+    reduce: {
+        (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+        (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+        <U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: readonly string[]) => U_1, initialValue: U_1): U_1;
+    };
+    reduceRight: {
+        (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+        (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+        <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
+    };
+    find: {
+        <S_2 extends string>(predicate: (value: string, index: number, obj: readonly string[]) => value is S_2, thisArg?: any): S_2;
+        (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
+    };
+    findIndex: (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any) => number;
+    entries: () => IterableIterator<[number, string]>;
+    keys: () => IterableIterator<number>;
+    values: () => IterableIterator<string>;
+    includes: (searchElement: string, fromIndex?: number) => boolean;
+    flatMap: <U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This) => U_3[];
+    flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
+    [Symbol.iterator]: () => IterableIterator<string>;
+    readonly [Symbol.unscopables]: {
+        [x: number]: boolean;
+        readonly length?: boolean;
+        toString?: boolean;
+        toLocaleString?: boolean;
+        concat?: boolean;
+        join?: boolean;
+        slice?: boolean;
+        indexOf?: boolean;
+        lastIndexOf?: boolean;
+        every?: boolean;
+        some?: boolean;
+        forEach?: boolean;
+        map?: boolean;
+        filter?: boolean;
+        reduce?: boolean;
+        reduceRight?: boolean;
+        find?: boolean;
+        findIndex?: boolean;
+        entries?: boolean;
+        keys?: boolean;
+        values?: boolean;
+        includes?: boolean;
+        flatMap?: boolean;
+        flat?: boolean;
+        [Symbol.iterator]?: boolean;
+        readonly [Symbol.unscopables]?: boolean;
+        at?: boolean;
+    };
+    at: (index: number) => string;
+}> | Readonly<import("vue").ExtractPropTypes<{
+    [x: string]: import("vue").Prop<unknown, unknown>;
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {} | {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{
+        [x: number]: string;
+        readonly length: number;
+        toString: () => string;
+        toLocaleString: () => string;
+        concat: {
+            (...items: ConcatArray<string>[]): string[];
+            (...items: (string | ConcatArray<string>)[]): string[];
+        };
+        join: (separator?: string) => string;
+        slice: (start?: number, end?: number) => string[];
+        indexOf: (searchElement: string, fromIndex?: number) => number;
+        lastIndexOf: (searchElement: string, fromIndex?: number) => number;
+        every: {
+            <S extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S, thisArg?: any): this is readonly S[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): boolean;
+        };
+        some: (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any) => boolean;
+        forEach: (callbackfn: (value: string, index: number, array: readonly string[]) => void, thisArg?: any) => void;
+        map: <U>(callbackfn: (value: string, index: number, array: readonly string[]) => U, thisArg?: any) => U[];
+        filter: {
+            <S_1 extends string>(predicate: (value: string, index: number, array: readonly string[]) => value is S_1, thisArg?: any): S_1[];
+            (predicate: (value: string, index: number, array: readonly string[]) => unknown, thisArg?: any): string[];
+        };
+        reduce: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_1>(callbackfn: (previousValue: U_1, currentValue: string, currentIndex: number, array: readonly string[]) => U_1, initialValue: U_1): U_1;
+        };
+        reduceRight: {
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string): string;
+            (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: readonly string[]) => string, initialValue: string): string;
+            <U_2>(callbackfn: (previousValue: U_2, currentValue: string, currentIndex: number, array: readonly string[]) => U_2, initialValue: U_2): U_2;
+        };
+        find: {
+            <S_2 extends string>(predicate: (value: string, index: number, obj: readonly string[]) => value is S_2, thisArg?: any): S_2;
+            (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any): string;
+        };
+        findIndex: (predicate: (value: string, index: number, obj: readonly string[]) => unknown, thisArg?: any) => number;
+        entries: () => IterableIterator<[number, string]>;
+        keys: () => IterableIterator<number>;
+        values: () => IterableIterator<string>;
+        includes: (searchElement: string, fromIndex?: number) => boolean;
+        flatMap: <U_3, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U_3 | readonly U_3[], thisArg?: This) => U_3[];
+        flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
+        [Symbol.iterator]: () => IterableIterator<string>;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean;
+            readonly length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            slice?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+            [Symbol.iterator]?: boolean;
+            readonly [Symbol.unscopables]?: boolean;
+            at?: boolean;
+        };
+        at: (index: number) => string;
+    }>, never> | Omit<Readonly<{} & {
+        [x: string]: unknown;
+        [x: number]: unknown;
+    }>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/oxide/toolbar/Toolbar.d.ts

@@ -7,8 +7,12 @@ declare const _default: {
         $: import("vue").ComponentInternalInstance;
         $data: {};
         $props: {
+            container?: any;
+            blueprint?: any;
+            colorSchemaType?: any;
+            blueprintType?: any;
+            colors?: any;
             readonly title?: string;
-            readonly container?: unknown;
             style?: unknown;
             class?: String | String[];
             key?: string | number | symbol;
@@ -55,21 +59,13 @@ declare const _default: {
                 [key: string]: any;
             }>) => void)[];
             readonly closeButton?: boolean;
-            readonly blueprint?: unknown;
-            readonly colorSchemaType?: unknown;
-            readonly blueprintType?: unknown;
-            readonly "v-slots"?: ({
+            readonly "v-slots"?: {
                 default?: Func<[VNodeChild]>;
             } & {
                 title?: Func<[VNodeChild]>;
                 customButtons?: Func<[VNodeChild]>;
-            }) | ({
-                default?: () => VNodeChild;
-            } & {
-                icon?: () => VNodeChild;
-            });
+            };
             readonly variant?: string;
-            readonly colors?: unknown;
             "onClick:close"?: () => any;
             readonly backButton?: boolean;
             "onClick:back"?: () => any;
@@ -88,43 +84,51 @@ declare const _default: {
         $emit: ((event: "click:close") => void) & ((event: "click:back") => void);
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            "v-slots": import("vue").Prop<({
-                default?: Func<[VNodeChild]>;
-            } & {
-                title?: Func<[VNodeChild]>;
-                customButtons?: Func<[VNodeChild]>;
-            }) | ({
-                default?: () => VNodeChild;
-            } & {
-                icon?: () => VNodeChild;
-            }), ({
+            "v-slots": import("vue").Prop<{
                 default?: Func<[VNodeChild]>;
             } & {
                 title?: Func<[VNodeChild]>;
                 customButtons?: Func<[VNodeChild]>;
-            }) | ({
-                default?: () => VNodeChild;
+            }>;
+            backButton: {
+                type: import("vue").PropType<boolean>;
+            };
+            closeButton: {
+                type: import("vue").PropType<boolean>;
+            };
+            icon: {
+                type: import("vue").PropType<IIcon>;
+            };
+            title: {
+                type: import("vue").PropType<string>;
+            };
+            variant: {
+                type: import("vue").PropType<string>;
             } & {
-                icon?: () => VNodeChild;
-            })>;
-            backButton: import("vue").Prop<boolean, boolean>;
-            closeButton: import("vue").Prop<boolean, boolean>;
-            icon: import("vue").Prop<IIcon, IIcon>;
-            title: import("vue").Prop<string, string>;
-            variant: import("vue").Prop<string, string>;
-            class: import("vue").Prop<String | String[], String | String[]>;
-            colorSchemaType?: import("vue").Prop<unknown, unknown>;
-            container?: import("vue").Prop<unknown, unknown>;
-            colors?: import("vue").Prop<unknown, unknown>;
-            blueprintType?: import("vue").Prop<unknown, unknown>;
-            blueprint?: import("vue").Prop<unknown, unknown>;
+                type: import("vue").PropType<string>;
+            };
+            class: {
+                type: import("vue").PropType<String | String[]>;
+                required: boolean;
+            };
+            colorSchemaType?: any;
+            container?: any;
+            colors?: any;
+            blueprintType?: any;
+            blueprint?: any;
         }>> & {
             "onClick:close"?: () => any;
             "onClick:back"?: () => any;
-        }, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
             "click:close": () => true;
             "click:back": () => true;
-        }, string, {}, {}, string, {}> & {
+        }, string, {
+            container?: any;
+            blueprint?: any;
+            colorSchemaType?: any;
+            blueprintType?: any;
+            colors?: any;
+        }, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -145,36 +149,38 @@ declare const _default: {
         $nextTick: typeof import("vue").nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
     } & Readonly<import("vue").ExtractPropTypes<{
-        "v-slots": import("vue").Prop<({
-            default?: Func<[VNodeChild]>;
-        } & {
-            title?: Func<[VNodeChild]>;
-            customButtons?: Func<[VNodeChild]>;
-        }) | ({
-            default?: () => VNodeChild;
-        } & {
-            icon?: () => VNodeChild;
-        }), ({
+        "v-slots": import("vue").Prop<{
             default?: Func<[VNodeChild]>;
         } & {
             title?: Func<[VNodeChild]>;
             customButtons?: Func<[VNodeChild]>;
-        }) | ({
-            default?: () => VNodeChild;
+        }>;
+        backButton: {
+            type: import("vue").PropType<boolean>;
+        };
+        closeButton: {
+            type: import("vue").PropType<boolean>;
+        };
+        icon: {
+            type: import("vue").PropType<IIcon>;
+        };
+        title: {
+            type: import("vue").PropType<string>;
+        };
+        variant: {
+            type: import("vue").PropType<string>;
         } & {
-            icon?: () => VNodeChild;
-        })>;
-        backButton: import("vue").Prop<boolean, boolean>;
-        closeButton: import("vue").Prop<boolean, boolean>;
-        icon: import("vue").Prop<IIcon, IIcon>;
-        title: import("vue").Prop<string, string>;
-        variant: import("vue").Prop<string, string>;
-        class: import("vue").Prop<String | String[], String | String[]>;
-        colorSchemaType?: import("vue").Prop<unknown, unknown>;
-        container?: import("vue").Prop<unknown, unknown>;
-        colors?: import("vue").Prop<unknown, unknown>;
-        blueprintType?: import("vue").Prop<unknown, unknown>;
-        blueprint?: import("vue").Prop<unknown, unknown>;
+            type: import("vue").PropType<string>;
+        };
+        class: {
+            type: import("vue").PropType<String | String[]>;
+            required: boolean;
+        };
+        colorSchemaType?: any;
+        container?: any;
+        colors?: any;
+        blueprintType?: any;
+        blueprint?: any;
     }>> & {
         "onClick:close"?: () => any;
         "onClick:back"?: () => any;
@@ -183,64 +189,69 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    "v-slots": import("vue").Prop<({
-        default?: Func<[VNodeChild]>;
-    } & {
-        title?: Func<[VNodeChild]>;
-        customButtons?: Func<[VNodeChild]>;
-    }) | ({
-        default?: () => VNodeChild;
-    } & {
-        icon?: () => VNodeChild;
-    }), ({
+    "v-slots": import("vue").Prop<{
         default?: Func<[VNodeChild]>;
     } & {
         title?: Func<[VNodeChild]>;
         customButtons?: Func<[VNodeChild]>;
-    }) | ({
-        default?: () => VNodeChild;
+    }>;
+    backButton: {
+        type: import("vue").PropType<boolean>;
+    };
+    closeButton: {
+        type: import("vue").PropType<boolean>;
+    };
+    icon: {
+        type: import("vue").PropType<IIcon>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    };
+    variant: {
+        type: import("vue").PropType<string>;
     } & {
-        icon?: () => VNodeChild;
-    })>;
-    backButton: import("vue").Prop<boolean, boolean>;
-    closeButton: import("vue").Prop<boolean, boolean>;
-    icon: import("vue").Prop<IIcon, IIcon>;
-    title: import("vue").Prop<string, string>;
-    variant: import("vue").Prop<string, string>;
-    class: import("vue").Prop<String | String[], String | String[]>;
-    colorSchemaType?: import("vue").Prop<unknown, unknown>;
-    container?: import("vue").Prop<unknown, unknown>;
-    colors?: import("vue").Prop<unknown, unknown>;
-    blueprintType?: import("vue").Prop<unknown, unknown>;
-    blueprint?: import("vue").Prop<unknown, unknown>;
+        type: import("vue").PropType<string>;
+    };
+    class: {
+        type: import("vue").PropType<String | String[]>;
+        required: boolean;
+    };
+    colorSchemaType?: any;
+    container?: any;
+    colors?: any;
+    blueprintType?: any;
+    blueprint?: any;
 }>> & {
     "onClick:close"?: () => any;
     "onClick:back"?: () => any;
-}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "click:close": () => true;
     "click:back": () => true;
-}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
+}, string, {
+    container?: any;
+    blueprint?: any;
+    colorSchemaType?: any;
+    blueprintType?: any;
+    colors?: any;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{
+        container?: any;
+        blueprint?: any;
+        colorSchemaType?: any;
+        blueprintType?: any;
+        colors?: any;
+    } & {
         title?: string;
-        container?: unknown;
         class?: String | String[];
         icon?: IIcon;
         closeButton?: boolean;
-        blueprint?: unknown;
-        colorSchemaType?: unknown;
-        blueprintType?: unknown;
-        "v-slots"?: ({
+        "v-slots"?: {
             default?: Func<[VNodeChild]>;
         } & {
             title?: Func<[VNodeChild]>;
             customButtons?: Func<[VNodeChild]>;
-        }) | ({
-            default?: () => VNodeChild;
-        } & {
-            icon?: () => VNodeChild;
-        });
+        };
         variant?: string;
-        colors?: unknown;
         backButton?: boolean;
     }>, "onClick:close" | "onClick:back"> & {
         "onClick:close"?: () => any;

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseComponentStyling.d.ts

@@ -1,6 +1,7 @@
 import { ColorStyles } from "@omnia/fx-models";
 import { useColorSchemaStore } from "../ColorSchemaStore";
 export declare function useScrollStyling(colors: ReturnType<typeof useColorSchemaStore>, toned?: boolean, targetSelector?: string): string;
+export declare function useDividingOpacity(dark: boolean): string;
 export declare function useBackgroundOpacity(dark: boolean, opacity?: Number): string;
 export declare function useBackgroundOpacityOnColor(color: string, dark: boolean, opacity?: Number): any;
 export declare function useColorStyling(color: string, opacity?: number): ColorStyles;

package/internal-do-not-import-from-here/wctypings.d.ts

@@ -112,6 +112,7 @@ import wc994b0ed2b0794f928849a3fb5c52c70a from './ux/oxide/main/Main';
 import wce688539435a64ccf8569a6e05020ca94 from './ux/oxide/menu/Menu';
 import wcd17d504fd4874d8bb50ab6a946859546 from './ux/oxide/navigationdrawer/NavigationDrawer';
 import wcc51213da3caa4607b2fa435ae0c7acbf from './ux/oxide/panel/Panel';
+import wc61e392c374cf4be6b9a1457b79a715ed from './ux/oxide/progress/Progress';
 import wc6c9f088f52de491bbe36933530a1880a from './ux/oxide/radio/RadioGroup';
 import wca156e0af12b3464082a7e9fd2cdab84a from './ux/oxide/radio/Radio';
 import wc87b50e67ce504ec292925641cfb29016 from './ux/oxide/select/Select';
@@ -353,6 +354,7 @@ declare global {
             "o-menu": typeof wce688539435a64ccf8569a6e05020ca94.propsDefinition & VueComponentBaseProps;
             "o-navigation-drawer": typeof wcd17d504fd4874d8bb50ab6a946859546.propsDefinition & VueComponentBaseProps;
             "o-panel": typeof wcc51213da3caa4607b2fa435ae0c7acbf.propsDefinition & VueComponentBaseProps;
+            "o-progress": typeof wc61e392c374cf4be6b9a1457b79a715ed.propsDefinition & VueComponentBaseProps;
             "o-radio-group": typeof wc6c9f088f52de491bbe36933530a1880a.propsDefinition & VueComponentBaseProps;
             "o-radio": typeof wca156e0af12b3464082a7e9fd2cdab84a.propsDefinition & VueComponentBaseProps;
             "o-select": typeof wc87b50e67ce504ec292925641cfb29016.propsDefinition & VueComponentBaseProps;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.32-vnext",
+  "version": "8.0.34-vnext",
   "description": "Provide Omnia Fx typings and tooling for clientside Omnia development.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -20,7 +20,7 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.32-vnext",
+    "@omnia/fx-models": "8.0.34-vnext",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.10.7",