@veloceapps/sdk 5.0.13-0

package/cms/cms.actions.d.ts

@@ -0,0 +1,28 @@
+import { IntegrationAction, Metric } from './types';
+export declare enum FlowAction {
+    FLOW_CONFIGURE_PRODUCT = "FLOW_CONFIGURE_PRODUCT",
+    FLOW_NAVIGATE_BACK = "FLOW_NAVIGATE_BACK",
+    FLOW_NAVIGATE_TO_CATALOG = "FLOW_NAVIGATE_TO_CATALOG",
+    FLOW_APPLY_PRODUCT_CONFIGURATION = "FLOW_APPLY_PRODUCT_CONFIGURATION",
+    FLOW_OPEN_DOC_GEN = "FLOW_OPEN_DOC_GEN",
+    FLOW_CLOSE_DOC_GEN = "FLOW_CLOSE_DOC_GEN",
+    FLOW_SWITCH_OBJECT = "FLOW_SWITCH_OBJECT",
+    REMOTE_APPLY = "REMOTE_APPLY",
+    REMOTE_CANCEL = "REMOTE_CANCEL",
+    SET_DEFAULT_METRICS = "SET_DEFAULT_METRICS"
+}
+export declare const ConfigureProductAction: ({ lineItemId, productId, }: {
+    lineItemId?: string | undefined;
+    productId?: string | undefined;
+}) => IntegrationAction;
+export declare const NavigateBackAction: () => IntegrationAction;
+export declare const NavigateToCatalogAction: () => IntegrationAction;
+export declare const ApplyProductConfigurationAction: () => IntegrationAction;
+export declare const OpenDocGenAction: () => IntegrationAction;
+export declare const CloseDocGenAction: () => IntegrationAction;
+export declare const RemoteApplyAction: () => IntegrationAction;
+export declare const RemoteCancelAction: () => IntegrationAction;
+export declare const SwitchObjectAction: (payload: {
+    id: string;
+}) => IntegrationAction;
+export declare const SetDefaultMetrics: (metrics: Metric[]) => IntegrationAction;

package/cms/cms.default.d.ts

@@ -0,0 +1,5 @@
+import { UIDefinitionType } from '@veloceapps/sdk/core';
+import { Plugin } from './engine/models/plugin';
+export declare const DEFAULT_PLUGINS: {
+    [key in UIDefinitionType]: typeof Plugin[];
+};

package/cms/cms.elements.d.ts

@@ -0,0 +1,4 @@
+import { ElementConfig, ELEMENT_TYPE } from './types/common.types';
+export declare const CONFIG: {
+    [key in ELEMENT_TYPE]: ElementConfig;
+};

package/cms/components/element-children/element-children.component.d.ts

@@ -0,0 +1,10 @@
+import { ElementContextService } from '../../services/element-context.service';
+import { ElementMetadata } from '../../types/common.types';
+import * as i0 from "@angular/core";
+export declare class ElementChildrenComponent {
+    private elementContext;
+    metadata?: ElementMetadata;
+    constructor(elementContext: ElementContextService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementChildrenComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementChildrenComponent, "element-children", never, {}, {}, never, never>;
+}

package/cms/components/element-children/element-children.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./element-children.component";
+import * as i2 from "../element-renderer/element-renderer.module";
+export declare class ElementChildrenModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementChildrenModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementChildrenModule, [typeof i1.ElementChildrenComponent], [typeof i2.ElementRendererModule], [typeof i1.ElementChildrenComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementChildrenModule>;
+}

package/cms/components/element-renderer/element-renderer.component.d.ts

@@ -0,0 +1,36 @@
+import { ChangeDetectorRef, ElementRef, Injector, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { ConfigurationService } from '@veloceapps/sdk/core';
+import { DynamicModuleService } from '../../services/dynamic-module.service';
+import { ElementContextService } from '../../services/element-context.service';
+import { IOProviderService } from '../../services/io-provider.service';
+import { ElementMetadata } from '../../types/common.types';
+import * as i0 from "@angular/core";
+export declare class ElementRendererComponent implements OnInit, OnDestroy {
+    private parentInjector;
+    private dynamicModuleService;
+    private elementContext;
+    private ioProviderService;
+    private configurationService;
+    private elementRef;
+    private cdr;
+    el?: ViewContainerRef;
+    meta: ElementMetadata;
+    private factory?;
+    private refs;
+    private destroy$;
+    constructor(parentInjector: Injector, dynamicModuleService: DynamicModuleService, elementContext: ElementContextService, ioProviderService: IOProviderService, configurationService: ConfigurationService, elementRef: ElementRef, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private createComponents;
+    private createFromPath;
+    private getModelComponent;
+    private createFromLineItem;
+    private processChildren;
+    private getParentLineItem$;
+    private createComponent;
+    private updateComponent;
+    private destroyComponent;
+    private destroyComponents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererComponent, [{ skipSelf: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementRendererComponent, "vl-cms-element-renderer", never, { "meta": "meta"; }, {}, never, never>;
+}

package/cms/components/element-renderer/element-renderer.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./element-renderer.component";
+export declare class ElementRendererModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementRendererModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementRendererModule, [typeof i1.ElementRendererComponent], never, [typeof i1.ElementRendererComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementRendererModule>;
+}

package/cms/components/element.component.d.ts

@@ -0,0 +1,17 @@
+import { AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, Injector, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Entity } from '../engine/models/entity';
+import { IPluginComponent } from './plugin.component';
+export declare class ElementComponent extends Entity implements OnChanges, OnInit, DoCheck, AfterContentInit, AfterViewInit, AfterViewChecked, OnDestroy {
+    injector: Injector;
+    readonly model$: BehaviorSubject<any>;
+    readonly plugins: IPluginComponent[];
+    constructor(injector: Injector);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+}

package/cms/components/index.d.ts

@@ -0,0 +1 @@
+export * from './element.component';

package/cms/components/plugin.component.d.ts

@@ -0,0 +1,15 @@
+import { AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { ElementComponent } from '.';
+import { Plugin } from '../engine/models/plugin';
+import * as i0 from "@angular/core";
+declare type AngularHooks = OnChanges & OnInit & DoCheck & AfterContentInit & AfterContentChecked & AfterViewInit & AfterViewChecked & OnDestroy;
+export interface IPluginComponent extends Partial<AngularHooks> {
+    host: ElementComponent;
+}
+export declare class PluginComponent extends Plugin implements IPluginComponent {
+    readonly host: ElementComponent;
+    constructor(host: ElementComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PluginComponent, never, never, {}, {}, never>;
+}
+export {};

package/cms/components/preview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './preview.component';
+export * from './preview.module';

package/cms/components/preview/preview.component.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ConfigurationRuntimeService, ConfigurationService, UIDefinition } from '@veloceapps/sdk/core';
+import { MessageService } from 'primeng/api';
+import { BehaviorSubject } from 'rxjs';
+import { IntegrationState } from '../../services';
+import { LauncherService } from '../../services/launcher.service';
+import { ElementMetadata } from '../../types/common.types';
+import * as i0 from "@angular/core";
+interface State {
+    loading: boolean;
+    failure: boolean;
+}
+export declare class PreviewComponent implements OnInit, OnDestroy {
+    private launcherService;
+    private configurationService;
+    private messageService;
+    private runtimeService;
+    private integrationState;
+    modelId?: string;
+    uiDefinition?: UIDefinition;
+    clearState: boolean;
+    state$: BehaviorSubject<State>;
+    elements: ElementMetadata[];
+    private destroy$;
+    constructor(launcherService: LauncherService, configurationService: ConfigurationService, messageService: MessageService, runtimeService: ConfigurationRuntimeService, integrationState: IntegrationState);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeConfiguration$;
+    private elementToMetadataSafe;
+    private startPreview;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "vl-cms-preview", never, { "modelId": "modelId"; "uiDefinition": "uiDefinition"; "clearState": "clearState"; }, {}, never, never>;
+}
+export {};

package/cms/components/preview/preview.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./preview.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/components";
+import * as i4 from "../element-renderer/element-renderer.module";
+import * as i5 from "../element-children/element-children.module";
+export declare class PreviewModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PreviewModule, [typeof i1.PreviewComponent], [typeof i2.CommonModule, typeof i3.LoaderModule, typeof i4.ElementRendererModule, typeof i5.ElementChildrenModule], [typeof i1.PreviewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PreviewModule>;
+}

package/cms/decorators/element.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ElementDefaultMetadata } from '../types';
+export declare function ElementDefinition(definition: ElementDefaultMetadata): (constructor: any) => any;

package/cms/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './element.decorator';

package/cms/directives/custom-template.directive.d.ts

@@ -0,0 +1,12 @@
+import { AfterViewInit, TemplateRef } from '@angular/core';
+import { TemplatesService } from '../services/templates.service';
+import * as i0 from "@angular/core";
+export declare class CustomTemplateDirective implements AfterViewInit {
+    private templateRef;
+    private templatesService;
+    constructor(templateRef: TemplateRef<any>, templatesService: TemplatesService);
+    customTemplate: string | undefined;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomTemplateDirective, "[customTemplate]", never, { "customTemplate": "customTemplate"; }, {}, never>;
+}

package/cms/engine/models/entity.d.ts

@@ -0,0 +1,11 @@
+import { Injector } from '@angular/core';
+import { Plugin } from './plugin';
+export declare class Entity {
+    injector: Injector;
+    protected readonly plugins: Plugin[];
+    private config;
+    private defaultPlugins;
+    constructor(injector: Injector);
+    initPlugins(): void;
+    registerPlugin(plugin: Plugin): void;
+}

package/cms/engine/models/plugin.d.ts

@@ -0,0 +1,5 @@
+import { Entity } from './entity';
+export declare class Plugin {
+    readonly host: Entity;
+    constructor(host: Entity);
+}

package/cms/index.d.ts

@@ -0,0 +1,11 @@
+export * from './cms.actions';
+export * from './components';
+export * from './components/preview';
+export * from './decorators';
+export * from './injection-tokens';
+export * from './launcher.module';
+export * from './modules/federated/export';
+export * from './services';
+export * from './types';
+export * from './utils';
+export { VendorMap } from './vendor-map';

package/cms/injection-tokens.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { UIDefinitionMetadata } from '@veloceapps/sdk/core';
+import { Dictionary } from 'lodash';
+import { Plugin } from './engine/models/plugin';
+import { ElementConfig, ElementMetadata } from './types/common.types';
+export declare const DEFAULT_PLUGINS_TOKEN: InjectionToken<(typeof Plugin)[]>;
+export declare const UI_DEFINITION_METADATA: InjectionToken<UIDefinitionMetadata>;
+export declare const ELEMENT_METADATA: InjectionToken<ElementMetadata>;
+export declare const SHARED_ELEMENT_METADATA: InjectionToken<ElementMetadata>;
+export declare const ELEMENT_CONFIG: InjectionToken<ElementConfig>;
+export declare const VENDOR_MAP: InjectionToken<Dictionary<any>>;

package/cms/launcher.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@veloceapps/core";
+import * as i3 from "@veloceapps/api";
+import * as i4 from "@veloceapps/sdk/core";
+export declare class LauncherModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LauncherModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LauncherModule, never, [typeof i1.CommonModule, typeof i2.CoreModule, typeof i3.ApiModule, typeof i4.SdkCoreModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LauncherModule>;
+}

package/cms/modules/federated/default-options.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultOptions: {
+    suppressLoading: boolean;
+    loadingLabel: string;
+};

package/cms/modules/federated/export.d.ts

@@ -0,0 +1 @@
+export { FederatedComponentInstance, FederatedModuleOptions } from './federated.types';

package/cms/modules/federated/federated.component.d.ts

@@ -0,0 +1,26 @@
+import { AfterViewInit, ApplicationRef, Compiler, ElementRef, Injector, OnChanges, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FederatedModuleOptions } from './federated.types';
+import * as i0 from "@angular/core";
+export declare class FederatedComponent implements OnInit, AfterViewInit, OnChanges {
+    private injector;
+    private compiler;
+    private appRef;
+    private renderer;
+    moduleHostRef?: ElementRef;
+    remoteEntry?: string;
+    remoteName?: string;
+    exposedModule?: string;
+    data?: any;
+    options?: FederatedModuleOptions;
+    isLoading$: BehaviorSubject<boolean>;
+    suppressLoading: boolean;
+    loadingLabel: string;
+    private instance?;
+    constructor(injector: Injector, compiler: Compiler, appRef: ApplicationRef, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FederatedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FederatedComponent, "veloce-host-federated", never, { "remoteEntry": "remoteEntry"; "remoteName": "remoteName"; "exposedModule": "exposedModule"; "data": "data"; "options": "options"; }, {}, never, never>;
+}

package/cms/modules/federated/federated.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./federated.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@veloceapps/components";
+export declare class FederatedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FederatedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FederatedModule, [typeof i1.FederatedComponent], [typeof i2.CommonModule, typeof i3.LoaderModule], [typeof i1.FederatedComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FederatedModule>;
+}

package/cms/modules/federated/federated.types.d.ts

@@ -0,0 +1,30 @@
+export declare type FederatedModuleOptions = {
+    /**
+     * URL to the federated container
+     * i.e. http://localhost:4200/remoteIntegrationModule.js
+     */
+    remoteEntry?: string;
+    /**
+     * Name of the federated container
+     */
+    remoteName?: string;
+    /**
+     * Name of exposed Angular module
+     */
+    exposedModule?: string;
+    /**
+     * Suppress remote module loading process spinner
+     */
+    suppressLoading?: boolean;
+    /**
+     * Loading label. Default: LOADING
+     */
+    loadingLabel?: string;
+    /**
+     * Ready callback is called when remote module has been loaded
+     */
+    onReady?: () => void;
+};
+export interface FederatedComponentInstance<D = unknown> {
+    data?: D;
+}

package/cms/modules/federated/federated.utils.d.ts

@@ -0,0 +1 @@
+export declare function loadRemoteModule(remoteEntry: string, remoteName: string, exposedModule: string): Promise<any>;

package/cms/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@veloceapps/sdk/cms",
+  "sideEffects": false,
+  "main": "../bundles/veloceapps-sdk-cms.umd.js",
+  "module": "../fesm2015/veloceapps-sdk-cms.js",
+  "es2015": "../fesm2015/veloceapps-sdk-cms.js",
+  "esm2015": "../esm2015/cms/veloceapps-sdk-cms.js",
+  "fesm2015": "../fesm2015/veloceapps-sdk-cms.js",
+  "typings": "veloceapps-sdk-cms.d.ts"
+}

package/cms/plugins/configuration.plugin.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy } from '@angular/core';
+import { ElementComponent } from '../components/element.component';
+import { PluginComponent } from '../components/plugin.component';
+import { ConfigurationElement } from '../types';
+import * as i0 from "@angular/core";
+export declare class ConfigurationPlugin implements PluginComponent, OnDestroy {
+    host: ElementComponent & ConfigurationElement;
+    private modelSnapshot?;
+    private destroy$;
+    private elementMetadata;
+    private configurationService;
+    constructor(host: ElementComponent & ConfigurationElement);
+    ngOnDestroy(): void;
+    private register;
+    private registerType;
+    private registerPort;
+    private registerAttribute;
+    private get attributeHost();
+    private get typeHost();
+    private get portHost();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPlugin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConfigurationPlugin, never, never, {}, {}, never>;
+}

package/cms/plugins/io.plugin.d.ts

@@ -0,0 +1,9 @@
+import { ElementComponent } from '../components/element.component';
+import { PluginComponent } from '../components/plugin.component';
+import * as i0 from "@angular/core";
+export declare class IOPlugin implements PluginComponent {
+    host: ElementComponent;
+    constructor(host: ElementComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IOPlugin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IOPlugin, never, never, {}, {}, never>;
+}

package/cms/plugins/script.plugin.d.ts

@@ -0,0 +1,13 @@
+import { ElementComponent } from '../components/element.component';
+import { PluginComponent } from '../components/plugin.component';
+import * as i0 from "@angular/core";
+export declare class ScriptPlugin implements PluginComponent {
+    host: ElementComponent;
+    private document;
+    private vendorMap;
+    constructor(host: ElementComponent);
+    private addScript;
+    private normalizeImports;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScriptPlugin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScriptPlugin, never, never, {}, {}, never>;
+}

package/cms/services/dynamic-module.service.d.ts

@@ -0,0 +1,15 @@
+import { ComponentFactory } from '@angular/core';
+import { ElementMetadata } from '../types/common.types';
+import * as i0 from "@angular/core";
+export declare class DynamicModuleService {
+    private _elementsTree;
+    private _componentFactories;
+    set componentFactories(data: ComponentFactory<any>[]);
+    get componentFactories(): ComponentFactory<any>[];
+    getComponentFactory(element: ElementMetadata): ComponentFactory<any> | undefined;
+    get elementsTree(): ElementMetadata[];
+    set elementsTree(tree: ElementMetadata[]);
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicModuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicModuleService>;
+}

package/cms/services/element-context.service.d.ts

@@ -0,0 +1,8 @@
+import { ElementMetadata } from '../types/common.types';
+import * as i0 from "@angular/core";
+export declare class ElementContextService {
+    metadata?: ElementMetadata;
+    parentModelId?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElementContextService>;
+}

package/cms/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './integration.state';
+export * from './launcher.service';
+export * from './templates.service';

package/cms/services/integration.state.d.ts

@@ -0,0 +1,17 @@
+import { Dictionary } from 'lodash';
+import { Observable } from 'rxjs';
+import { IntegrationAction } from '../types/integration.types';
+import * as i0 from "@angular/core";
+export declare class IntegrationState<S = Dictionary<any>> {
+    private readonly stateSubj$;
+    private readonly action$;
+    get state$(): Observable<S>;
+    get state(): S;
+    patchState(update: Partial<S>): void;
+    dispatch(action: IntegrationAction): void;
+    listen$<P = any>(actionType: string): Observable<P>;
+    listenAll$<T extends IntegrationAction>(): Observable<T>;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntegrationState<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntegrationState<any>>;
+}

package/cms/services/io-provider.service.d.ts

@@ -0,0 +1,15 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ElementMetadata } from '../types/common.types';
+import { DynamicModuleService } from './dynamic-module.service';
+import * as i0 from "@angular/core";
+export declare class IOProviderService {
+    private dynamicModuleService;
+    private inputs;
+    constructor(dynamicModuleService: DynamicModuleService);
+    connect(el: ElementMetadata, name: string, target?: string | null): Observable<any> | undefined;
+    provide(el: ElementMetadata, name: string, target?: string | null): BehaviorSubject<any> | undefined;
+    private resolveTarget;
+    private createSubjectSafe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IOProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IOProviderService>;
+}

package/cms/services/launcher.service.d.ts

@@ -0,0 +1,18 @@
+import { Compiler } from '@angular/core';
+import { UIDefinitionMetadata } from '@veloceapps/sdk/core';
+import { Observable } from 'rxjs';
+import { CompilationResult, ElementMetadata } from '../types';
+import { DynamicModuleService } from './dynamic-module.service';
+import * as i0 from "@angular/core";
+export declare class LauncherService {
+    private compiler;
+    private dynamicModuleService;
+    private module?;
+    private moduleInstance?;
+    constructor(compiler: Compiler, dynamicModuleService: DynamicModuleService);
+    compileModule(uiDef: UIDefinitionMetadata, elements: ElementMetadata[]): Observable<CompilationResult>;
+    destroy(): void;
+    private getModule;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LauncherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LauncherService>;
+}

package/cms/services/templates.service.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+declare type Template = TemplateRef<any> | undefined;
+export declare class TemplatesService {
+    private templates;
+    register(name: string, templateRef: TemplateRef<any>): void;
+    get(name: string): Template;
+    get$(name: string): Observable<Template>;
+    private ensureStorage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TemplatesService>;
+}
+export {};

package/cms/types/common.types.d.ts

@@ -0,0 +1,108 @@
+import { Dictionary } from 'lodash';
+import { Entity } from '../engine/models/entity';
+import { Plugin } from '../engine/models/plugin';
+export declare type ELEMENT_TYPE = 'CUSTOM' | 'CONTAINER' | 'SERVICE' | 'REFERENCE';
+export declare type ElementStyleDeclaration = Partial<CSSStyleDeclaration>;
+export interface ElementConfig {
+    component: typeof Entity;
+    plugins?: typeof Plugin[];
+    defaultTemplate?: string;
+    suppressTemplate?: boolean;
+    suppressStyles?: boolean;
+}
+export interface ElementModel {
+    /**
+     * Defines a path for an element model.
+     * It's combined with a path to a target element and an output property name.
+     *
+     * If target value is an Array, then the element will be repeated `n` times and each instance will get it's own value.
+     *
+     * Examples:
+     * - `/Root/Services/DataService/:products`
+     * - `../../Services/DataService/:products`
+     * - `@Services/DataService/:products`
+     */
+    path?: string;
+    /**
+     * Used only when `UIDefinitionType = CONFIGURATION`.
+     */
+    lineItem?: string;
+}
+export interface ElementDefaultMetadata {
+    name: string;
+    type: ELEMENT_TYPE;
+    /**
+     * Make component shared
+     *
+     * Used only when `type !== REFERENCE`
+     */
+    isShared?: boolean;
+    /**
+     * Element module name. Module is used for quick access from other elements.
+     *
+     * For example we have a `DataService` element, and we say it's declared in `Services` module. Then it can be accessed in other elements `model`, `inputs` or `outputs` properties this way: `@Services/DataService`
+     *
+     */
+    module?: string;
+    /**
+     * Defines inputs of the element. An object where `key` is the name of the input and `value` is target path
+     *
+     * If `value == null`, then the element acts like a target - we expect other element to connect to it.
+     *
+     * Examples:
+     *
+     * 1. `products: '/Root/Services/DataService'`
+     * The element will have `products` input which will get the data from `products` output in dataservice element
+     *
+     * 2. `productsList: '/Root/Services/DataService/:products'`
+     * The element will have `productsList` input which will get the data from `products` output in dataservice element
+     *
+     * 3. `productsList: '@Services/DataService/:products'`
+     * The element will have `productsList` input which will get the data from `products` output in dataservice element which is declared in `Services` module
+     *
+     * 4. `onProductSelect: null`
+     * The element will have `onProductSelect` input, and the script could have a logic which will listen on the events
+     *
+     * Relative paths allowed:
+     *
+     * - `..`
+     * - `../:products`
+     * - `../../DataService/:products`
+     *
+     */
+    inputs?: Dictionary<string | null>;
+    /**
+     * Defines outputs of the element. An object where `key` is the name of the output and `value` is target path
+     *
+     * If `value == null`, then the element acts like a target - we expect other element to connect to it.
+     *
+     * Examples:
+     *
+     * 1. `onProductSelect: '/Root/Services/DataService/:handleProductSelect'`
+     * The element will have `onProductSelect` output, which will emit events to the `dataservice` element `handleProductSelect` input
+     *
+     * 2. `onProductSelect: '@Services/DataService/:handleProductSelect'`
+     * Same output but accessing dataservice by the Service module
+     */
+    outputs?: Dictionary<string | null>;
+    model?: ElementModel;
+    /**
+     * Defines a shared component name to use as a reference
+     *
+     * Used only when `type === REFERENCE`
+     */
+    reference?: string;
+    children?: string[];
+    /**
+     * Contains styles configurable from UI builder
+     */
+    configuredStyles?: ElementStyleDeclaration;
+}
+export interface ElementMetadata extends Omit<ElementDefaultMetadata, 'children'> {
+    path?: string;
+    children: ElementMetadata[];
+    template?: string;
+    styles?: string;
+    script?: string;
+    metadata?: string;
+}

package/cms/types/compilation.types.d.ts

@@ -0,0 +1,6 @@
+import { ModuleWithComponentFactories, NgModule } from '@angular/core';
+import { ElementMetadata } from './common.types';
+export interface CompilationResult {
+    elements: ElementMetadata[];
+    module: ModuleWithComponentFactories<NgModule>;
+}