@omnia/fx 8.0.8-vnext → 8.0.9-dev

package/internal-do-not-import-from-here/services/properties/EnterprisePropertiesProvider.d.ts

@@ -0,0 +1,30 @@
+import { EnterprisePropertyCategory, EnterprisePropertyDataTypeIds, EnterprisePropertyDefinition, PropertyConfiguration, PropertyDefinition, PropertyDefinitionId } from "../../models";
+import { ServiceContainerContext } from "../../core";
+import { OmniaContext } from "../../contexts";
+import { EnterprisePropertyStore } from "../../stores/EnterprisePropertyStore";
+import { MultilingualStore } from "../../stores/MultilingualStore";
+import { EnterprisePropertyCategoryStore } from "../../stores/EnterprisePropertyCategoryStore";
+declare class EnterprisePropertyToPropertyDefinitionMap {
+    readonly enterprisePropertyDataTypeId: EnterprisePropertyDataTypeIds;
+    readonly propertyDefintionId: PropertyDefinitionId;
+    constructor(propDefinitionCtor: new () => PropertyDefinition<any, any, any>, enterprisePropertyDataTypeId: EnterprisePropertyDataTypeIds);
+}
+export declare class EnterprisePropertiesProvider {
+    static enterprisePropertyDataTypeToPropertyDefinition: Array<EnterprisePropertyToPropertyDefinitionMap>;
+    id: import("@omnia/fx-models").GuidValue;
+    title: string;
+    omniaContext: OmniaContext;
+    enterprisePropertyStore: EnterprisePropertyStore;
+    multilingualStore: MultilingualStore;
+    serviceContainerContext: ServiceContainerContext;
+    enterprisePropertyCategoryStore: EnterprisePropertyCategoryStore;
+    private promise;
+    getProperties(): Promise<Array<{
+        epDef: EnterprisePropertyDefinition;
+        epCategory: EnterprisePropertyCategory;
+    }>>;
+    getPropertyDefinition(enterprisePropertyDefinition: EnterprisePropertyDefinition): PropertyDefinitionId;
+    getPropertyConfiguration(enterprisePropertyDefinition: EnterprisePropertyDefinition): Promise<PropertyConfiguration<PropertyDefinition<any, any, any, any>>>;
+    private getEnterprisePropertyDataTypeToPropertySetting;
+}
+export {};

package/internal-do-not-import-from-here/services/properties/bindings/PropertyBindingService.d.ts

@@ -0,0 +1,12 @@
+import { PropertyBinding, PropertyBindingId, PropertyConfiguration, PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType, PropertyValue } from "../../../models";
+export declare class PropertyBindingService {
+    private serviceContainerContext;
+    private plugedInBindingProviders;
+    private allBindings;
+    constructor();
+    getBindingById(bindingId: PropertyBindingId): Promise<PropertyBinding<PropertyDefinition<PropertyValue, any, any>>>;
+    getConfiguration<TPropertyDefinition extends PropertyDefinition<PropertyValue, any, any>>(bindingId: PropertyBindingId): Promise<PropertyConfiguration<TPropertyDefinition>>;
+    getDisplaySettings<TPropertyDefinition extends PropertyDefinition<PropertyValue, any, any>>(bindingId: PropertyBindingId): Promise<PropertyDisplaySettingsType<TPropertyDefinition>>;
+    getEditSettings<TPropertyDefinition extends PropertyDefinition<PropertyValue, any, any>>(bindingId: PropertyBindingId): Promise<PropertyEditorSettingsType<TPropertyDefinition>>;
+    private ensureAllBindings;
+}

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/BusinessProfilePropertyBindingProvider.d.ts

@@ -0,0 +1,9 @@
+import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+export declare class BusinessProfilePropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
+    private static bindingConfigs;
+    private localizationStore;
+    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
+}

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/ExtendedEnterprisePropertyBindingProvider.d.ts

@@ -0,0 +1,10 @@
+import { GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, PropertyDisplaySettingsBase, IPropertyBindingProvider } from "../../../../models";
+export declare class ExtendedEnterprisePropertiesPropertyBindingProvider implements IPropertyBindingProvider {
+    id: import("@omnia/fx-models").Guid;
+    private enterprisePropertyStore;
+    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+    getBindingsIncludeDeleted(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, PropertyDisplaySettingsBase, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
+    private getExtendedEnterpriseProperties;
+}

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/IdentityPropertyBindingProvider.d.ts

@@ -0,0 +1,10 @@
+import { Guid, GuidValue, IdentityTypes, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+export declare class IdentityPropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
+    private static bindingConfigs;
+    private localizationStore;
+    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
+    getBindingForIdentityType(type: IdentityTypes): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+}

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/UserPropertyBindingProvider.d.ts

@@ -0,0 +1,9 @@
+import { Guid, GuidValue, PropertyBinding, PropertyConfiguration, PropertyDefinition, IPropertyBindingProvider } from "../../../../models";
+export declare class UserPropertyBindingProvider implements IPropertyBindingProvider {
+    id: Guid;
+    private static bindingConfigs;
+    private localizationStore;
+    getBindingById(bindingId: GuidValue): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindings(): Promise<PropertyBinding<PropertyDefinition<any, any, any>>[]>;
+    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
+}

package/internal-do-not-import-from-here/services/properties/bindings/bindingProviders/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ExtendedEnterprisePropertyBindingProvider";
+export * from "./IdentityPropertyBindingProvider";
+export * from "./UserPropertyBindingProvider";
+export * from "./BusinessProfilePropertyBindingProvider";

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

@@ -0,0 +1,2 @@
+export * from "./PropertyBindingService";
+export * from "./bindingProviders";

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertiesService.d.ts

@@ -0,0 +1,88 @@
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, GuidValue, PropertyDataSourceId, PropertyDefinition, PropertyValue, PropertyValuePrimitiveConverter, UserIdentity } from "../../../models";
+import { IDataSourcePropertyCreator } from "./DataSourcePropertyProvider";
+import { DataSourcePropertyDefinitionHandler } from "./DataSourcePropertyDefinitionHandler";
+import { OmniaContext } from "../../../contexts";
+export declare enum WriteBackStatus {
+    WrittenOk = 0,
+    ConversionError = 1,
+    SaveError = 2,
+    WritebackUnSupported = 3
+}
+export type WritebackRequest = {
+    dataSourceProperty: DataSourceProperty;
+    propertyValue: PropertyValue;
+    definitionHandler: DataSourcePropertyDefinitionHandler<PropertyDefinition<any, any, any>, DataSourceProperty, any, any>;
+};
+export type WritebackResult = {
+    dataSourceProperty: DataSourceProperty;
+    writeStatus: WriteBackStatus;
+};
+export interface IWritebackTrigger {
+    /**
+     * Will trigger any pending writebacks
+     * */
+    executeWritebacks(): Promise<void>;
+}
+export interface IChangeUserContextTrigger {
+}
+export declare class DataSourcePropertiesService {
+    private propertyDataSourceInstances;
+    private specificUser;
+    private serviceContainerContext;
+    omniaContext: OmniaContext;
+    private externalWritebackTrigger;
+    private externalChangeUserContextTrigger;
+    getDataSources(): Promise<Array<{
+        sourceId: PropertyDataSourceId;
+        dataSourceTitle: string;
+    }>>;
+    getSpecificUser(): UserIdentity;
+    setSpecificUser(specificUser: UserIdentity): void;
+    changeUserContext(user: UserIdentity): void;
+    isChangeUserContext(): boolean;
+    resetUserContext(): void;
+    hasExternalWritebackTrigger(): boolean;
+    addOnBeforeExternalWritebackHandler(writebackPreparationFunc: () => Promise<void>): void;
+    registerExternalWritebackTrigger(onWriteBackPendingListener: () => void, getExist?: boolean): IWritebackTrigger;
+    registerExternalChangeUserContextTrigger(onChangeUserContextListener: () => void): IChangeUserContextTrigger;
+    getProperties(datasourceId: PropertyDataSourceId): Promise<Array<DataSourceProperty>>;
+    /**
+     * Getting more than one possible creator for a given data source property means a selection must be made as several converters/creators could be used to create the desired propertydefinition, e.g. using ui component
+     * Each DataSourcePropertyDefinitionHandler has it own unique id, which can be used to persist the choice of the selection, note a persisted selection could point to a handler no longer provided by the system
+     * Getting no converters/creators mean this property can not be handled by the system
+     * */
+    getPropertyValueCreators(dataSourceProperty: DataSourceProperty): Promise<Array<DataSourcePropertyDefinitionHandler<PropertyDefinition<PropertyValue, any, any>, DataSourceProperty, any, any>>>;
+    getPropertiesDisplayInformation(dataSourceProperties: Array<DataSourceProperty>): Promise<Array<{
+        property: DataSourceProperty;
+        displayInformation: DataSourcePropertyDisplayInformation;
+    }>>;
+    getPropertySourceValues(dataSourceProperties: Array<DataSourceProperty>): Promise<Array<{
+        valueFromSource: any;
+        dataSourceProperty: DataSourceProperty;
+    }>>;
+    getPropertyValuePrimitiveConverter(propertyValueCreator: DataSourcePropertyDefinitionHandler<PropertyDefinition<PropertyValue, any, any>, DataSourceProperty, any, any>): Promise<PropertyValuePrimitiveConverter>;
+    supportsWriteback(dataSourceProperties: Array<DataSourceProperty>): Promise<Array<{
+        property: DataSourceProperty;
+        supportsWriteBack: boolean;
+    }>>;
+    /**
+     * Write back dataSourceProperties based on the values in PropertyValue, the value written to the datasource is the result of the definitionHandler.propertyWriteBackDataCreator.
+     * */
+    writeback(writeRequests: Array<WritebackRequest>): Promise<Array<WritebackResult>>;
+    /**
+     * Get an interface for a datasource to create properties from string, if not supported null/undefined
+     * @param dataSourceId
+     * @returns creator or undefined/null for not supported
+     */
+    getDataSourcePropertyCreator(dataSourceId: GuidValue): Promise<IDataSourcePropertyCreator>;
+    /**
+     * Todo add something like this that a datasource can return if it supports creating datasourceproperties, i.e. graph But does this need more than from string, i.e. like separat creator manifest from datasource?
+     * string is quite basic/ugly but migt not need anthing more now atleast
+     * return null, not supported else the creator of propertymetadata
+     * */
+    private writeBackToDataSource;
+    private getDataSourceDefinitionHandlers;
+    private getPropertyDataSourceInstance;
+    private groupBy;
+    private makeWriteable;
+}

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyDefinitionHandler.d.ts

@@ -0,0 +1,35 @@
+import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDefinition, PropertyValueType, PropertyDefinitionId } from "../../../models";
+export type DataSourcePropertyDefintionHandlerId = GuidValue;
+/**
+ *
+ * A plugin module for handling the different property definitions/values that can be created from the data source properties
+ *
+ * */
+export declare abstract class DataSourcePropertyDefinitionHandler<TPropertyDefinition extends PropertyDefinition<any, any, any>, TDataSourceProperty extends DataSourceProperty, DataSourceReadDataType, DataSourceWriteBackType> {
+    /**
+     * A unique constant id for this converter
+     * */
+    abstract readonly Id: DataSourcePropertyDefintionHandlerId;
+    /**
+     * Handler title, will be used if more than one handler exists for any given propertyDefinition
+     * E.g "Ticks to DateTimeProperty", and one other handler nemed "String to DateTimeProperty", i.e "TDataSourceData To TPropertyDefinition" or so.
+     * */
+    abstract readonly title: string;
+    /**
+     * The property defintion this handler is intended to handle
+     * */
+    readonly propertyDefintionId: PropertyDefinitionId;
+    /**
+     * The ctor for the definition which this handler is defined for, only used to link with definitionId in a typesafe way
+     * */
+    constructor(propertyDefinitionCtor: new () => TPropertyDefinition);
+    propertyConfiguration?: PropertyConfiguration<TPropertyDefinition>;
+    /**
+     * This method should convert from the data source value to PropertyValue matching the TPropertyDefinition
+     * */
+    abstract propertyValueCreator(dataSourceProperty: TDataSourceProperty, valueFromSource: DataSourceReadDataType, propertyconfiguration?: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyValueType<TPropertyDefinition>>;
+    /**
+     * This method should convert from PropertyValue matching the TPropertyDefinition to the write back data type expected for data source to be able to writeback
+     * */
+    abstract propertyWriteBackDataCreator(dataSourceProperty: TDataSourceProperty, propertyValue: PropertyValueType<TPropertyDefinition>): Promise<DataSourceWriteBackType>;
+}

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyProvider.d.ts

@@ -0,0 +1,49 @@
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition, PropertyDefinitionId, UserIdentity } from "../../../models";
+import { WritebackResult } from "./DataSourcePropertiesService";
+export interface IDataSourcePropertyCreator {
+    createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
+}
+export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends DataSourceProperty> {
+    readonly currentUser: UserIdentity;
+    readonly isImpersonatedUser: boolean;
+    abstract readonly title: string;
+    abstract readonly id: PropertyDataSourceId;
+    abstract supportsWriteback2(properties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        supportsWriteBack: boolean;
+    }>>;
+    abstract writeback(properties: Array<{
+        dataSourceProperty: TDataSourceProperty;
+        valueToWriteback: any;
+    }>): Promise<Array<WritebackResult>>;
+    /**
+     * Get all the properties supported by this data source, this is the @type {TDataSourceProperty} is extended to represent the information within a data source to identify a data source property
+     * */
+    abstract getProperties(): Promise<Array<TDataSourceProperty>>;
+    /**
+     * Returns the property configuration that should be used when representing this property, if the propertyconfiguration is not know by the source return null
+     * */
+    abstract getPropertyConfiguration(property: TDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, any, any>>>;
+    /**
+     * Returns the property definition id that should be used for representing this property, if the propertydefinition is not know by the source return undefined, selection among source property creators can be made explicitly
+     * */
+    abstract getPropertyDefinition(property: TDataSourceProperty): Promise<PropertyDefinitionId>;
+    /**
+     * Get the value for datasource properties, the returned data type TDataSourceData must have a matching DataSourcePropertyDefinitionHandler<any,any,TDataSourceData>
+     * I.e. so a handler exists that can create property values from the source value type
+     * */
+    abstract getPropertyValues(properties: Array<TDataSourceProperty>): Promise<Array<{
+        valueFromSource: any;
+        dataSourceProperty: TDataSourceProperty;
+    }>>;
+    /**
+     * Get the current display information for a data source property, this is resolved from a data source property, as this information migth relay on system/source data that change over time
+     * */
+    abstract getPropertyDisplayInformation(dataSourceProperties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        displayInformation: DataSourcePropertyDisplayInformation;
+    }>>;
+}
+export declare abstract class DynamicPropertyDataSource<TDataSourceProperty extends DataSourceProperty> extends PropertyDataSourceBase<TDataSourceProperty> implements IDataSourcePropertyCreator {
+    abstract createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
+}

package/internal-do-not-import-from-here/services/properties/datasource/TestDataSourceService.d.ts

@@ -0,0 +1,6 @@
+import { DataSourcePropertiesService } from "./DataSourcePropertiesService";
+export declare class TestDataSourcePropertiesService {
+    dataSourcePropertiesService: DataSourcePropertiesService;
+    constructor();
+    runTest(): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export * from "./DataSourcePropertyProvider";
+export * from "./DataSourcePropertyDefinitionHandler";
+export * from "./DataSourcePropertiesService";
+export * from "./TestDataSourceService";

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

@@ -0,0 +1,3 @@
+export * from "./bindings";
+export * from "./datasource";
+export * from "./EnterprisePropertiesProvider";

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

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

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

@@ -0,0 +1,143 @@
+import { HttpConfig, HttpCredentials, HttpMethods, 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;
+    buildRequestInit(method: HttpMethods, url: string, config: HttpConfig, reqConfig: HttpConfig, body: any): {
+        requestUrl: string;
+        reqInit: RequestInit;
+    };
+}
+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

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

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

@@ -0,0 +1 @@
+export type DynamicState = object;

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

@@ -0,0 +1,3 @@
+export interface IEquals<T extends Object> {
+    equals: T;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//have issue with guidvalue can't auto cast to string if have more extension method here.
+// declare global {
+//     interface String {
+//         equals?: {
+//             component<TElement = typeof omfx>(cb: (elements: TElement) => any): boolean;
+//         }
+//     }
+// }
+const _equalsObject = {};
+// only add extension methods when running in browser, not in node.js
+if (globalThis.omnia) {
+    Object.defineProperty(String.prototype, "equals", {
+        value: function () {
+            return _equalsObject;
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+    Object.defineProperty(Object.prototype, "equals", {
+        value: function () {
+            return _equalsObject;
+        },
+        writable: true,
+        configurable: false,
+        enumerable: false
+    });
+    // Object.defineProperty(String.prototype["equals"], "element", {
+    //     value: function () {
+    //         return function (cb: (elements) => any) {
+    //             const elementName = cb(new Proxy({}, {
+    //                 get(target, key: string) {
+    //                     return key;
+    //                 }
+    //             }) as any);
+    //             return this.toString().replace(/-/g, "").toLowerCase().indexof(elementName.toLowerCase()) > -1;
+    //         };
+    //     },
+    //     writable: false,
+    //     configurable: false,
+    //     enumerable: false
+    // });
+}

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

@@ -14,7 +14,10 @@ export declare class Future<T> extends Promise<T> {
      * @return {*}  {Future<{ success?: T, error?: Error; }>}
      * @memberof Future
      */
-    tryCatch(): Future<[success: T, error: Error]>;
+    tryCatch(): Future<{
+        success: T;
+        error: Error;
+    }>;
     /**
      * Aborts the request
      *

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

@@ -5,16 +5,18 @@ class Future extends Promise {
     constructor(executor) {
         let resolveLocal;
         let rejectLocal;
+        // Cant have function here since this is undefined in setTimeout
+        // eslint-disable-next-line func-style 
         const onAborted = (cb) => {
             setTimeout(() => {
                 this.onAborted = cb;
             });
         };
-        const exec = (resolve, reject) => {
+        function exec(resolve, reject) {
             // assign to local to prevent error assignbefore call super;
             resolveLocal = resolve;
             rejectLocal = reject;
-        };
+        }
         super(exec);
         this.resolving = false;
         this._resolved = false;
@@ -46,10 +48,10 @@ class Future extends Promise {
         return new Future(async (resolve) => {
             try {
                 const data = await this;
-                resolve([data, undefined]);
+                resolve({ success: data, error: undefined });
             }
-            catch (err) {
-                resolve([undefined, err]);
+            catch (error) {
+                resolve({ success: undefined, error });
             }
         });
     }
@@ -90,13 +92,19 @@ class Future extends Promise {
     }
     get [Symbol.toStringTag]() {
         // return Object value to make vue can build get/set reactive.
-        return "Object";
+        // return "Object";
+        //<<vue3>> back to normal because vue 3 use native proxy.
+        return "Future";
     }
     static new() {
         return new Future(() => { });
     }
 }
 exports.Future = Future;
+// Future.prototype["promise_then"] = Promise.prototype.then;
+// Future.prototype["then"] = function (resolve, reject) {
+//     return Future.prototype["promise_then"].apply(this, arguments);
+// };
 class ResponsePromise extends Promise {
     constructor(executor) {
         const onCancel = (cb) => {

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

@@ -1,4 +1,8 @@
-export interface GuidValue {
+import "./Equals";
+import { IEquals } from "./Equals";
+export interface GuidValue extends Partial<IEquals<{
+    guid(value: GuidValue): boolean;
+}>> {
     toString: () => string;
 }
 /**
@@ -6,10 +10,13 @@ export interface GuidValue {
  */
 export declare class Guid implements GuidValue {
     private static _empty;
+    private value;
+    equals: {
+        guid: (value: GuidValue) => boolean;
+    };
     static newGuid(): GuidValue;
     static get empty(): GuidValue;
     static isValid(guid: string | GuidValue): boolean;
-    private value;
     constructor(guid: string);
     toString(): string;
     toJSON: () => string;