@omnia/fx-models 8.0.129-dev → 8.0.131-dev

package/internal-do-not-import-from-here/shared/broadcasting/Broadcast.d.ts

@@ -0,0 +1,37 @@
+import { BroadcastTopic, BroadcastInvokeTopic, Future } from "../models";
+/**
+ *Broadcast between render, worker thread and windows, tabs
+ * @class MessageBus
+ */
+export declare class Broadcast {
+    private static _subscribers;
+    private static _channel;
+    private static _initialized;
+    private static _disableSync;
+    private static _invokeRequests;
+    private static _invokeHandlers;
+    /**
+    * Broadcasts a message on the topic
+    */
+    static publish<TMessage>(topic: BroadcastTopic<TMessage>, message: TMessage): void;
+    static invoke<TMessage, TReturnValue>(topic: BroadcastInvokeTopic<TMessage, TReturnValue>, data: TMessage): Future<TReturnValue>;
+    static invokeHandler<TMessage, TReturnValue>(topic: BroadcastInvokeTopic<TMessage, TReturnValue>, fn: (message: TMessage, messageId?: string) => Future<TReturnValue>): void;
+    /**
+    * Subscribes to the specified Topic and triggers function when a message is published
+    */
+    static subscribe<TMessage>(topic: BroadcastTopic<TMessage>, fn: (message: TMessage) => void): void;
+    /**
+    * Unsubscribes from the specified Topic
+    */
+    static unsubscribe<TMessage>(topic: BroadcastTopic<TMessage>, fn: (message: TMessage) => void): void;
+    /**
+    * Creates a topic if it dosent exists
+    * @param topic
+    * @param settings
+    * @returns true/false created
+    */
+    private static ensureTopic;
+    private static ensureInitialized;
+    private static onMessage;
+    private static get channel();
+}

package/internal-do-not-import-from-here/shared/broadcasting/InternalTopics.d.ts

@@ -0,0 +1,23 @@
+import { BroadcastTopic, RealtimeChannelUpdateMessage, RealtimeSendMessage, RealtimChannelMessage, BroadcastInvokeTopic, GuidValue } from "../models";
+export declare const realtimeTopics: {
+    getActiveChannels: BroadcastTopic<void>;
+    updateChannels: BroadcastTopic<RealtimeChannelUpdateMessage[]>;
+    sendMessage: BroadcastTopic<RealtimeSendMessage>;
+    getUsersInChannel: BroadcastInvokeTopic<RealtimChannelMessage, number[]>;
+    messageReceived: BroadcastTopic<RealtimeSendMessage>;
+};
+export declare const endpointTopics: {
+    getActivityHubUrl: BroadcastTopic<{
+        threadId: GuidValue;
+    }>;
+    activityHubUrlUpdated: BroadcastTopic<{
+        threadId: GuidValue;
+        activityHubUrl: string;
+        tokenRefBase64: string;
+    }>;
+};
+export declare const workerTopics: {
+    leaderElected: BroadcastTopic<{
+        workerThreadId: GuidValue;
+    }>;
+};

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

@@ -0,0 +1 @@
+export * from "./Broadcast";

package/internal-do-not-import-from-here/shared/factory/DefineFactory.d.ts

@@ -0,0 +1,12 @@
+import { GuidValue, InstanceLifetimes } from "@omnia/fx-models";
+import { SubscriptionHandler } from "../messaging";
+export interface SetupFactoryContext {
+    onDeactivated(fn: () => void): any;
+    subscriptions: SubscriptionHandler;
+}
+export declare function defineFactory<InferReturnSetup>(setup: (ctx: SetupFactoryContext, ...args: any) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): () => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1>(setup: (ctx: SetupFactoryContext, param1: T1) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: string): (param1: T1, param2: T2) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3, T4>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3, param4: T4) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3, param4: T4) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3, T4, T5>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3, param4: T4, param5: T5) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3, param4: T4, param5: T5) => InferReturnSetup;

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

@@ -0,0 +1,30 @@
+type Resolver = <TClass, TConstructor>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor) => TClass;
+export declare function registerInjectResolver(resolver: Resolver): void;
+/**
+ * Injects an instance of the specifed type. That instance maybe come from higer level relation provide it.
+ *
+ * @param classType - Type to inject
+ * @param constructorArgs - Optional arguments for the constructor, by naming convention an interface should be supplied specifying the expected parameters
+ * the name of the interface should follow <classType>Constructor i.e.
+ * Type: HttpClient, if supporting constructor arguments an interface named: "HttpClientConstructor" should be supplied.
+ *
+ * E.g.:
+ * Inject<HttpClientConstructor>(HttpClient,{someConstructorArg1:"",someConstructorArg2})
+ */
+export declare function Inject<T>(classType: any, constructorArgs?: T): any;
+type Class<T> = {
+    new (...args: any[]): T;
+};
+/**
+ * Injects an instance of the specifed type. That instance maybe come from higer level relation provide it.
+ *
+ * @param type - Type to inject
+ * @param constructorArgs - Optional arguments for the constructor, by naming convention an interface should be supplied specifying the expected parameters
+ * the name of the interface should follow <classType>Constructor i.e.
+ * Type: HttpClient, if supporting constructor arguments an interface named: "HttpClientConstructor" should be supplied.
+ *
+ * E.g.:
+ * useInject<HttpClientConstructor>(HttpClient,{someConstructorArg1:"",someConstructorArg2})
+ */
+export declare function useInject<TClass, TConstructor>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor): TClass;
+export {};

package/internal-do-not-import-from-here/shared/factory/Injectable.d.ts

@@ -0,0 +1,4 @@
+import { ActivationOptions } from "../models";
+export declare function isInjectable(type: any): boolean;
+export declare function Injectable<T>(options: ActivationOptions): any;
+export declare function defineInjectable<TFunc extends Function>(targetFunc: TFunc, options: ActivationOptions): TFunc;

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

@@ -0,0 +1,45 @@
+import { GuidValue } from "../models";
+type Class<T> = {
+    new (...args: any[]): T;
+};
+interface MockInstance {
+    type: any;
+    instance: any;
+}
+export declare function registerTypeResolver(resolver: (type: any) => any): void;
+export declare class InternalServiceContainer {
+    private id;
+    private static creatingFromType;
+    private static singletonInstances;
+    private transientInstances;
+    private destroyedContainer;
+    private scopedInstances;
+    constructor(id: GuidValue);
+    createInstance<TConstructor, TClass>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
+    static isCreatingInstanceFromType(type: any): boolean;
+    private getActiveInstance;
+    /** Only used it for Scope lifetime -  Use to create a proxy to monitor instance, will auto recreate a instance if disposed */
+    private createInstanceProxy;
+    dispose(destroyContainer?: boolean): void;
+    private disposeInstance;
+}
+export declare class ServiceContainer {
+    private static mockInstances;
+    private static registeredOnDisposing;
+    static addMock<T>(type: T, instance: any): void;
+    static getMock<TClass>(type: Class<TClass> | (() => TClass)): MockInstance;
+    /**
+    *  @param forceNewInstanceLifetimeScope that used in Provide/Inject pattern in ui layer.
+    */
+    static createInstance<TConstructor, TClass = any>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
+    static disposeScopedAndTransient(): void;
+    static onDisposing(func: (instance: any) => void): void;
+    static getRegisteredOnDisposing(): ((activatedInstance: any) => void)[];
+}
+export declare class ServiceContainerContext {
+    private container;
+    constructor();
+    createInstance<TConstructor, TClass = any>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,4 @@
+export * from "./ServiceContainer";
+export * from "./Injectable";
+export * from "./Inject";
+export * from "./DefineFactory";

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

@@ -0,0 +1,141 @@
+import { HttpConfig, HttpCredentials, HttpResponse, Future, Guid } from "../models";
+export declare class HttpBuilder {
+    _config?: HttpConfig;
+    constructor(_config?: HttpConfig);
+    /**
+     * The base url for the client e.g. https://api.com
+     *
+     * @param {string} baseUrl
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withBaseUrl(baseUrl: string): HttpBuilder;
+    /**
+     * If headers should be included in the request
+     *
+     * @param {{ [name: string]: string }} headers
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withHeaders(headers: {
+        [name: string]: string;
+    }): HttpBuilder;
+    /**
+     * If credential options should be included in the request, Default is "include" for this method
+     *
+     * @param {HttpCredentials} [credentials]
+     * @return {*}  {HttpBuilder}
+     * @memberof HttpBuilder
+     */
+    withCredentials(credentials?: HttpCredentials): HttpBuilder;
+    /**
+     * Sets up the client defaults to call a json api
+     *
+     * @return {*}
+     * @memberof HttpBuilder
+     */
+    withJsonApiSupport(): HttpBuilder;
+    withExecuteOnWorker(): this;
+    /**
+     * Sets up the client defaults to call a json api
+     *
+     * @return {*}
+     * @memberof HttpBuilder
+     */
+    getConfig(): HttpConfig;
+    /**
+     * Creates the Http instance with the configuration options
+     *
+     * @return {*}  {Http}
+     * @memberof HttpBuilder
+     */
+    build(): Http;
+}
+export declare class Http {
+    _baseConfig: HttpConfig | Future<HttpConfig> | Promise<HttpConfig>;
+    /**
+     * Create a new instance of Http using the HttpBuilder
+     * @static
+     * @param {(HttpConfig | Future<HttpConfig> | Promise<HttpConfig>)} [config]
+     * @return {*}  {Http}
+     * @memberof Http
+     */
+    static new(config?: HttpConfig): HttpBuilder;
+    /**
+     * Creates a new instance of Http with default configurations for calling Omnia Service Apis
+     *
+     * @static
+     * @return {*}
+     * @memberof Http
+     */
+    static default(config?: HttpConfig): Http;
+    constructor(config?: HttpConfig | Future<HttpConfig> | Promise<HttpConfig>);
+    /**
+     *Performs a GET request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    get<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a DELETE request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    delete<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    head<TReturnType>(url: string, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a HEAD request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    post<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    put<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    /**
+     * Performs a POST request for provided url
+     *
+     * @template TReturnType
+     * @param {string} url
+     * @param {Object} body
+     * @param {HttpConfig} [config]
+     * @return {*}  {Future<HttpResponse<TReturnType>>}
+     * @memberof Http
+     */
+    patch<TReturnType>(url: string, body: Object, config?: HttpConfig): Future<HttpResponse<TReturnType>>;
+    private createRequest;
+    private buildRequestInit;
+    private appendQueryParamsToUrl;
+}
+export declare function http(omniaServiceId: Guid, executeOnWorker?: boolean): Http;
+export declare function http(options: HttpConfig): Http;

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

@@ -0,0 +1 @@
+export * from "./Http";

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

@@ -0,0 +1,12 @@
+/**
+ * fx/shared that contain all code to share between worker and browser.
+ * NOTE: it cant have any dependencies to fx core, worker and vendors stuffs
+ * ***/
+export * from "./models";
+export * from "./broadcasting";
+export * from "./workers";
+export * from "./http";
+export * from "./services";
+export * from "./utils";
+export * from "./factory";
+export * from "./messaging";

package/internal-do-not-import-from-here/shared/messaging/MessageBus.d.ts

@@ -0,0 +1,48 @@
+import { Topic, TopicSettings } from "../models";
+/**
+ * A message bus where messages can be published and subscribed to based on a path
+ * @class MessageBus
+ */
+export declare class MessageBus {
+    private static _subscribers;
+    private static _subscriptionConfigs;
+    /**
+    * Publishes a message on the topic
+    */
+    static publish<T>(topic: Topic<T>, obj: T): void;
+    /**
+    * Clears the message cache for the topic
+    */
+    static clearCache<T>(topic: Topic<T>): number;
+    /**
+    * Subscribes to the specified Topic and triggers function when a message is published
+    */
+    static subscribe<T>(topic: Topic<T>, fn: (obj: T) => void): void;
+    /**
+    * Unsubscribes from the specified Topic
+    */
+    static unsubscribe<T>(topic: Topic<T>, fn: (obj: T) => void): void;
+    /**
+    * Creates a topic that messages can be published to, if topic already exists it will throw exception
+    */
+    static createTopic<T>(topic: Topic<T>, settings?: TopicSettings): void;
+    /**
+    * Creates a topic if it dosent exists, if it already exists it will ignore and continue without exception
+    * @param topic
+    * @param settings
+    * @returns true/false created
+    */
+    static ensureTopic<T>(topic: Topic<T>, settings?: TopicSettings): boolean;
+    /**
+    * Returns true if the topic exists already
+    */
+    static topicExists<T>(topic: Topic<T>): boolean;
+    /**
+    * Builds the full path
+    */
+    private static buildTopicPath;
+    /**
+    * Ensures the subscribers array on the path
+    */
+    private static ensureSubscribers;
+}

package/internal-do-not-import-from-here/shared/messaging/MessageBusMediator.d.ts

@@ -0,0 +1,30 @@
+import { Topic, TopicSettings, IMessageBusSubscriptionHandler, IMessageBusTopicSubscription, IMessageBusTopicPublishSubscriber, IMessageBusTopicPublication, TopicCreatedFunc } from "../models";
+export declare class SubscriptionHandler implements IMessageBusSubscriptionHandler {
+    private unSubcribeHandlers;
+    constructor();
+    /**
+     * Unsubscribe to the related subscription(s)
+     * and/or any subscriptions added using add method)
+     * */
+    unsubscribe: () => void;
+    /**
+     * Adds another unsubscribe handler, all will be unsubscribed to if calling unsubscribe
+     * @param unSubscriptionHandler
+     */
+    add: (unSubscriptionHandler: IMessageBusSubscriptionHandler) => void;
+}
+export declare class MessageBusExposeOnlySubscription<T> implements IMessageBusTopicSubscription<T> {
+    subscribe: (fn: (obj: T) => void) => IMessageBusSubscriptionHandler;
+    constructor(publishSubscriber: IMessageBusTopicPublishSubscriber<T>);
+}
+export declare class MessageBusExposeOnlyPublication<T> implements IMessageBusTopicPublication<T> {
+    publish: (msg: T) => void;
+    constructor(publishSubscriber: IMessageBusTopicPublishSubscriber<T>);
+}
+export declare class MessageBusTopicMediator<T> implements IMessageBusTopicPublishSubscriber<T> {
+    private _topic;
+    constructor(topic: Topic<T>, settings?: TopicSettings, onTopicCreated?: TopicCreatedFunc<T>);
+    publish: (msg: T) => void;
+    subscribe: (fn: (obj: T) => void) => IMessageBusSubscriptionHandler;
+    clearMessageCache: () => number;
+}

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

@@ -0,0 +1,2 @@
+export * from "./MessageBus";
+export * from "./MessageBusMediator";

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

@@ -1,11 +1,12 @@
-import { BackgroundDefinition, ColorValue, FillDefinition } from "./ThemeDefinitionV2";
-import { ChromeBlueprint } from "./Chrome";
+import { BackgroundDefinition, ColorSchemaType, ColorValue, FillDefinition } from "./ThemeDefinitionV2";
 import { SpacingDefinition, Spacing } from "./Spacing";
 import { TypographyValue } from "./Typography";
 export interface BoxDimensions extends Spacing {
 }
 import { TypographyBlueprint } from "./Typography";
+import { Guid, GuidValue, VelcronAppDefinition } from "@omnia/fx-models";
 export interface Blueprints {
+    id: Guid;
     name?: string;
 }
 export type BlueprintVariant = "primary" | "secondary" | "variant1" | "variant2" | "variant3";
@@ -22,7 +23,19 @@ export interface TypographyBlueprints extends Blueprints {
 export interface SpacingBlueprints extends Blueprints {
     primary: SpacingBlueprint;
 }
-export type ButtonTypes = "primary" | "basic" | "accent1" | "warn" | "disabled" | "link";
+export interface ChromeBlueprint {
+    name?: string;
+    colorSchemaType?: ColorSchemaType;
+    header: {
+        definitionId: GuidValue;
+        definition?: VelcronAppDefinition;
+    };
+    styles: {
+        background?: BackgroundDefinition;
+        spacing?: Spacing;
+    };
+}
+export type ButtonTypes = "primary" | "basic" | "accent1" | "warn" | "link" | "variant1" | "variant2" | "variant3" | "variant4";
 export interface ComponentBlueprints extends Blueprints {
     buttons?: {
         text?: {
@@ -30,16 +43,22 @@ export interface ComponentBlueprints extends Blueprints {
             basic?: ButtonBlueprint;
             accent1?: ButtonBlueprint;
             warn?: ButtonBlueprint;
-            disabled?: ButtonBlueprint;
             link?: ButtonBlueprint;
+            variant1?: ButtonBlueprint;
+            variant2?: ButtonBlueprint;
+            variant3?: ButtonBlueprint;
+            variant4?: ButtonBlueprint;
         };
         icon?: {
             primary?: ButtonBlueprint;
             basic?: ButtonBlueprint;
             accent1?: ButtonBlueprint;
             warn?: ButtonBlueprint;
-            disabled?: ButtonBlueprint;
             link?: ButtonBlueprint;
+            variant1?: ButtonBlueprint;
+            variant2?: ButtonBlueprint;
+            variant3?: ButtonBlueprint;
+            variant4?: ButtonBlueprint;
         };
     };
     tabs?: {
@@ -48,6 +67,7 @@ export interface ComponentBlueprints extends Blueprints {
         variant2?: TabsBlueprint;
         variant3?: TabsBlueprint;
     };
+    blocks?: ChromeBlueprints;
 }
 export interface SpacingBlueprint {
     layout: SpacingDefinition;

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

@@ -1,5 +1,5 @@
 import { Guid } from "../Guid";
-import { BoxDimensions, ChromeBlueprints, ComponentBlueprints, SpacingBlueprints, TypographyBlueprints } from "./Blueprints";
+import { BoxDimensions } from "./Blueprints";
 export interface ColorTypeResult<resultType> {
     base: resultType;
     baseTone: resultType;
@@ -38,15 +38,16 @@ export interface ColorSchemas {
     background: ColorSchema;
     error: ColorSchema;
     info: ColorSchema;
+    warning: ColorSchema;
+    notification: ColorSchema;
 }
 export interface ThemeDefinitionV2 {
     id: Guid;
     name?: string;
     colors: ColorSchemas;
-    typography: TypographyBlueprints;
-    spacing: SpacingBlueprints;
-    chrome: ChromeBlueprints;
-    components: ComponentBlueprints;
+    typographyId: Guid;
+    spacingId: Guid;
+    componentId: Guid;
 }
 export type ColorSchemaType = keyof typeof ColorSchemaTypes;
 export declare enum ColorSchemaTypes {
@@ -56,6 +57,8 @@ export declare enum ColorSchemaTypes {
     accent2 = "accent2",
     accent3 = "accent3",
     neutral = "neutral",
+    warning = "warning",
+    notification = "notification",
     background = "background",
     error = "error",
     info = "info",

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

@@ -9,6 +9,8 @@ var ColorSchemaTypes;
     ColorSchemaTypes["accent2"] = "accent2";
     ColorSchemaTypes["accent3"] = "accent3";
     ColorSchemaTypes["neutral"] = "neutral";
+    ColorSchemaTypes["warning"] = "warning";
+    ColorSchemaTypes["notification"] = "notification";
     ColorSchemaTypes["background"] = "background";
     ColorSchemaTypes["error"] = "error";
     ColorSchemaTypes["info"] = "info";

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

@@ -4,5 +4,4 @@ export * from "./UseThemeMethods";
 export * from "./Spacing";
 export * from "./SharedBlueprintMethods";
 export * from "./SharedColorMethods";
-export * from "./Chrome";
 export * from "./Blueprints";

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

@@ -8,5 +8,4 @@ tslib_1.__exportStar(require("./UseThemeMethods"), exports);
 tslib_1.__exportStar(require("./Spacing"), exports);
 tslib_1.__exportStar(require("./SharedBlueprintMethods"), exports);
 tslib_1.__exportStar(require("./SharedColorMethods"), exports);
-tslib_1.__exportStar(require("./Chrome"), exports);
 tslib_1.__exportStar(require("./Blueprints"), exports);

package/internal-do-not-import-from-here/shared/services/ActivityService.d.ts

@@ -0,0 +1,27 @@
+import { FileOwnerId, ChannelId, ActivityFeed, FeedActivityDefinition, SourceRelatedHubProperty, NotificationTeaser, FeedQuery, TemporaryFileId, ActorActivityBase, ActivityCategoryCount, ActorActivityCategory, ActivityRendererLoadingReferences, ActivityRendererLoadReference, ActivityRenderer, HubReaction, HubComment, ExternalActorId, ActivityId, ActorId, Actor } from "../models";
+export declare const activityService: () => {
+    getFeed: (channelId: ChannelId, options?: FeedQuery) => Promise<ActivityFeed>;
+    createActivity: <TRenderState>(channelId: ChannelId, createdBy: ActorId, activityDefinition: FeedActivityDefinition<TRenderState>, targeting: Array<Array<SourceRelatedHubProperty>>, notification: NotificationTeaser, category?: ActorActivityCategory, expires?: Date, createdAt?: Date, activityIdPlaceHolder?: TemporaryFileId) => Promise<void>;
+    getActors: (actorIds: Array<ActorId>) => Promise<Actor[]>;
+    getActorsByExternalIds: (externalIds: Array<ExternalActorId>) => Promise<{
+        actorId: ActorId;
+        externalId: string;
+    }[]>;
+    dismissNotificationsByActorIds: (channelId: ChannelId, actorIds: Array<ActorId>) => Promise<boolean>;
+    updateActorActivity: (channelId: ChannelId, actorActivity: ActorActivityBase) => Promise<ActivityCategoryCount[]>;
+    tempDelete: (channelId: ChannelId) => Promise<boolean>;
+    tempActorActivitiesDelete: (channelId: ChannelId) => Promise<boolean>;
+    getActivityRenderersLoadReferences: (currentLoadStateHash?: string) => Promise<ActivityRendererLoadingReferences>;
+    getActivityRenderer: (toLoad: ActivityRendererLoadReference) => Promise<ActivityRenderer>;
+    addCommentAsync: (activityId: ActivityId, rendererJson: string, mentions: ExternalActorId[], inReplyToCommentId?: number) => Promise<HubComment>;
+    getCommentsAsync: (activityId: ActivityId, offSet?: HubComment | null, limt?: number) => Promise<HubComment[]>;
+    updateCommentAsync: (activityId: ActivityId, comment: HubComment) => Promise<HubComment>;
+    deleteCommentAsync: (activityId: ActivityId, toDelete: HubComment) => Promise<number[]>;
+    addReactionAsync: (activityId: ActivityId, reactionType: string) => Promise<HubReaction[]>;
+    deleteReactionAsync: (activityId: ActivityId, toDelete: HubReaction) => Promise<HubReaction[]>;
+    getReactionsAsync: (activityId: ActivityId) => Promise<HubReaction[]>;
+    getFiles: (fileOwnerId: FileOwnerId, startPath: string[]) => Promise<string[]>;
+    getTempFiles: (tempFilesId: TemporaryFileId, startPath: string[]) => Promise<string[]>;
+    takeOwnership: (tempFilesId: TemporaryFileId, subPath: string[]) => Promise<void>;
+    upload: (uniqueGuid: TemporaryFileId, files: File[]) => Promise<TemporaryFileId>;
+};

package/internal-do-not-import-from-here/shared/services/ActivitySubscriptionService.d.ts

@@ -0,0 +1,15 @@
+import { SubscriptionInformation, Subscription, ActorSubscription, ActorId, SubscriptionId } from "../models";
+export declare const activitySubscriptionService: () => {
+    upsertSubscription: (subscriptionOwner: ActorId, id: SubscriptionId, title: Record<string, string>, description: Record<string, string>) => Promise<SubscriptionInformation>;
+    removeSubscription: (actorSubscription: ActorSubscription) => Promise<SubscriptionInformation>;
+    get: (actorSubscription: ActorSubscription) => Promise<SubscriptionInformation>;
+    getByActorId: (subscriptionOwner: ActorId) => Promise<SubscriptionInformation[]>;
+    getAll: () => Promise<SubscriptionInformation[]>;
+    addActorAsSubscriber: (actorSubscription: ActorSubscription, newSubscriber: ActorId) => Promise<SubscriptionId>;
+    removeActorAsSubscriber: (actorSubscription: ActorSubscription, actorToRemove: ActorId) => Promise<SubscriptionId>;
+    getActorSubscriptions: (actorToGetFor: ActorId) => Promise<SubscriptionInformation[]>;
+    getSubscribers: (subscriptionOwner: ActorId, ownerSubscriptions: SubscriptionId[]) => Promise<Subscription[]>;
+    addFollowingSubscription: (actorToFollow: ActorId) => Promise<void>;
+    isFollowingSubscription: (actorToFollow: ActorId) => Promise<boolean>;
+    removeFollowingSubscription: (actorToFollow: ActorId) => Promise<SubscriptionId>;
+};

package/internal-do-not-import-from-here/shared/services/DefineService.d.ts

@@ -0,0 +1,9 @@
+import { SetupFactoryContext } from "../factory";
+import { http } from "../http";
+interface SetupServiceContext extends SetupFactoryContext {
+    http: typeof http;
+}
+export declare function defineService<TActions extends {
+    [key: string]: Function;
+}, TArgs extends any[]>(setup: (ctx: SetupServiceContext) => TActions): () => TActions;
+export {};

package/internal-do-not-import-from-here/shared/services/RealtimeService.d.ts

@@ -0,0 +1,8 @@
+import { Future, RealtimeChannel, RealtimeData } from "../models";
+export declare const useRealtimeService: () => {
+    activateChannel: (channel: RealtimeChannel) => void;
+    deactivateChannel: (channel: RealtimeChannel) => void;
+    send: <TRealtimeChannel extends RealtimeChannel, TRealtimeData extends RealtimeData<TRealtimeChannel, any>>(data: TRealtimeData, value: TRealtimeData["value"]) => void;
+    getUsersInChannel: (channel: RealtimeChannel) => Future<Array<number>>;
+    onMessage: <TRealtimeChannel_1 extends RealtimeChannel, TRealtimeData_1 extends RealtimeData<TRealtimeChannel_1, any>>(data: TRealtimeData_1, callback: (value: TRealtimeData_1["value"]) => void) => void;
+};

package/internal-do-not-import-from-here/shared/services/ThemingService.d.ts

@@ -0,0 +1,8 @@
+import { ButtonBlueprint, Guid, ITemplateRegistration } from "@omnia/fx-models";
+export declare const useThemingService: () => {
+    buttonBlueprints: () => {
+        upsert: (blueprint: ITemplateRegistration<ButtonBlueprint>) => Promise<void>;
+        delete: (id: Guid) => Promise<void>;
+        getAll: () => Promise<ITemplateRegistration<ButtonBlueprint>[]>;
+    };
+};

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

@@ -0,0 +1,5 @@
+export * from "./DefineService";
+export * from "./ActivityService";
+export * from "./RealtimeService";
+export * from "./ActivitySubscriptionService";
+export * from "./ThemingService";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export declare class Utils {
+    static generateGuid(): string;
+    static isNativeClass(value: any): boolean;
+}

package/internal-do-not-import-from-here/shared/workers/Leader.d.ts

@@ -0,0 +1,6 @@
+export declare class Leader {
+    private static _elector;
+    static awaitLeadership(): Promise<void>;
+    static get isLeader(): boolean;
+    private static get elector();
+}

package/internal-do-not-import-from-here/shared/workers/WorkerProxy.d.ts

@@ -0,0 +1,11 @@
+import { WorkerProxyFunction } from "../models";
+export declare class WorkerProxy {
+    static _worker: Worker;
+    private static _initialized;
+    private static _handlers;
+    private static _promiseResolvers;
+    static call<TParamType, TReturnType>(topic: WorkerProxyFunction<TParamType, TReturnType>, parameter: TParamType): Promise<TReturnType>;
+    static addFunction<TSendType, TReturnType>(topic: WorkerProxyFunction<TSendType, TReturnType>, handler: (data: TSendType) => TReturnType): void;
+    private static ensureInitialized;
+    private static callHandlerMessage;
+}

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

@@ -0,0 +1,2 @@
+export * from "./WorkerProxy";
+export * from "./Leader";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-models",
   "license": "MIT",
-  "version": "8.0.129-dev",
+  "version": "8.0.131-dev",
   "description": "Provide Omnia Fx Models Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/ux/ThemingApi.d.ts

@@ -1,34 +1,40 @@
-import { BorderStylingDefinition, ButtonBlueprint, ChromeBlueprint, ChromeBlueprints, ColorSchema, ComponentBlueprints, FillDefinition, SpacingBlueprints, SpacingDefinition, TabsBlueprint, ThemeDefinitionV2, TypographyBlueprints } from "@omnia/fx-models";
+import { BorderStylingDefinition, ButtonBlueprint, ChromeBlueprint, ChromeBlueprints, ColorSchema, ComponentBlueprints, FillDefinition, Guid, SpacingBlueprints, SpacingDefinition, TabsBlueprint, ThemeDefinitionV2, TypographyBlueprints } from "@omnia/fx-models";
 import { ApiPath } from "../Extends";
+export interface ITemplateRegistration<TTemplateType = any> {
+    id: Guid;
+    template: TTemplateType;
+    hidden?: boolean;
+    custom?: boolean;
+}
 export interface IThemeRegistrationApiHandler {
-    getAllThemes(): any;
-    registerTheme(definitions: ThemeDefinitionV2 | ThemeDefinitionV2[]): any;
-    registerColorSchema(colorSchema: ColorSchema | ColorSchema[]): any;
-    getAllColorSchemas(): any;
+    getAllThemeRegistrations(): ITemplateRegistration<ThemeDefinitionV2>[];
+    registerTheme(definitions: ITemplateRegistration<ThemeDefinitionV2> | ITemplateRegistration<ThemeDefinitionV2>[]): any;
+    registerColorSchema(colorSchema: ITemplateRegistration<ColorSchema> | ITemplateRegistration<ColorSchema>[]): any;
+    getAllColorSchemaRegistrations(): any;
     templates: {
         get: {
-            spacingDefinition: () => SpacingDefinition[];
-            spacingBlueprints: () => SpacingBlueprints[];
-            fillDefinition: () => FillDefinition[];
-            borderDefinition: () => BorderStylingDefinition[];
-            buttonBlueprint: () => ButtonBlueprint[];
-            tabsBlueprint: () => TabsBlueprint[];
-            chromeBlueprint: () => ChromeBlueprint[];
-            chromeBlueprints: () => ChromeBlueprints[];
-            componentBlueprints: () => ComponentBlueprints[];
-            typographyBlueprints: () => TypographyBlueprints[];
+            spacingDefinition: () => ITemplateRegistration<SpacingDefinition>[];
+            spacingBlueprints: () => ITemplateRegistration<SpacingBlueprints>[];
+            fillDefinition: () => ITemplateRegistration<FillDefinition>[];
+            borderDefinition: () => ITemplateRegistration<BorderStylingDefinition>[];
+            buttonBlueprint: () => ITemplateRegistration<ButtonBlueprint>[];
+            tabsBlueprint: () => ITemplateRegistration<TabsBlueprint>[];
+            chromeBlueprint: () => ITemplateRegistration<ChromeBlueprint>[];
+            chromeBlueprints: () => ITemplateRegistration<ChromeBlueprints>[];
+            componentBlueprints: () => ITemplateRegistration<ComponentBlueprints>[];
+            typographyBlueprints: () => ITemplateRegistration<TypographyBlueprints>[];
         };
         add: {
-            spacingDefinition: (spacing: SpacingDefinition | SpacingDefinition[]) => void;
-            spacingBlueprints: (spacing: SpacingBlueprints | SpacingBlueprints[]) => void;
-            fillDefinition: (fill: FillDefinition | FillDefinition[]) => void;
-            borderDefinition: (border: BorderStylingDefinition | BorderStylingDefinition[]) => void;
-            buttonBlueprint: (blueprint: ButtonBlueprint | ButtonBlueprint[]) => void;
-            tabsBlueprint: (blueprint: TabsBlueprint | TabsBlueprint[]) => void;
-            chromeBlueprint: (blueprint: ChromeBlueprint | ChromeBlueprint[]) => void;
-            chromeBlueprints: (blueprint: ChromeBlueprints | ChromeBlueprints[]) => void;
-            componentBlueprints: (blueprint: ComponentBlueprints | ComponentBlueprints[]) => void;
-            typographyBlueprints: (blueprints: TypographyBlueprints | TypographyBlueprints[]) => void;
+            spacingDefinition: (spacing: ITemplateRegistration<SpacingDefinition> | ITemplateRegistration<SpacingDefinition>[]) => void;
+            spacingBlueprints: (spacing: ITemplateRegistration<SpacingBlueprints> | ITemplateRegistration<SpacingBlueprints>[]) => void;
+            fillDefinition: (fill: ITemplateRegistration<FillDefinition> | ITemplateRegistration<FillDefinition>[]) => void;
+            borderDefinition: (border: ITemplateRegistration<BorderStylingDefinition> | ITemplateRegistration<BorderStylingDefinition>[]) => void;
+            buttonBlueprint: (blueprint: ITemplateRegistration<ButtonBlueprint> | ITemplateRegistration<ButtonBlueprint>[]) => void;
+            tabsBlueprint: (blueprint: ITemplateRegistration<TabsBlueprint> | ITemplateRegistration<TabsBlueprint>[]) => void;
+            chromeBlueprint: (blueprint: ITemplateRegistration<ChromeBlueprint> | ITemplateRegistration<ChromeBlueprint>[]) => void;
+            chromeBlueprints: (blueprint: ITemplateRegistration<ChromeBlueprints> | ITemplateRegistration<ChromeBlueprints>[]) => void;
+            componentBlueprints: (blueprint: ITemplateRegistration<ComponentBlueprints> | ITemplateRegistration<ComponentBlueprints>[]) => void;
+            typographyBlueprints: (blueprints: ITemplateRegistration<TypographyBlueprints> | ITemplateRegistration<TypographyBlueprints>[]) => void;
         };
     };
 }

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

@@ -1,16 +0,0 @@
-import { GuidValue } from "../Guid";
-import { VelcronAppDefinition } from "../velcron";
-import { Spacing } from "./Spacing";
-import { BackgroundDefinition, ColorSchemaType } from "./ThemeDefinitionV2";
-export interface ChromeBlueprint {
-    name?: string;
-    colorSchemaType?: ColorSchemaType;
-    header: {
-        definitionId: GuidValue;
-        definition?: VelcronAppDefinition;
-    };
-    styles: {
-        background?: BackgroundDefinition;
-        spacing?: Spacing;
-    };
-}

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });