@omnia/fx 8.0.2-vnext → 8.0.3-dev

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

@@ -0,0 +1,239 @@
+import "client/tooling/vue/config/wctypings";
+import "../wctypings";
+import "./button/index";
+import "./colorpicker/index";
+import "./confirmdialog/index";
+import "./contextlanguagepicker/index";
+import "./datatable/index";
+import "./datetimepicker/index";
+import "./dialog/index";
+import "./documenticon/index";
+import "./enterpriseproperties/index";
+import "./enterprisepropertysets/index";
+import "./errormessage/index";
+import "./features/index";
+import "./fileuploader/index";
+import "./governancedashboard/index";
+import "./heading/index";
+import "./icon/index";
+import "./iconpicker/index";
+import "./iframe/index";
+import "./imagegrid/index";
+import "./imagetransformation/index";
+import "./imagetransformer/index";
+import "./journey/index";
+import "./languagepicker/index";
+import "./layoutcanvas/renderer/ILayoutBlockRendererHelper";
+import "./layoutcanvas/renderer/ILayoutRendererCanvas";
+import "./letteravatar/index";
+import "./mediapicker/index";
+import "./mediapickerproviders/index";
+import "./messaging/index";
+import "./multilingualinput/index";
+import "./peoplepicker/index";
+import "./permissioninput/index";
+import "./richtexteditor/index";
+import "./richtexteditor/PublicRichTextEditorApi";
+import "./richtexteditorrenderer/index";
+import "./rollupfilter/index";
+import "./settings/index";
+import "./sitelogoicon/index";
+import "./social/index";
+import "./spacingpicker/index";
+import "./statusmessageoverlay/index";
+import "./templatepicker/index";
+import "./texttranslator/index";
+import "./theming/index";
+import "./timeperiodpicker/index";
+import "./timezonepicker/index";
+import "./urlinput/index";
+import "./validation/index";
+import "./welcome/index";
+import "./wizard/index";
+import "./enterpriseglossary/index";
+import "./app/builders/index";
+import "./app/appinstance/index";
+import "./selection/index";
+import "./profilecard/index";
+import "./organizationtree/IOrganizationTree";
+type VuetifyProps<T> = {
+    [K in keyof (T extends {
+        $props: any;
+    } ? T["$props"] : T)]: T extends {
+        $props: any;
+    } ? T["$props"][K] : never;
+};
+type VuetifySlots<T> = {
+    [K in keyof T as K extends `v-slot:${infer N}` ? N : never]: T[K];
+};
+type VuetifyValue<T> = T extends {
+    value?: any;
+} ? T["value"] : T;
+import { VTooltip, VTextarea, VSwitch, VRadioGroup, VForm, VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll, VChip, VSelect, VBadge } from "vuetify/components";
+import { Intersect } from "vuetify/directives";
+import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer } from "vuetify/labs/components";
+export interface VDataTableServerSlots extends VuetifySlots<VuetifyProps<Pick<VDataTableServer, "$props">>> {
+}
+export interface VDataTableSlots extends VuetifySlots<VuetifyProps<Pick<VDataTable, "$props">>> {
+}
+export interface VListItemSlots extends VuetifySlots<VuetifyProps<Pick<VListItem, "$props">>> {
+}
+export interface VTextFieldSlots extends VuetifySlots<VuetifyProps<Pick<VTextField, "$props">>> {
+}
+export interface VTextAreaSlots extends VuetifySlots<VuetifyProps<Pick<VTextarea, "$props">>> {
+}
+declare global {
+    namespace JSX {
+        interface Element {
+        }
+        interface ElementClass {
+        }
+        interface IntrinsicAttributes {
+            "v-intersect"?: VuetifyValue<Pick<Parameters<typeof Intersect.mounted>[1], "value">>;
+        }
+        interface IntrinsicElements {
+            "v-tooltip": VuetifyProps<Pick<VTooltip, "$props">> & {
+                [name: string]: any;
+            };
+            "v-textarea": VuetifyProps<Pick<VTextarea, "$props">> & {
+                [name: string]: any;
+            };
+            "v-radio-group": VuetifyProps<Pick<VRadioGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-switch": VuetifyProps<Pick<VSwitch, "$props">> & {
+                [name: string]: any;
+            };
+            "v-form": VuetifyProps<Pick<VForm, "$props">> & {
+                [name: string]: any;
+            };
+            "v-badge": VuetifyProps<Pick<VBadge, "$props">> & {
+                [name: string]: any;
+            };
+            "v-select": VuetifyProps<Pick<VSelect, "$props">> & {
+                [name: string]: any;
+            };
+            "v-chip": VuetifyProps<Pick<VChip, "$props">> & {
+                [name: string]: any;
+            };
+            "v-data-table-server": VuetifyProps<Pick<VDataTableServer, "$props">> & {
+                [name: string]: any;
+            };
+            "v-data-table": VuetifyProps<Pick<VDataTable, "$props">> & {
+                [name: string]: any;
+            };
+            "v-data-table-row": VuetifyProps<Pick<VDataTableRow, "$props">> & {
+                [name: string]: any;
+            };
+            "v-data-table-rows": VuetifyProps<Pick<VDataTableRows, "$props">> & {
+                [name: string]: any;
+            };
+            "v-data-table-virtual": VuetifyProps<Pick<VDataTableVirtual, "$props">> & {
+                [name: string]: any;
+            };
+            "v-checkbox": VuetifyProps<Pick<VCheckbox, "$props">> & {
+                [name: string]: any;
+            };
+            "v-checkbox-btn": VuetifyProps<Pick<VCheckboxBtn, "$props">> & {
+                [name: string]: any;
+            };
+            "v-table": VuetifyProps<Pick<VTable, "$props">> & {
+                [name: string]: any;
+            };
+            "v-text-field": VuetifyProps<Pick<VTextField, "$props">> & {
+                [name: string]: any;
+            };
+            "v-menu": VuetifyProps<Pick<VMenu, "$props">> & {
+                [name: string]: any;
+            };
+            "v-virtual-scroll": VuetifyProps<Pick<VVirtualScroll, "$props">> & {
+                [name: string]: any;
+            };
+            "v-autocomplete": VuetifyProps<Pick<VAutocomplete, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panels": VuetifyProps<Pick<VExpansionPanels, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel": VuetifyProps<Pick<VExpansionPanel, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel-text": VuetifyProps<Pick<VExpansionPanelText, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel-title": VuetifyProps<Pick<VExpansionPanelTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card": VuetifyProps<Pick<VCard, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-actions": VuetifyProps<Pick<VCardActions, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-item": VuetifyProps<Pick<VCardItem, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-subtitle": VuetifyProps<Pick<VCardSubtitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-text": VuetifyProps<Pick<VCardText, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-title": VuetifyProps<Pick<VCardTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn": VuetifyProps<Pick<VBtn, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn-group": VuetifyProps<Pick<VBtnGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn-toggle": VuetifyProps<Pick<VBtnToggle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-navigation-drawer": VuetifyProps<Pick<VNavigationDrawer, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list": VuetifyProps<Pick<VList, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item": VuetifyProps<Pick<VListItem, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-group": VuetifyProps<Pick<VListGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-img": VuetifyProps<Pick<VListImg, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-action": VuetifyProps<Pick<VListItemAction, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-title": VuetifyProps<Pick<VListItemTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-subtitle": VuetifyProps<Pick<VListItemSubtitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-media": VuetifyProps<Pick<VListItemMedia, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-subheader": VuetifyProps<Pick<VListSubheader, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog": VuetifyProps<Pick<VDialog, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-bottom-transition": VuetifyProps<Pick<VDialogBottomTransition, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-top-transition": VuetifyProps<Pick<VDialogTopTransition, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-transition": VuetifyProps<Pick<VDialogTransition, "$props">> & {
+                [name: string]: any;
+            };
+        }
+    }
+}
+export {};

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

@@ -0,0 +1,112 @@
+import { Prop, PropType, VNodeChild } from "vue";
+export type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
+export type VModelKeyNameInJsxElement<N extends string> = N extends "" ? "v-model" : `v-model:${N}`;
+export type VModelEmitsInJsxElement<N extends string> = N extends "" ? "onUpdate:modelValue" : `onUpdate:${N}`;
+export type VModelKeyNameInProps<N extends string> = N extends "" ? "modelValue" : N;
+type BuildVModelName<TName extends string, TPropType, Required extends boolean = false> = {
+    [key in VModelEmitsInJsxElement<TName>]: {
+        type: PropType<(value: TPropType) => any | void>;
+    };
+} & {
+    [key in VModelKeyNameInJsxElement<TName>]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+} & {
+    [key in VModelKeyNameInProps<TName>]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+};
+export type KebabKeys<T> = {
+    [K in keyof T as K extends string ? Kebab<K> : never]: T[K];
+};
+export type Kebab<T extends string, A extends string = ""> = T extends `${infer F}${infer R}` ? Kebab<R, `${A}${F extends Lowercase<F> ? "" : "-"}${Lowercase<F>}`> : A;
+export type DefinePropRequire<TName extends string, TPropType, E> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+        required: true;
+    };
+} & {
+    defaultValue(value?: TPropType): Omit<DefinePropDefaultValue<TName, TPropType, E, true>, "require">;
+    doc$(description?: string): Omit<DefinePropRequire<TName, TPropType, E>, "doc$">;
+};
+export type DefinePropDefaultValue<TName extends string, TPropType, E, Required extends boolean = false> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+} & {
+    require(): Omit<DefinePropRequire<TName, TPropType, E>, "defaultValue">;
+    doc$(description?: string): Omit<DefinePropDefaultValue<TName, TPropType, E>, "doc$">;
+};
+export type DefinePropDoc<TName extends string, TPropType, E> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+    };
+} & {
+    require(): Omit<DefinePropRequire<TName, TPropType, E>, "defaultValue">;
+    defaultValue(value?: TPropType): Omit<DefinePropDefaultValue<TName, TPropType, E>, "require">;
+};
+export type DefinePropModelRequire<N extends string, TPropType, E> = E & BuildVModelName<N, TPropType, true> & {
+    defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<N, TPropType, E, true>, "require">;
+    doc$(description?: string): Omit<DefinePropModelRequire<N, TPropType, E>, "doc$">;
+};
+export type DefinePropModelDefaultValue<N extends string, TPropType, E, Required extends boolean = false> = E & BuildVModelName<N, TPropType, Required> & {
+    require(): Omit<DefinePropModelRequire<N, TPropType, E>, "defaultValue">;
+    doc$(description?: string): Omit<DefinePropModelDefaultValue<N, TPropType, E>, "doc$">;
+};
+export type DefinePropModelDoc<TName extends string, TPropType, E> = E & BuildVModelName<TName, TPropType> & {
+    require(): Omit<DefinePropModelRequire<TName, TPropType, E>, "defaultValue">;
+    defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<TName, TPropType, E>, "require">;
+};
+export type DefinePropModelSlots = {
+    slots<Slots>(): {
+        "v-slots": Prop<{
+            default?: Slot;
+        } & Slots>;
+        doc$(doc?: {
+            [K in keyof Slots]: string;
+        }): {
+            "v-slots": Prop<{
+                default?: Slot;
+            } & Slots>;
+        };
+    };
+    vModel<TPropType>(disableAutoEmit?: boolean): BuildVModelName<"", TPropType> & {
+        require(): DefinePropModelRequire<"", TPropType, {}>;
+        defaultValue(value?: TPropType): DefinePropModelDefaultValue<"", TPropType, {}>;
+        doc$(description?: string): DefinePropModelDoc<"", TPropType, {}>;
+    } & {
+        name<TName extends string>(n?: TName): BuildVModelName<TName, TPropType> & {
+            require(): DefinePropModelRequire<TName, TPropType, BuildVModelName<"", TPropType>>;
+            defaultValue(value?: TPropType): DefinePropModelDefaultValue<TName, TPropType, BuildVModelName<"", TPropType>>;
+            doc$(description?: string): DefinePropModelDoc<TName, TPropType, BuildVModelName<"", TPropType>>;
+        };
+    };
+    prop<TPropType>(): {
+        name<TName extends string>(n: TName): KebabKeys<{
+            [K in TName]: {
+                type: PropType<TPropType>;
+            };
+        }> & {
+            [K in TName]: {
+                type: PropType<TPropType>;
+            };
+        } & {
+            require(): DefinePropRequire<TName, TPropType, {}>;
+            defaultValue(value?: TPropType): DefinePropDefaultValue<TName, TPropType, {}>;
+            doc$(description?: string): DefinePropDoc<TName, TPropType, {}>;
+        };
+    };
+    emit<TEmitType>(): {
+        name<TName extends string>(n: TName): {
+            [K in TName]: TEmitType;
+        } & {
+            doc$(description?: string): {
+                [K in TName]: TEmitType;
+            };
+        };
+    };
+};
+export {};

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

@@ -26,15 +26,11 @@ export * from "./social";
 export * from "./sitelogoicon";
 export * from "./languagepicker";
 export * from "./permissioninput";
-export * from "./securitytrimer";
-export * from "./spacingpicker";
 export * from "./models";
 export * from "./wizard";
-export * from "./statusmessageoverlay";
 export * from "./multilingualinput";
 export * from "./texttranslator";
 export * from "./errormessage";
-export * from "./imagegrid";
 export * from "./timeperiodpicker";
 export * from "./theming";
 export * from "./theming-v2";
@@ -57,6 +53,8 @@ export * from "./filterengine";
 export * from "./use";
 export * from "./tag";
 export * from "./decorators";
+export * from "./docs";
+export * from "./statuscoderenderer";
 export * from "./VueWebComponentSlot";
 export * from "./TokenBasedRouter";
 export * from "./StyleFlow";
@@ -73,8 +71,11 @@ export * from "./AnchorLink";
 export * from "./LayoutFileContext";
 export * from "./AppRollupFilterEngineContext";
 export * from "./SidePanelContext";
+export * from "./ScrollHelper";
+export * from "./ListViewComponentBase";
 export { OmniaTheming } from "./OmniaTheming";
 export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } from "./directives";
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";
-export { VueComponentBase, definePropFunctionType, definePropObjectType, getVuetifyAppClasses, VueComponentConnect, defineVueComponent, } from "./VueComponentBase";
+export { VueComponentBase, getVuetifyAppClasses, VueComponentConnect, } from "./VueComponentBase";
 export type { VueComponentBaseProps, VueComponentBaseEvents, } from "./VueComponentBase";
+export { defineVueComponent, definePropFunctionType, definePropObjectType, defineVue, createVueNode, getElementName, isElement } from "./InternalDefineComponent";

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

@@ -0,0 +1,271 @@
+import { SubscriptionHandler } from "@omnia/fx";
+import { ComponentInjectOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentPropsOptions, ComputedOptions, CreateComponentPublicInstance, DefineComponent, EmitsOptions, ExtractDefaultPropTypes, ExtractPropTypes, MethodOptions, ObjectEmitsOptions, Prop, PropType, RenderFunction, Slot, SlotsType, VNode, VNodeArrayChildren, VNodeProps, VNodeTypes, computed, watch, watchEffect } from "vue";
+import { LooseRequired, Prettify, UnionToIntersection } from "@vue/shared";
+import { ComponentBundleManifest, GuidValue, ThemeableComponentProps } from "@omnia/fx-models";
+import { IValidatorBase } from "./models/Validation";
+import { useBlueprintSetup, useColorSchemaSetup } from "./use";
+export declare function definePropFunctionType<T>(): PropType<T>;
+export declare function definePropObjectType<T>(): PropType<T>;
+type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
+type RawProps = VNodeProps & {
+    __v_isVNode?: never;
+    [Symbol.iterator]?: never;
+} & Record<string, any>;
+type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [
+    {
+        type: null | true;
+    }
+] ? any : [T] extends [
+    ObjectConstructor | {
+        type: ObjectConstructor;
+    }
+] ? Record<string, any> : [T] extends [
+    BooleanConstructor | {
+        type: BooleanConstructor;
+    }
+] ? boolean : [T] extends [
+    DateConstructor | {
+        type: DateConstructor;
+    }
+] ? Date : [T] extends [
+    (infer U)[] | {
+        type: (infer U)[];
+    }
+] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+type RemoveDefinePropApi<T> = T extends string[] ? T : {
+    [K in keyof T as K extends "require" | "defaultValue" | "prop" | "vModel" | "slots" | "doc$" ? never : K]: T[K];
+};
+type ExcludeJsxPropKeys<T> = T extends string[] ? T : {
+    [K in keyof T as K extends `v-model${infer _}` | "v-slots" ? never : K]: T[K];
+};
+type ExtractPropModels<T> = {
+    -readonly [K in keyof T as K extends `v-model:${infer N}` ? N : K extends "v-model" ? "modelValue" : never]: T[K];
+};
+type ExtractPropSlots<T> = T extends {
+    "v-slots"?: any;
+} ? T["v-slots"] & {
+    default?: Slot;
+} : {
+    default?: Slot;
+};
+type RequiredKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type CustomExtractPropTypes<O> = {
+    [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>;
+} & {
+    [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>;
+};
+type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
+    [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
+} : T extends ObjectEmitsOptions ? {
+    [K in string & `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? T[Uncapitalize<C>] extends null ? (...args: any[]) => any : (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : never) => any : never;
+} : {};
+type TsxComponentV3<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PropsDefinition = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? CustomExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions>> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE> & {
+    propsDefinition: PropsDefinition extends {} ? Omit<PropsDefinition, keyof ({} extends E ? {} : EmitsToProps<E>)> & ({} extends E ? {} : EmitsToProps<E>) : never;
+};
+type ComponentOptionsWithObjectPropsCustom<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<ExtractPropTypes<PropsOptions>> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBaseExtends<RemoveDefinePropApi<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
+    props: PropsOptions & ThisType<void>;
+} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
+type ComponentOptionsWithoutProps<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, PE = Props & EmitsToProps<E>> = ComponentOptionsBaseExtends<PE, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
+    props?: undefined;
+} & ThisType<CreateComponentPublicInstance<PE, RawBindings, D, C, M, Mixin, Extends, E, PE, {}, false, I>>;
+type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<{
+    [key in PropNames]?: any;
+}> & EmitsToProps<E>> = ComponentOptionsBaseExtends<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
+    props: PropNames[];
+} & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
+type Data = Record<string, unknown>;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
+    [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
+}[Event]>;
+type OptionTypesKeys = "P" | "B" | "D" | "C" | "M" | "Defaults";
+type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
+    P: P;
+    B: B;
+    D: D;
+    C: C;
+    M: M;
+    Defaults: Defaults;
+};
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
+    Mixin: MixinToOptionTypes<T>;
+}[T extends ComponentOptionsMixin ? "Mixin" : never];
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
+type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
+type UseState = <T = any>(state?: T) => {
+    state: T;
+    setState(state: T): void;
+};
+type SetupContext<ExtractedPropsType, Props, E = EmitsOptions> = E extends any ? {
+    props: ExtractedPropsType;
+    attrs: Data;
+    slots: ExtractPropSlots<Props>;
+    models?: Required<ExtractPropModels<Props>>;
+    colors: ReturnType<typeof useColorSchemaSetup>;
+    blueprints: ReturnType<typeof useBlueprintSetup>;
+    validator: IValidatorBase;
+    emit: EmitFn<E>;
+    expose: (exposed?: Record<string, any>) => void;
+    useState: UseState;
+    computed: typeof computed;
+    watch: typeof watch;
+    watchEffect: typeof watchEffect;
+    subscriber: SubscriptionHandler;
+} : never;
+interface ComponentOptionsBaseExtends<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string> extends ComponentOptionsBase<ExcludeJsxPropKeys<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> {
+    setup?: (this: void, ctx: SetupContext<LooseRequired<ExcludeJsxPropKeys<Props> & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, "P">>>, Props, E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+}
+export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (ctx: SetupContext<Props, E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
+    props?: (keyof Props)[];
+    emits?: E | EE[];
+    slots?: S;
+}, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
+export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (ctx: SetupContext<Props, E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
+    props?: ComponentObjectPropsOptions<Props>;
+    emits?: E | EE[];
+    slots?: S;
+}, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
+export declare function defineVueComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<Props extends Object, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<ComponentObjectPropsOptions<Props>>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Readonly<{
+    [key in PropNames]?: any;
+}>, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Readonly<{
+    [key in PropNames]?: any;
+}>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<PropsOptions>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function internalDefineVueWebComponent(omniaServiceId: any, manifestId: any, options: any, extraOptions?: any, register?: (manifest: ComponentBundleManifest, component: any) => void): any;
+export declare function createPropType<T>(): PropType<T>;
+export declare function defineVue(): {
+    slots<Slots_1>(): {
+        "v-slots": Prop<{
+            default?: import("./DefineVueTypings").Slot<any[]>;
+        } & Slots_1>;
+        doc$(doc?: { [K in keyof Slots_1]: string; }): {
+            "v-slots": Prop<{
+                default?: import("./DefineVueTypings").Slot<any[]>;
+            } & Slots_1>;
+        };
+    };
+    vModel<TPropType>(disableAutoEmit?: boolean): {
+        "onUpdate:modelValue": {
+            type: PropType<(value: TPropType) => any>;
+        };
+    } & {
+        "v-model": {
+            type: PropType<TPropType>;
+            required: false;
+        };
+    } & {
+        modelValue: {
+            type: PropType<TPropType>;
+            required: false;
+        };
+    } & {
+        require(): import("./DefineVueTypings").DefinePropModelRequire<"", TPropType, {}>;
+        defaultValue(value?: TPropType): import("./DefineVueTypings").DefinePropModelDefaultValue<"", TPropType, {}, false>;
+        doc$(description?: string): import("./DefineVueTypings").DefinePropModelDoc<"", TPropType, {}>;
+    } & {
+        name<TName extends string>(n?: TName): { [key in import("./DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
+            type: PropType<(value: TPropType) => any>;
+        }; } & { [key_1 in import("./DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+            type: PropType<TPropType>;
+            required: false;
+        }; } & { [key_2 in import("./DefineVueTypings").VModelKeyNameInProps<TName>]: {
+            type: PropType<TPropType>;
+            required: false;
+        }; } & {
+            require(): import("./DefineVueTypings").DefinePropModelRequire<TName, TPropType, {
+                "onUpdate:modelValue": {
+                    type: PropType<(value: TPropType) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: TPropType): import("./DefineVueTypings").DefinePropModelDefaultValue<TName, TPropType, {
+                "onUpdate:modelValue": {
+                    type: PropType<(value: TPropType) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("./DefineVueTypings").DefinePropModelDoc<TName, TPropType, {
+                "onUpdate:modelValue": {
+                    type: PropType<(value: TPropType) => any>;
+                };
+            } & {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }>;
+        };
+    };
+    prop<TPropType_1>(): {
+        name<TName_1 extends string>(n: TName_1): import("./DefineVueTypings").KebabKeys<{ [K_1 in TName_1]: {
+            type: PropType<TPropType_1>;
+        }; }> & { [K_2 in TName_1]: {
+            type: PropType<TPropType_1>;
+        }; } & {
+            require(): import("./DefineVueTypings").DefinePropRequire<TName_1, TPropType_1, {}>;
+            defaultValue(value?: TPropType_1): import("./DefineVueTypings").DefinePropDefaultValue<TName_1, TPropType_1, {}, false>;
+            doc$(description?: string): import("./DefineVueTypings").DefinePropDoc<TName_1, TPropType_1, {}>;
+        };
+    };
+    emit<TEmitType>(): {
+        name<TName_2 extends string>(n: TName_2): { [K_3 in TName_2]: TEmitType; } & {
+            doc$(description?: string): { [K_4 in TName_2]: TEmitType; };
+        };
+    };
+    props: () => {
+        theming: ThemeableComponentProps;
+        class: {
+            class: {
+                type: PropType<String | String[]>;
+                required: boolean;
+            };
+        };
+    };
+};
+export declare function getElementName(componentManifestId: GuidValue): string;
+export declare function createVueNode(element: VNodeTypes | GuidValue, props?: RawProps, children?: RawChildren | RawSlots, onComponentMounted?: (instance: any) => void, onComponentCreated?: (instance: any) => void): VNode;
+export declare function isElement<TElement = typeof omfx>(element: string, cb: (elements: TElement) => any): boolean;
+declare global {
+    namespace JSX {
+        interface IntrinsicAttributes {
+            $children?: {};
+        }
+    }
+}
+export {};