@omnia/fx 7.0.462-dev → 7.0.464-dev

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

@@ -1,5 +1,5 @@
 import { IExtend, LoadableBundleManifest, GuidValue, IExtendApiManifest, IExtendApiManifestWithConfiguration, ApiPath, Future } from "../models";
-export declare type ExtendApiConfigurationManifest<T> = {
+export type ExtendApiConfigurationManifest<T> = {
     configuration: T;
     manifest: LoadableBundleManifest;
 };

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

@@ -10,7 +10,7 @@
  * Inject<HttpClientConstructor>(HttpClient,{someConstructorArg1:"",someConstructorArg2})
  */
 export declare function Inject<T>(classType: any, constructorArgs?: T): any;
-declare type Class<T> = {
+type Class<T> = {
     new (...args: any[]): T;
 };
 /**

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

@@ -1,4 +1,4 @@
-declare type Class = {
+type Class = {
     new (...args: any[]): any;
 };
 interface MockInstance {

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

@@ -1,5 +1,5 @@
-export declare type PropPathCheckTargetType<T, Path extends string, TargetType> = string extends Path ? never : Path extends keyof T ? (T[Path] extends TargetType ? `${Path}` : never) : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropStartPathCheckTargetType<T[K], R, Path, TargetType> : never : never;
-declare type PropStartPathCheckTargetType<T, Path extends string, StartPath extends string, TargetType> = string extends Path ? never : Path extends keyof T ? (T[Path] extends TargetType ? `${StartPath}` : never) : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropStartPathCheckTargetType<T[K], R, Path, TargetType> : never : never;
+export type PropPathCheckTargetType<T, Path extends string, TargetType> = string extends Path ? never : Path extends keyof T ? (T[Path] extends TargetType ? `${Path}` : never) : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropStartPathCheckTargetType<T[K], R, Path, TargetType> : never : never;
+type PropStartPathCheckTargetType<T, Path extends string, StartPath extends string, TargetType> = string extends Path ? never : Path extends keyof T ? (T[Path] extends TargetType ? `${StartPath}` : never) : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropStartPathCheckTargetType<T[K], R, Path, TargetType> : never : never;
 /**
  * Returns the property path as string if valid for type, else compile error (Argument of type string is not assignable to never).
  *

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

@@ -1,5 +1,5 @@
 import { PropPathCheckTargetType } from "./propertyPath";
-export declare type PropPathType<T, Path extends string> = string extends Path ? never : Path extends keyof T ? T[Path] : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropPathType<T[K], R> : never : never;
+export type PropPathType<T, Path extends string> = string extends Path ? never : Path extends keyof T ? T[Path] : Path extends `${infer K}.${infer R}` ? K extends keyof T ? PropPathType<T[K], R> : never : never;
 /**
  * Get a value from a property path and preserv type of the target on that path
  *

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

@@ -1,5 +1,5 @@
 import { microsoftTeams } from "./MicrosoftTeams.d";
-export declare type MicrosoftTeams = typeof microsoftTeams;
+export type MicrosoftTeams = typeof microsoftTeams;
 export declare module MicrosoftTeamsSdkLoader {
     function getApi(): Promise<MicrosoftTeams>;
     function runningInMicrosoftTeams(): boolean;

package/internal-do-not-import-from-here/shared/http/Bring.d.ts

@@ -1,30 +1,109 @@
-import { BringConfig, BringResponse, Future } from "../models";
+import { BringConfig, BringCredentials, BringResponse, Future } from "../models";
+export declare class BringBuilder {
+    protected config?: BringConfig;
+    private _bring;
+    constructor(config?: BringConfig);
+    /**
+     * The base url for the client e.g. https://api.com
+     *
+     * @param {string} baseUrl
+     * @return {*}  {BringBuilder}
+     * @memberof BringBuilder
+     */
+    withBaseUrl(baseUrl: string): BringBuilder;
+    /**
+     * If headers should be included in the request
+     *
+     * @param {{ [name: string]: string }} headers
+     * @return {*}  {BringBuilder}
+     * @memberof BringBuilder
+     */
+    withHeaders(headers: {
+        [name: string]: string;
+    }): BringBuilder;
+    /**
+     * If credential options should be included in the request, Default is "include" for this method
+     *
+     * @param {BringCredentials} [credentials]
+     * @return {*}  {BringBuilder}
+     * @memberof BringBuilder
+     */
+    withCredentials(credentials?: BringCredentials): BringBuilder;
+    build(): Bring;
+}
 export declare class Bring {
-    protected config?: BringConfig | Future<BringConfig> | Promise<BringConfig>;
+    _baseConfig: BringConfig | Future<BringConfig> | Promise<BringConfig>;
+    /**
+     * Create a new instance of Bring
+     * @static
+     * @param {(BringConfig | Future<BringConfig> | Promise<BringConfig>)} [config]
+     * @return {*}  {Bring}
+     * @memberof Bring
+     */
+    static new(config?: BringConfig): BringBuilder;
     constructor(config?: BringConfig | Future<BringConfig> | Promise<BringConfig>);
     /**
-    * Performs a GET request for provided url
-    */
+     *Performs a GET request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     get<TReturnType>(url: string, config?: BringConfig): Future<BringResponse<TReturnType>>;
     /**
-    * Performs a DELETE request for provided url
-    */
+     * Performs a DELETE request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     delete<TReturnType>(url: string, config?: BringConfig): Future<BringResponse<TReturnType>>;
     /**
-    * Performs a HEAD request for provided url
-    */
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     head<TReturnType>(url: string, config?: BringConfig): Future<BringResponse<TReturnType>>;
     /**
-    * Performs a POST request for provided url
-    */
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     post<TReturnType>(url: string, body: Object, config?: BringConfig): Future<BringResponse<TReturnType>>;
     /**
-    * Performs a POST request for provided url
-    */
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     put<TReturnType>(url: string, body: Object, config?: BringConfig): Future<BringResponse<TReturnType>>;
     /**
-    * Performs a POST request for provided url
-    */
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {BringConfig} [config]
+     * @return {*}  {Future<BringResponse<TReturnType>>}
+     * @memberof Bring
+     */
     patch<TReturnType>(url: string, body: Object, config?: BringConfig): Future<BringResponse<TReturnType>>;
     private createRequest;
 }

package/internal-do-not-import-from-here/shared/models/Bring.d.ts

@@ -1,6 +1,6 @@
-export declare type BringMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-export declare type BringCacheOptions = "no-cache" | "reload" | "force-cache" | "only-if-cached";
-export declare type BringCredentials = "include" | "omit" | "same-origin";
+export type BringMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export type BringCacheOptions = "no-cache" | "reload" | "force-cache" | "only-if-cached";
+export type BringCredentials = "include" | "omit" | "same-origin";
 export interface BringInterceptOptions {
     beforeRequest?: (request: BringConfig) => BringConfig;
     afterRequest?: <T>(response: BringResponse<T>, request: BringConfig) => BringResponse<T>;

package/internal-do-not-import-from-here/shared/models/Future.d.ts

@@ -6,6 +6,21 @@ export declare class Future<T> extends Promise<T> {
     private _rejected;
     private onAborted;
     constructor(executor: (resolve: (value: T) => void, reject: (reason?: any) => void, onAborted: (cb: (reason?: any) => void) => void) => void);
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    tryCatch(): Future<[success: T, error: Error]>;
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
     abort(reason?: any): void;
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises

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

@@ -33,6 +33,32 @@ class Future extends Promise {
             executor(this.resolve, this.reject, onAborted);
         }
     }
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    //tryCatch(): Future<{ success?: T, error?: Error; }> {
+    tryCatch() {
+        return new Future(async (resolve) => {
+            try {
+                const data = await this;
+                resolve([data, undefined]);
+            }
+            catch (err) {
+                resolve([undefined, err]);
+            }
+        });
+    }
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
     abort(reason) {
         if (this.onAborted) {
             this.onAborted(reason);

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

@@ -8,21 +8,6 @@ exports.Guid = void 0;
  * Class to create a guid
  */
 class Guid {
-    constructor(guid) {
-        this.value = Guid._empty;
-        //We serialize as string value
-        this.toJSON = () => {
-            return this.value.toLowerCase();
-        };
-        if (guid) {
-            if (Guid.isValid(guid)) {
-                this.value = guid;
-            }
-            else {
-                throw `The string '${guid}' is not a valid Guid`;
-            }
-        }
-    }
     static newGuid() {
         return new Guid("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
             const r = Math.random() * 16 | 0;
@@ -40,6 +25,21 @@ class Guid {
         const validRegex = /^[{]?[0-9a-fA-F]{8}[-]?([0-9a-fA-F]{4}[-]?){3}[0-9a-fA-F]{12}[}]?$/;
         return validRegex.test(guid.toString());
     }
+    constructor(guid) {
+        this.value = Guid._empty;
+        //We serialize as string value
+        this.toJSON = () => {
+            return this.value.toLowerCase();
+        };
+        if (guid) {
+            if (Guid.isValid(guid)) {
+                this.value = guid;
+            }
+            else {
+                throw `The string '${guid}' is not a valid Guid`;
+            }
+        }
+    }
     toString() {
         return this.value.toLowerCase();
     }

package/internal-do-not-import-from-here/shared/models/Realtime.d.ts

@@ -26,7 +26,7 @@ export declare class PageChatRealtimeData extends RealtimeData<BusinuessProfileC
     constructor(channel: BusinuessProfileChannel);
     getId(): GuidValue;
 }
-export declare type RealtimeChannelUpdateTypes = "activate" | "deactivate";
+export type RealtimeChannelUpdateTypes = "activate" | "deactivate";
 export interface RealtimeChannelUpdateMessage extends RealtimChannelMessage {
     threadId: GuidValue;
     type: RealtimeChannelUpdateTypes;

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

@@ -16,16 +16,16 @@ class BusinuessProfileChannel extends RealtimeChannel {
 }
 exports.BusinuessProfileChannel = BusinuessProfileChannel;
 class RealtimeData {
-    constructor(channel, value) {
-        this._channel = channel;
-        this._value = value;
-    }
     get channel() {
         return this._channel;
     }
     get value() {
         return this._value;
     }
+    constructor(channel, value) {
+        this._channel = channel;
+        this._value = value;
+    }
 }
 exports.RealtimeData = RealtimeData;
 //FIXME: This is a test implementation remove when tested

package/internal-do-not-import-from-here/spfx/components/OmniaWPContainer.d.ts

@@ -1,6 +1,6 @@
 import { SettingsService } from "../../../fx/services";
 import { VueComponentBase, BlockCatalogStore } from "../../ux";
-export declare type WebComponentDefinition = {
+export type WebComponentDefinition = {
     id: string;
     name: string;
     icon?: {

package/internal-do-not-import-from-here/spfx/messagebus/internal/InternalTopics.d.ts

@@ -3,7 +3,7 @@ export declare enum SpfxSettingsActionType {
     Get = 0,
     Set = 1
 }
-export declare type SpfxWebPartSettingMsg = {
+export type SpfxWebPartSettingMsg = {
     action: SpfxSettingsActionType;
     callBack: (value?: any) => void;
     value?: any;

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

@@ -3,7 +3,7 @@ import { ServiceContainerContext } from "../core";
 import { EnterpriseGlossary, EnterpriseGlossaryBase, EnterpriseGlossaryInstance, IEnterpriseGlossaryInformationSourceReadonly, EnterpriseGlossaryInformationSourceSettings, EnterpriseGlossaryMapping, EnterpriseGlossaryMappingData, EnterpriseGlossaryMappingId } from "../models";
 import { EnterpriseGlossaryService } from "../services/EnterpriseGlossaryService";
 import { Store } from "./Store";
-declare type TriggeredEnterpriseGlossaryInformation<TInformationSource extends Object = Object, TInformationSourceSettings extends EnterpriseGlossaryInformationSourceSettings = EnterpriseGlossaryInformationSourceSettings> = {
+type TriggeredEnterpriseGlossaryInformation<TInformationSource extends Object = Object, TInformationSourceSettings extends EnterpriseGlossaryInformationSourceSettings = EnterpriseGlossaryInformationSourceSettings> = {
     sourceInformation: IEnterpriseGlossaryInformationSourceReadonly<TInformationSource>;
     providerInformationSourceSettings: TInformationSourceSettings;
 };

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

@@ -19,10 +19,10 @@ export interface StateMutationLog {
 export interface StateActionLog {
     func: any;
 }
-declare type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
-declare type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
-declare type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
-declare type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
+type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
+type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
+type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
+type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
 export declare class StoreLogger {
     private _logState;
     enabled: boolean;

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

@@ -5,7 +5,7 @@ import { RecordPropsDefinition } from "vue/types/options";
 import { PropsForOutside, RequiredPropNames, _TsxComponentInstanceV3, _TsxComponentV3 } from "vue-tsx-support/lib/api";
 import { InnerScopedSlots } from "vue-tsx-support";
 import { TsxComponentTypeInfo } from "vue-tsx-support/types/base";
-export declare type SetupContextExtend<PrefixedEvents = unknown, ScopedSlots = unknown, On = unknown> = SetupContext & {
+export type SetupContextExtend<PrefixedEvents = unknown, ScopedSlots = unknown, On = unknown> = SetupContext & {
     slots: InnerScopedSlots<ScopedSlots>;
     _tsx?: TsxComponentTypeInfo<{}, {}, PrefixedEvents, On>;
     refs: {
@@ -13,16 +13,16 @@ export declare type SetupContextExtend<PrefixedEvents = unknown, ScopedSlots = u
     };
     readonly parent: Vue | null;
 };
-export declare type CompositionComponentOptions<Props, PropsDef extends RecordPropsDefinition<Props>, PrefixedEvents, ScopedSlots, On> = {
+export type CompositionComponentOptions<Props, PropsDef extends RecordPropsDefinition<Props>, PrefixedEvents, ScopedSlots, On> = {
     props?: PropsDef & RecordPropsDefinition<Props>;
     setup: (this: void, props: Props, ctx: SetupContextExtend<PrefixedEvents, ScopedSlots, On>) => () => VNode | JSX.Element;
 } & Pick<ComponentOptions<Vue>, "name" | "components" | "inheritAttrs" | "directives" | "filters">;
-export declare type CompositionComponentOptionsWithRender<Props, PropsDef extends RecordPropsDefinition<Props>, PrefixedEvents, ScopedSlots, On, RawBinding> = {
+export type CompositionComponentOptionsWithRender<Props, PropsDef extends RecordPropsDefinition<Props>, PrefixedEvents, ScopedSlots, On, RawBinding> = {
     props?: PropsDef & RecordPropsDefinition<Props>;
     setup: (this: void, props: Props, ctx: SetupContextExtend<PrefixedEvents, ScopedSlots, On>) => RawBinding;
     render(): VNode | JSX.Element;
 } & Pick<ComponentOptions<Vue>, "name" | "components" | "inheritAttrs" | "directives" | "filters"> & ThisType<ComponentPublicInstance<Props, RawBinding>>;
-declare type _OmniaTsxComponentV3<V extends Vue, Attributes, Props, PrefixedEvents, On, ScopedSlotArgs> = VueConstructor<_TsxComponentInstanceV3<V, Attributes, Props, PrefixedEvents, On, ScopedSlotArgs>> & {
+type _OmniaTsxComponentV3<V extends Vue, Attributes, Props, PrefixedEvents, On, ScopedSlotArgs> = VueConstructor<_TsxComponentInstanceV3<V, Attributes, Props, PrefixedEvents, On, ScopedSlotArgs>> & {
     propsDefinition: Props;
 };
 export declare function defineVueWebComponent<Props, PropsDef extends RecordPropsDefinition<Props> = RecordPropsDefinition<Props>, PrefixedEvents = any, ScopedSlots = any, On = any, RawBinding = any, RequiredProps extends keyof Props = RequiredPropNames<PropsDef> & keyof Props>(options: CompositionComponentOptions<Props, PropsDef, PrefixedEvents, ScopedSlots, On> | CompositionComponentOptionsWithRender<Props, PropsDef, PrefixedEvents, ScopedSlots, On, RawBinding>, register?: (manifest: WebComponentBundleManifest, component: _TsxComponentV3<Vue, {}, PropsForOutside<Props, RequiredProps>, PrefixedEvents, On, ScopedSlots>) => void): _OmniaTsxComponentV3<Vue, {}, PropsForOutside<Props, RequiredProps>, PrefixedEvents, On, ScopedSlots> | _OmniaTsxComponentV3<Vue & ShallowUnwrapRef<RawBinding>, {}, PropsForOutside<Props, RequiredProps>, PrefixedEvents, On, ScopedSlots>;

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

@@ -1,11 +1,11 @@
 import { types } from "typestyle";
 import { NestedCSSPropertiesExtends } from "@omnia/fx/models";
-declare type CSSClassNames<T extends string> = {
+type CSSClassNames<T extends string> = {
     [P in T]?: string | any;
 };
-declare type CSSClasses<K extends keyof any> = CustomRecord<K, types.NestedCSSProperties>;
-declare type CSSClassesExtends<K extends string> = CustomRecord<K, NestedCSSPropertiesExtends>;
-declare type CustomRecord<K extends keyof any, T> = {
+type CSSClasses<K extends keyof any> = CustomRecord<K, types.NestedCSSProperties>;
+type CSSClassesExtends<K extends string> = CustomRecord<K, NestedCSSPropertiesExtends>;
+type CustomRecord<K extends keyof any, T> = {
     [P in K]?: T | ((...args: any[]) => T);
 };
 export declare module StyleFlow {
@@ -17,129 +17,19 @@ export declare module StyleFlow {
      */
     export function stylesheet(selector: string, ...objects: types.NestedCSSProperties[]): void;
     module InternalStyleFlow {
-        const cssClassesName = "__$cssClasses";
-        const debugName = "__$debugName";
-        function define<Names extends string = any, TCSSClasses extends CSSClasses<Names> = any>(target: TCSSClasses, classes?: TCSSClasses, prefixClassName?: string): TCSSClasses {
-            target = target || {} as any;
-            if (classes) {
-                const classNames = Object.getOwnPropertyNames(classes) as (Names)[];
-                for (const className of classNames) {
-                    const classDef = classes[className];
-                    if (classDef) {
-                        target[className] = target[className] || classDef;
-                        if (Utils.isFunction(target[className])) {
-                            target[className] = classDef;
-                        }
-                        else {
-                            target[className] = Object.assign({}, target[className], classDef);
-                        }
-                    }
-                }
-            }
-            if (prefixClassName) {
-                target[debugName] = prefixClassName;
-            }
-            target[cssClassesName] = buildCssClasses(target);
-            return target;
-        }
-        function override<T>(target: T) {
-            return new StyleOverride<T>(target);
-        }
-        function use<Names extends string = any>(target: CSSClassesExtends<Names>, ...mergeCSSClasses: Array<CSSClassesExtends<Names>>): CSSClassNames<Names> {
-            if (mergeCSSClasses) {
-                const mergeObject = Object.assign({}, ...mergeCSSClasses);
-                const classNames = Object.getOwnPropertyNames(mergeObject as any) as (Names)[];
-                const cloneObject = Object.assign({}, target || {}) as any;
-                for (const className of classNames) {
-                    const classDef = mergeObject[className];
-                    if (classDef) {
-                        if (classDef["$clear"] || Utils.isFunction(classDef)) {
-                            cloneObject[className] = classDef;
-                        }
-                        else {
-                            cloneObject[className] = Object.assign({}, cloneObject[className] || {}, classDef);
-                        }
-                    }
-                }
-                return buildCssClasses(cloneObject);
-            }
-            if (!target[cssClassesName]) {
-                target[cssClassesName] = buildCssClasses(target);
-            }
-            return target[cssClassesName];
-        }
-        function stylesheet(selector: string, ...objects: types.NestedCSSProperties[]) {
-            cssRule(selector, ...objects);
-        }
-        function buildCssClasses<T, K extends keyof T>(source: T): CSSClassNames<Extract<keyof T, string>> {
-            const result = {};
-            const classNames = Object.getOwnPropertyNames(source);
-            for (const className of classNames) {
-                Object.defineProperty(result, className, {
-                    get: function () {
-                        if (Utils.isFunction(source[className])) {
-                            return (...args) => {
-                                return mergeCssClasses(source, className, args);
-                            };
-                        }
-                        const cssClassName = `__$class__${className}`;
-                        if (!this[cssClassName]) {
-                            this[cssClassName] = mergeCssClasses(source, className);
-                        }
-                        return this[cssClassName];
-                    },
-                    enumerable: true,
-                    configurable: true
-                });
-            }
-            return result as CSSClassNames<Extract<keyof T, string>>;
-        }
-        function mergeCssClasses(source, propName: string, args?) {
-            const isFunction = Utils.isFunction(source[propName]);
-            const overrideName = getOverrideName(propName);
-            let classDef: NestedCSSPropertiesExtends = {};
-            let definitions = [{ weight: -1, classDef: source[propName] }] as Array<OverrideCSSProperties<any>>;
-            if (source[overrideName]) {
-                definitions = (source[overrideName] as Array<OverrideCSSProperties<any>>).concat(definitions);
-            }
-            definitions.forEach(def => {
-                classDef = Object.assign({}, Utils.isFunction(def.classDef) ? def.classDef(...args) : def.classDef || {}, classDef);
-                if (classDef.$clear) {
-                    return;
-                }
-            });
-            delete classDef["$clear"];
-            return source[debugName]
-                ? style(Object.assign({ $debugName: `${source[debugName]}-${propName}`.toLowerCase() }, classDef))
-                : style(classDef);
-        }
-        function getOverrideName(propName: string) {
-            return `${propName}__$overrides`;
-        }
+        function define<Names extends string = any, TCSSClasses extends CSSClasses<Names> = any>(target: TCSSClasses, classes?: TCSSClasses, prefixClassName?: string): TCSSClasses;
+        function override<T>(target: T): StyleOverride<T>;
+        function use<Names extends string = any>(target: CSSClassesExtends<Names>, ...mergeCSSClasses: Array<CSSClassesExtends<Names>>): CSSClassNames<Names>;
+        function stylesheet(selector: string, ...objects: types.NestedCSSProperties[]): void;
         class StyleOverride<T> {
-            constructor(private target: T) {
-                this.target = this.target || Object.assign({});
-            }
+            private target;
+            constructor(target: T);
             define<K extends keyof T>(classes: T, 
             /**
              * This influence the order of the nodes, be nice, use ordering with gap -100, 0, 100, 200
                So other extensions etc can inject between
              */
-            weight: number = 1) {
-                this.target = this.target || Object.assign({});
-                const classNames = Object.getOwnPropertyNames(classes) as (K)[];
-                for (const className of classNames) {
-                    const classDef = classes[className];
-                    if (classDef) {
-                        const overrideName = getOverrideName(className as string);
-                        this.target[overrideName] = this.target[overrideName] || [];
-                        const overrides = this.target[overrideName] as Array<OverrideCSSProperties<string>>;
-                        overrides.push({ weight: weight, classDef: classDef });
-                        overrides.sort((o1, o2) => o2.weight - o1.weight);
-                    }
-                }
-                this.target[cssClassesName] = null;
-            }
+            weight?: number): void;
         }
     }
     export {};

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

@@ -1,3 +1,3 @@
-export declare type TsxAllowUnknowProperties<T extends {}> = T & {
+export type TsxAllowUnknowProperties<T extends {}> = T & {
     [name: string]: any;
 };

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

@@ -1,13 +1,13 @@
-export declare type Slots<T> = {
+export type Slots<T> = {
     [K in keyof T]: (props?: T[K]) => JSX.Element | string | JSX.Element[];
 } & {
     [name: string]: (props?: any) => JSX.Element | string | JSX.Element[];
 };
-export declare type ScopedSlots<T> = {
+export type ScopedSlots<T> = {
     [K in keyof T]: (props?: T[K]) => JSX.Element | string | JSX.Element[];
 } & {
     [name: string]: (props?: any) => JSX.Element | string | JSX.Element[];
 };
-export declare type EventHandlers<E> = {
+export type EventHandlers<E> = {
     [K in keyof E]?: (payload: E[K]) => void;
 };

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

@@ -7,7 +7,7 @@ import * as models from "../models";
 import { RecordPropsDefinition } from "vue/types/options";
 import { PropsForOutside, RequiredPropNames, _TsxComponentV3 } from "vue-tsx-support";
 import { CompositionComponentOptions } from "vue-tsx-support/lib/vca";
-declare type VuetifyThemeItem = string | number | {
+type VuetifyThemeItem = string | number | {
     base: string | number;
     lighten5: string | number;
     lighten4: string | number;
@@ -29,7 +29,7 @@ interface VuetifyTheme {
     error: VuetifyThemeItem;
     success: VuetifyThemeItem;
 }
-declare type InheritanceTheme = {
+type InheritanceTheme = {
     id: string;
 };
 export interface VSlot {

package/internal-do-not-import-from-here/ux/admin/chrome/AdminChrome.d.ts

@@ -4,7 +4,7 @@ import { DirectionRuleStore } from "../../../stores";
 import { VueComponentBase } from "../../index";
 import { InputLanguageStore } from "../../inputlanguagepicker/stores";
 import "./AdminChrome.css";
-declare type AdminNavCategory = AdminNavigationBuiltInCategory | string;
+type AdminNavCategory = AdminNavigationBuiltInCategory | string;
 export default class AdminChromeComponent extends VueComponentBase implements IWebComponentInstance {
     private omniaContext;
     private localizationService;

package/internal-do-not-import-from-here/ux/admin/store/AdminStore.d.ts

@@ -1,6 +1,6 @@
 import { AdminNavigationBuiltInCategory, NavigationNode, NavigationMenuNode, Future } from "../../../models";
 import { Store } from "../../../stores";
-declare type AdminNavCategory = AdminNavigationBuiltInCategory | string;
+type AdminNavCategory = AdminNavigationBuiltInCategory | string;
 declare class AdminStoreClass extends Store {
     private localizationService;
     private omniaContext;

package/internal-do-not-import-from-here/ux/appprovisioning/appimageinput/AppImageInput.d.ts

@@ -4,6 +4,7 @@ import { VueComponentBase } from "../../VueComponentBase";
 import { IAppImageInput } from "./IAppImageInput";
 export declare class AppImageInput extends VueComponentBase implements IAppImageInput, IWebComponentInstance {
     appInstance: AppInstance;
+    onValueChanged?: () => void;
     private omniaUxLoc;
     private mediaPickerStore;
     private mediaPickerService;

package/internal-do-not-import-from-here/ux/appprovisioning/appimageinput/IAppImageInput.d.ts

@@ -2,6 +2,7 @@ import { AppInstance } from "../../../models";
 import { TsxAllowUnknowProperties } from "../../TsxAllowUnknowProperties";
 export interface IAppImageInput {
     appInstance: AppInstance;
+    onValueChanged?: () => void;
 }
 declare global {
     namespace JSX {

package/internal-do-not-import-from-here/ux/appprovisioning/apppropertiesinput/AppPropertiesInput.d.ts

@@ -5,6 +5,7 @@ import { IAppPropertiesInput } from "./IAppPropertiesInput";
 export declare class AppPropertiesInput extends VueComponentBase implements IAppPropertiesInput, IWebComponentInstance {
     appInstance: AppInstance;
     cols: number;
+    onValueChanged?: () => void;
     private wizardSize;
     created(): void;
     mounted(): void;