@omnia/fx 8.0.91-vnext → 8.0.93-vnext

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

@@ -1,65 +1,109 @@
+import { VelcronAppDefinition } from "@omnia/fx/models";
 export declare const DialogSizeDefinitions: string[];
 export type DialogSize = typeof DialogSizeDefinitions[number];
 export interface DocumentationArea {
     name: string;
     icon: string;
 }
-export declare const DocumentCategoryTypesDefinitions: string[];
-export type DocumentCategoryTypes = typeof DocumentCategoryTypesDefinitions[number];
+export interface DocumentationCategory {
+    name: string;
+    sortOrder: number;
+}
+export interface PropertySpec {
+    name: string;
+    description: string;
+    type: string;
+    builtInType: boolean;
+    defaultValue: string;
+}
+export interface EventSpec {
+    name: string;
+    description: string;
+    type: string;
+}
+export interface SlotSpec {
+    name: string;
+    description: string;
+}
+export interface MarkdownSection {
+    title: string;
+    markdown: string;
+}
 export declare const builtInDocumeantionAreas: {
     oxide: DocumentationArea;
     omfx: DocumentationArea;
     velcron: DocumentationArea;
 };
+export declare const builtInDocumentationCategories: {
+    containment: DocumentationCategory;
+    dataAndDisplay: DocumentationCategory;
+    feedback: DocumentationCategory;
+    grid: DocumentationCategory;
+    inputsAndControls: DocumentationCategory;
+    imagesAndIcons: DocumentationCategory;
+    navigation: DocumentationCategory;
+    pickers: DocumentationCategory;
+};
+export declare const velcronDocumentationCategories: {
+    gettingStarted: DocumentationCategory;
+    components: DocumentationCategory;
+};
 export interface ComponentSpecRegistration {
-    spec: ComponentSpec;
-    category: DocumentCategoryTypes;
+    spec: DocumentationSpec;
+    category: DocumentationCategory;
     area: DocumentationArea;
 }
 export declare class Docs {
     static registrations: Map<string, Array<ComponentSpecRegistration>>;
     static areas: Array<DocumentationArea>;
+    static categories: Array<DocumentationCategory>;
     static addArea(area: DocumentationArea): void;
-    static specBuilder(name: string): ComponentSpec;
+    static addCategory(category: DocumentationCategory): void;
+    static specBuilder(name: string): DocumentationSpec;
     static velcronSpecBuilder(name: string): VelcronComponentSpec;
-    static registerComponent(spec: ComponentSpec, area: DocumentationArea, category: DocumentCategoryTypes): void;
+    static registerComponent(spec: DocumentationSpec, area: DocumentationArea, category: DocumentationCategory): void;
 }
 interface TypeValueMapping {
     name: string;
     value: string;
 }
-interface ExampleComponentSpec {
+export interface ExampleComponentSpec {
     title: string;
     description: string;
     relativeUrl: string;
     component: any;
 }
-interface VelcronExampleComponentSpec {
+export interface VelcronExampleDefinitionSpec {
     title: string;
     description: string;
-    component: any;
+    definition: VelcronAppDefinition;
 }
-export declare class ComponentSpec {
+export declare class DocumentationSpec {
     private name;
     private typeValueMapping;
     private exampleComponents;
-    private introComponents;
+    markdownSections: Array<MarkdownSection>;
     themingSupport: boolean;
     toneSupport: boolean;
     cssClassSupport: boolean;
+    properties: PropertySpec[];
+    events: EventSpec[];
+    slots: SlotSpec[];
     constructor(name: string);
-    addTypeValueMapping(name: string, value: string | string[] | any): ComponentSpec;
-    addTheming(): ComponentSpec;
-    addToned(): ComponentSpec;
-    addCssClass(): ComponentSpec;
-    build(): ComponentSpec;
+    addTypeValueMapping(name: string, value: string | string[] | any): DocumentationSpec;
+    addTheming(): DocumentationSpec;
+    addToned(): DocumentationSpec;
+    addCssClass(): DocumentationSpec;
     getName(): string;
-    addExampleComponent(component: ExampleComponentSpec): ComponentSpec;
-    addExampleComponents(components: Array<ExampleComponentSpec>): ComponentSpec;
-    addIntroComponent(component: any): ComponentSpec;
+    addApiProperty(propertySpec: PropertySpec): DocumentationSpec;
+    addApiProperty(name: string, description: string, type: string, defaultValue?: string): DocumentationSpec;
+    addApiEvent(propertySpec: EventSpec): DocumentationSpec;
+    addApiEvent(name: string, description: string, type: string): DocumentationSpec;
+    addExampleComponent(component: ExampleComponentSpec | VelcronExampleDefinitionSpec): DocumentationSpec;
+    addExampleComponents(components: Array<ExampleComponentSpec | VelcronExampleDefinitionSpec>): DocumentationSpec;
     getTypeValueMapping(name: string): TypeValueMapping;
-    getExampleComponents(): ExampleComponentSpec[];
-    getIntroComponents(): any[];
+    getExampleComponents(): Array<ExampleComponentSpec | VelcronExampleDefinitionSpec>;
+    addMarkdownSection(title: string, markdown: string): DocumentationSpec;
 }
 export declare class VelcronComponentSpec {
     private name;
@@ -75,11 +119,11 @@ export declare class VelcronComponentSpec {
     addToned(): VelcronComponentSpec;
     addCssClass(): VelcronComponentSpec;
     getName(): string;
-    addExampleComponent(component: VelcronExampleComponentSpec): VelcronComponentSpec;
-    addExampleComponents(components: Array<VelcronExampleComponentSpec>): VelcronComponentSpec;
+    addExampleComponent(component: VelcronExampleDefinitionSpec): VelcronComponentSpec;
+    addExampleComponents(components: Array<VelcronExampleDefinitionSpec>): VelcronComponentSpec;
     addIntroComponent(component: any): VelcronComponentSpec;
     getTypeValueMapping(name: string): TypeValueMapping;
-    getExampleComponents(): VelcronExampleComponentSpec[];
+    getExampleComponents(): VelcronExampleDefinitionSpec[];
     getIntroComponents(): any[];
 }
 export {};

package/internal-do-not-import-from-here/ux/docs/chrome/VelcronSampleViewer.css.d.ts

@@ -0,0 +1,9 @@
+export declare const VelcronSampleViewer: {
+    container: (dark: boolean) => string;
+    expansionPanel: (dark: boolean) => string;
+    codePreviewWrapper: (dark: boolean) => string;
+    buttonWrapper: string;
+    componentSamplesWrapper: string;
+    codePanelWrapper: string;
+    codeViewWrapper: string;
+};

package/internal-do-not-import-from-here/ux/docs/chrome/VelcronSampleViewer.d.ts

@@ -0,0 +1,217 @@
+import { VelcronAppDefinition } from "@omnia/fx-models";
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly title?: string;
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            readonly definition?: VelcronAppDefinition<object>;
+            readonly props?: {
+                theming: import("@omnia/fx-models").ThemeableComponentProps;
+                class: {
+                    class: {
+                        type: import("vue").PropType<String | String[]>;
+                        required: boolean;
+                    };
+                };
+            };
+            readonly emit?: {
+                name<TName extends string>(n: TName): { [K in TName]: unknown; } & {
+                    doc$(description?: string): { [K_1 in TName]: unknown; };
+                };
+            };
+            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)[];
+            readonly description?: string;
+        };
+        $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<import("vue").ExtractPropTypes<{
+            definition: {
+                type: import("vue").PropType<VelcronAppDefinition<object>>;
+            } & {
+                type: import("vue").PropType<VelcronAppDefinition<object>>;
+            };
+            title: {
+                type: import("vue").PropType<string>;
+            } & {
+                type: import("vue").PropType<string>;
+            };
+            description: {
+                type: import("vue").PropType<string>;
+            } & {
+                type: import("vue").PropType<string>;
+            };
+            emit: <TEmitType>() => {
+                name<TName_1 extends string>(n: TName_1): { [K_2 in TName_1]: TEmitType; } & {
+                    doc$(description?: string): { [K_3 in TName_1]: TEmitType; };
+                };
+            };
+            props: () => {
+                theming: import("@omnia/fx-models").ThemeableComponentProps;
+                class: {
+                    class: {
+                        type: import("vue").PropType<String | String[]>;
+                        required: boolean;
+                    };
+                };
+            };
+        }>>, () => 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<import("vue").ExtractPropTypes<{
+        definition: {
+            type: import("vue").PropType<VelcronAppDefinition<object>>;
+        } & {
+            type: import("vue").PropType<VelcronAppDefinition<object>>;
+        };
+        title: {
+            type: import("vue").PropType<string>;
+        } & {
+            type: import("vue").PropType<string>;
+        };
+        description: {
+            type: import("vue").PropType<string>;
+        } & {
+            type: import("vue").PropType<string>;
+        };
+        emit: <TEmitType>() => {
+            name<TName_1 extends string>(n: TName_1): { [K_2 in TName_1]: TEmitType; } & {
+                doc$(description?: string): { [K_3 in TName_1]: TEmitType; };
+            };
+        };
+        props: () => {
+            theming: import("@omnia/fx-models").ThemeableComponentProps;
+            class: {
+                class: {
+                    type: import("vue").PropType<String | String[]>;
+                    required: boolean;
+                };
+            };
+        };
+    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    definition: {
+        type: import("vue").PropType<VelcronAppDefinition<object>>;
+    } & {
+        type: import("vue").PropType<VelcronAppDefinition<object>>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    } & {
+        type: import("vue").PropType<string>;
+    };
+    description: {
+        type: import("vue").PropType<string>;
+    } & {
+        type: import("vue").PropType<string>;
+    };
+    emit: <TEmitType>() => {
+        name<TName_1 extends string>(n: TName_1): { [K_2 in TName_1]: TEmitType; } & {
+            doc$(description?: string): { [K_3 in TName_1]: TEmitType; };
+        };
+    };
+    props: () => {
+        theming: import("@omnia/fx-models").ThemeableComponentProps;
+        class: {
+            class: {
+                type: import("vue").PropType<String | String[]>;
+                required: boolean;
+            };
+        };
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        title?: string;
+        definition?: VelcronAppDefinition<object>;
+        props?: {
+            theming: import("@omnia/fx-models").ThemeableComponentProps;
+            class: {
+                class: {
+                    type: import("vue").PropType<String | String[]>;
+                    required: boolean;
+                };
+            };
+        };
+        emit?: {
+            name<TName extends string>(n: TName): { [K in TName]: unknown; } & {
+                doc$(description?: string): { [K_1 in TName]: unknown; };
+            };
+        };
+        description?: string;
+    }>, never>;
+};
+export default _default;

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

@@ -1 +1 @@
-export declare const allSpecs: import("./Docs").ComponentSpec[];
+export declare const allSpecs: import("./Docs").DocumentationSpec[];

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

@@ -49,8 +49,8 @@ declare const _default: {
                 [key: string]: any;
             }>) => void)[];
             readonly settings?: FilterEngineSettings;
-            readonly context?: FilterEngineContext;
             readonly updateSettings?: () => void;
+            readonly context?: FilterEngineContext;
         };
         $attrs: {
             [x: string]: unknown;
@@ -104,8 +104,8 @@ declare const _default: {
 }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
         settings?: FilterEngineSettings;
-        context?: FilterEngineContext;
         updateSettings?: () => void;
+        context?: FilterEngineContext;
     }>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/filterpicker/docs/ExampleComponents.d.ts

@@ -1 +1 @@
-export declare const ExampleComponents: import("@omnia/fx/ux").ComponentSpec;
+export declare const ExampleComponents: import("@omnia/fx/ux").DocumentationSpec;

package/internal-do-not-import-from-here/ux/filterpicker/docs/index.d.ts

@@ -1 +1 @@
-export declare const spec: import("@omnia/fx/ux").ComponentSpec;
+export declare const spec: import("@omnia/fx/ux").DocumentationSpec;

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

@@ -64,11 +64,11 @@ declare const _default: {
             readonly hideUserTypeSelection?: Boolean;
             readonly hideDynamicGroupSelection?: Boolean;
             onDoc$?: (description?: string) => any;
+            onRemove?: (identity: Identity) => any;
             readonly attachToParent?: boolean;
             readonly showSelectedIdentities?: Boolean;
             readonly hideIdentityType?: Boolean;
             onAdd?: (identity: Identity) => any;
-            onRemove?: (identity: Identity) => any;
         };
         $attrs: {
             [x: string]: unknown;
@@ -157,8 +157,8 @@ declare const _default: {
             };
         }>> & {
             onDoc$?: (description?: string) => any;
-            onAdd?: (identity: Identity) => any;
             onRemove?: (identity: Identity) => any;
+            onAdd?: (identity: Identity) => any;
         }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
             remove: (identity: Identity) => void;
             doc$(description?: string): {
@@ -259,8 +259,8 @@ declare const _default: {
         };
     }>> & {
         onDoc$?: (description?: string) => any;
-        onAdd?: (identity: Identity) => any;
         onRemove?: (identity: Identity) => any;
+        onAdd?: (identity: Identity) => any;
     } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
@@ -339,8 +339,8 @@ declare const _default: {
     };
 }>> & {
     onDoc$?: (description?: string) => any;
-    onAdd?: (identity: Identity) => any;
     onRemove?: (identity: Identity) => any;
+    onAdd?: (identity: Identity) => any;
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     remove: (identity: Identity) => void;
     doc$(description?: string): {
@@ -367,10 +367,10 @@ declare const _default: {
         attachToParent?: boolean;
         showSelectedIdentities?: Boolean;
         hideIdentityType?: Boolean;
-    }>, "onDoc$" | "onAdd" | "onRemove"> & {
+    }>, "onDoc$" | "onRemove" | "onAdd"> & {
         onDoc$?: (description?: string) => any;
-        onAdd?: (identity: Identity) => any;
         onRemove?: (identity: Identity) => any;
+        onAdd?: (identity: Identity) => any;
     };
 };
 export default _default;