@acorex/platform 19.4.14 → 20.0.0-next.0

package/workflow/index.d.ts

@@ -1,7 +1,168 @@
-export * from './lib/errors.types';
-export * from './lib/workflow-event-dispatcher.service';
-export * from './lib/workflow-registery.service';
-export * from './lib/workflow.module';
-export * from './lib/workflow.service';
-export * from './lib/workflow.types';
-export * from './lib/task-board.types';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Type, ModuleWithProviders, Injector, InjectionToken } from '@angular/core';
+import { AXSchedulerAppointment, AXSchedulerAppointmentDataSourceFilter, AXSchedulerDateRange } from '@acorex/components/scheduler';
+import { AXPActionMenuItem, AXPExecuteCommand, AXPExecuteCommandResult } from '@acorex/platform/core';
+
+declare class AXPWorkflowError extends Error {
+    inner: Error | null;
+    constructor(message: string, inner?: Error | null);
+}
+
+interface AXPWorkflow {
+    steps: {
+        [stepName: string]: AXPWorkflowStep;
+    };
+    startStepId: string;
+}
+declare class AXPWorkflowContext {
+    constructor(initialData?: any);
+    private variables;
+    private stepOutputs;
+    setVariable(key: string, value: any): void;
+    setVariables(context?: any): void;
+    getVariable<T = any>(key?: string | null): T;
+    setOutput(key: string, output: any): void;
+    setOutputs(values: Map<string, any>): void;
+    getOutput<T = any>(key: string): T;
+}
+type AXPWorkflowActionInput = any;
+type AXPWorkflowConditionType = 'AND' | 'OR' | 'SINGLE';
+interface AXPWorkflowCondition {
+    type: AXPWorkflowConditionType;
+    conditions?: AXPWorkflowCondition[];
+    expression?: string;
+}
+interface AXPWorkflowNextStep {
+    conditions: AXPWorkflowCondition[];
+    nextStepId: string;
+}
+interface AXPWorkflowStep {
+    id?: string;
+    action: AXPWorkflowAction | string;
+    input?: AXPWorkflowActionInput;
+    nextSteps?: AXPWorkflowNextStep[];
+    conditions?: AXPWorkflowCondition[];
+}
+declare abstract class AXPWorkflowAction {
+    private eventService;
+    protected dispatch(event: AXPWorkflowEvent): void;
+    abstract execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowAction>;
+}
+declare abstract class AXPWorkflowFunction {
+    abstract execute(...args: any[]): Promise<any> | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowFunction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowFunction>;
+}
+interface AXPWorkflowEvent<T = any> {
+    type: string;
+    payload?: T;
+}
+declare function createWorkFlowEvent<T>(type: string): {
+    (payload: T): {
+        type: string;
+        payload: T;
+    };
+    type: string;
+};
+declare function ofType<T extends {
+    type: string;
+}>(...allowedTypes: Array<{
+    type: string;
+}>): rxjs.MonoTypeOperatorFunction<T>;
+
+declare class AXPWorkflowEventService {
+    private eventSubject;
+    dispatch(event: AXPWorkflowEvent): void;
+    get events$(): Observable<AXPWorkflowEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowEventService>;
+}
+
+declare class AXPWorkflowRegistryService {
+    private functionsMap;
+    private actionsMap;
+    private workflowsMap;
+    registerWorkflow(name: string, workflow: AXPWorkflow): void;
+    getWorkflow(name: string): AXPWorkflow | undefined;
+    registerAction(name: string, action: Type<AXPWorkflowAction>): void;
+    getAction(name: string): Type<AXPWorkflowAction> | undefined;
+    registerFunction(name: string, func: Type<AXPWorkflowFunction>): void;
+    getFunction(name: string): Type<AXPWorkflowFunction> | undefined;
+    getFunctionNames(): string[];
+    getStep(workflowName: string, stepName: string): AXPWorkflowStep | undefined;
+    updateStepInWorkflow(workflowName: string, stepName: string, step: AXPWorkflowStep): void;
+    addStepToWorkflow(workflowName: string, stepName: string, step: AXPWorkflowStep): void;
+    addAfterStep(workflowId: string, stepId: string, newStepId: string, newStepAction: string, conditionExpression: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowRegistryService>;
+}
+
+interface AXPWorkflowModuleConfigs {
+    functions?: {
+        [name: string]: Type<AXPWorkflowFunction>;
+    };
+    actions?: {
+        [name: string]: Type<AXPWorkflowAction>;
+    };
+    workflows?: {
+        [name: string]: AXPWorkflow;
+    };
+}
+declare class AXPWorkflowModule {
+    static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
+    static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPWorkflowModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPWorkflowModule>;
+}
+
+declare class AXPWorkflowService {
+    private registryService;
+    private injector;
+    private eventService;
+    get events$(): Observable<AXPWorkflowEvent>;
+    constructor(registryService: AXPWorkflowRegistryService, injector: Injector);
+    execute(workflow: AXPWorkflow | string, initialContext?: AXPWorkflowContext | any | null): Promise<AXPWorkflowContext>;
+    private processData;
+    private getActionInstance;
+    private getWorkflowInstance;
+    private determineNextStep;
+    private evaluateCondition;
+    private evaluateSingleCondition;
+    private evaluateExpression;
+    private processInputs;
+    private createFunctionScope;
+    private getFunctionInstance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
+}
+
+type AXPTask = AXSchedulerAppointment & {
+    data?: {
+        provider?: string;
+        actions?: AXPActionMenuItem[];
+    };
+};
+type AXPTaskFilter = AXSchedulerAppointmentDataSourceFilter & {
+    types?: string[];
+};
+declare abstract class AXPWorkflowTaskProvider {
+    abstract get name(): string;
+    abstract get title(): string;
+    abstract get icon(): string;
+    abstract getTasks(options?: AXPTaskFilter): Promise<AXPTask[]>;
+    abstract updateTask(id: any, range: AXSchedulerDateRange): Promise<AXPTask>;
+    abstract executeCommand(command: AXPExecuteCommand): Promise<AXPExecuteCommandResult>;
+}
+declare const AXP_WORKFLOW_TASK_PROVIDER: InjectionToken<AXPWorkflowTaskProvider[]>;
+
+export { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXPWorkflowTaskProvider, AXP_WORKFLOW_TASK_PROVIDER, createWorkFlowEvent, ofType };
+export type { AXPTask, AXPTaskFilter, AXPWorkflow, AXPWorkflowActionInput, AXPWorkflowCondition, AXPWorkflowConditionType, AXPWorkflowEvent, AXPWorkflowModuleConfigs, AXPWorkflowNextStep, AXPWorkflowStep };

package/auth/lib/application/application.loader.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Observable } from 'rxjs';
-import { AXPApplication } from './application.types';
-import { AXPSessionContext } from '../session.types';
-export interface AXPApplicationLoader {
-    getList(context: AXPSessionContext): Observable<AXPApplication[]>;
-}
-export declare const AXP_APPLICATION_LOADER: InjectionToken<AXPApplicationLoader>;

package/auth/lib/application/application.types.d.ts

@@ -1,10 +0,0 @@
-import { AXPLogoConfig } from '@acorex/platform/core';
-export interface AXPApplication {
-    id: string;
-    name: string;
-    title?: string;
-    version?: string;
-    editionName?: string;
-    description?: string;
-    logo?: AXPLogoConfig;
-}

package/auth/lib/auth-registry.service.d.ts

@@ -1,12 +0,0 @@
-import { Injector } from "@angular/core";
-import { AXPAuthStrategy } from "./auth.strategy";
-import * as i0 from "@angular/core";
-export declare class AXPAuthStrategyRegistryService {
-    private strategies;
-    private injector;
-    constructor(injector: Injector);
-    register(...plugins: (new () => AXPAuthStrategy)[]): void;
-    get(strategyKey: string): AXPAuthStrategy | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAuthStrategyRegistryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPAuthStrategyRegistryService>;
-}

package/auth/lib/auth.guard.d.ts

@@ -1,2 +0,0 @@
-import { CanActivateFn } from '@angular/router';
-export declare const AXPAuthGuard: CanActivateFn;

package/auth/lib/auth.module.d.ts

@@ -1,21 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { AXPAuthStrategy } from './auth.strategy';
-import { AXPSessionService } from './session.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./permission/permission.directive";
-import * as i2 from "./feature/feature.directive";
-export interface AXPAuthModuleConfigs {
-    strategies: (new () => AXPAuthStrategy)[];
-}
-export declare function initializeAppState(service: AXPSessionService): () => Promise<void>;
-export declare class AXPAuthModule {
-    static forRoot(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
-    static forChild(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
-    /**
-     * @ignore
-     */
-    constructor(instances: any[]);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAuthModule, [{ optional: true; }]>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPAuthModule, [typeof i1.AXPPermissionDirective, typeof i2.AXPFeatureDirective], never, [typeof i1.AXPPermissionDirective, typeof i2.AXPFeatureDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXPAuthModule>;
-}

package/auth/lib/auth.strategy.d.ts

@@ -1,47 +0,0 @@
-import { AXPApplication } from './application/application.types';
-import { AXPSessionContext } from './session.types';
-import { AXPTenant } from './tenant/tenant.types';
-import { AXPUser } from './user/user.types';
-export interface AXPBaseCredentials {
-    strategy: string;
-    [key: string]: string;
-}
-export interface AXPTokenResult {
-    accessToken: string;
-    expiresIn?: string | null;
-    refreshToken?: string;
-    tenant?: AXPTenant | null;
-    application?: AXPApplication | null;
-}
-export interface AXPSignInResult {
-    succeed: boolean;
-    data?: {
-        accessToken: string;
-        idToken?: string | null;
-        expiresIn?: string | null;
-        refreshToken: string;
-        user: AXPUser;
-        tenant?: AXPTenant | null;
-        application?: AXPApplication | null;
-    };
-}
-export interface AXPRefreshTokenResult {
-    succeed: boolean;
-    data?: AXPTokenResult;
-}
-export interface AXPAuthStrategy {
-    get name(): string;
-    signin(credentials: AXPBaseCredentials): Promise<AXPSignInResult>;
-    signout(): Promise<void>;
-    refreshToken(context: AXPSessionContext): Promise<AXPRefreshTokenResult>;
-}
-export interface AXPSessionData {
-    accessToken: string;
-    refreshToken: string;
-    idToken: string | null;
-    strategy: string;
-    user?: AXPUser | null;
-    tenant?: AXPTenant | null;
-    application?: AXPApplication | null;
-    expiresIn?: string | null;
-}

package/auth/lib/errors.types.d.ts

@@ -1,16 +0,0 @@
-export declare class AXPUnauthorizedError extends Error {
-    data?: {
-        redirectUrl?: string;
-    } | undefined;
-    constructor(message?: string, data?: {
-        redirectUrl?: string;
-    } | undefined);
-}
-export declare class AXPUnauthenticatedError extends Error {
-    data?: {
-        redirectUrl?: string;
-    } | undefined;
-    constructor(message?: string, data?: {
-        redirectUrl?: string;
-    } | undefined);
-}

package/auth/lib/feature/feature.directive.d.ts

@@ -1,15 +0,0 @@
-import { TemplateRef, ViewContainerRef } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class AXPFeatureDirective {
-    private templateRef;
-    private viewContainer;
-    private hasView;
-    private subscription;
-    private sessionService;
-    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
-    set feature(featureKeys: string | string[] | null);
-    set featureElse(elseTemplateRef: TemplateRef<any>);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPFeatureDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPFeatureDirective, "[feature]", never, { "feature": { "alias": "feature"; "required": false; }; "featureElse": { "alias": "featureElse"; "required": false; }; }, {}, never, never, false, never>;
-}

package/auth/lib/feature/feature.guard.d.ts

@@ -1,2 +0,0 @@
-import { CanActivateFn } from "@angular/router";
-export declare const AXPFeatureGuard: CanActivateFn;

package/auth/lib/feature/feature.loader.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Observable } from 'rxjs';
-import { AXPFeature } from './feature.types';
-import { AXPSessionContext } from '../session.types';
-export interface AXPFeatureLoader {
-    getList(context: AXPSessionContext): Observable<AXPFeature[]>;
-}
-export declare const AXP_FEATURE_LOADER: InjectionToken<AXPFeatureLoader>;

package/auth/lib/feature/feature.types.d.ts

@@ -1,6 +0,0 @@
-export interface AXPFeature {
-    name: string;
-    title: string;
-    description?: string;
-    value?: any;
-}

package/auth/lib/feature/index.d.ts

@@ -1,4 +0,0 @@
-export * from './feature.types';
-export * from './feature.loader';
-export * from './feature.directive';
-export * from './feature.guard';

package/auth/lib/permission/index.d.ts

@@ -1,6 +0,0 @@
-export * from './permission.directive';
-export * from './permission.guard';
-export * from './permission.loader';
-export * from './permission-definition.service';
-export * from './permission.types';
-export * from './permission-definition.builder';

package/auth/lib/permission/permission-definition.builder.d.ts

@@ -1,24 +0,0 @@
-import { AXPPermissionDefinition, AXPPermissionGroupDefinition } from "./permission.types";
-export declare class AXPPermissionDefinitionProviderContext {
-    private builders;
-    addGroup(name: string, title: string, description?: string): AXPPermissionDefinitionGroupBuilder;
-    getGroupDefinitions(): AXPPermissionGroupDefinition[];
-    findGroup(name: string): AXPPermissionDefinitionGroupBuilder | undefined;
-}
-export declare class AXPPermissionDefinitionGroupBuilder {
-    private context;
-    private _group;
-    get group(): AXPPermissionGroupDefinition;
-    constructor(context: AXPPermissionDefinitionProviderContext, group: AXPPermissionGroupDefinition);
-    addPermission(name: string, title: string, description?: string): AXPPermissionDefinitionBuilder;
-    endGroup(): AXPPermissionDefinitionProviderContext;
-    findPermission(path: string): AXPPermissionDefinition | undefined;
-    findGroup(name: string): AXPPermissionDefinitionGroupBuilder | undefined;
-}
-export declare class AXPPermissionDefinitionBuilder {
-    private groupBuilder;
-    private permission;
-    constructor(groupBuilder: AXPPermissionDefinitionGroupBuilder, permission: AXPPermissionDefinition);
-    addChild(name: string, title: string, description?: string): AXPPermissionDefinitionBuilder;
-    endPermission(): AXPPermissionDefinitionGroupBuilder;
-}

package/auth/lib/permission/permission-definition.service.d.ts

@@ -1,20 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { AXPPermissionDefinition, AXPPermissionGroupDefinition } from './permission.types';
-import { AXPPermissionDefinitionProviderContext } from './permission-definition.builder';
-import * as i0 from "@angular/core";
-export interface AXPPermissionDefinitionProvider {
-    define(context: AXPPermissionDefinitionProviderContext): Promise<void>;
-}
-export declare const AXP_PERMISSION_DEFINITION_PROVIDER: InjectionToken<AXPPermissionDefinitionProvider[]>;
-export declare class AXPPermissionDefinitionService {
-    private providers;
-    private cache;
-    private load;
-    reload(): Promise<void>;
-    getGroups(): Promise<AXPPermissionGroupDefinition[]>;
-    getPermissions(): Promise<AXPPermissionDefinition[]>;
-    getGroup(name: string): Promise<AXPPermissionGroupDefinition | null>;
-    getPermission(name: string): Promise<AXPPermissionDefinition | null>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPermissionDefinitionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPPermissionDefinitionService>;
-}

package/auth/lib/permission/permission.directive.d.ts

@@ -1,15 +0,0 @@
-import { TemplateRef, ViewContainerRef } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class AXPPermissionDirective {
-    private templateRef;
-    private viewContainer;
-    private hasView;
-    private subscription;
-    private sessionService;
-    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
-    set permission(permissionKeys: string | string[] | null);
-    set permissionElse(elseTemplateRef: TemplateRef<any>);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPermissionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPPermissionDirective, "[permission]", never, { "permission": { "alias": "permission"; "required": false; }; "permissionElse": { "alias": "permissionElse"; "required": false; }; }, {}, never, never, false, never>;
-}

package/auth/lib/permission/permission.guard.d.ts

@@ -1,2 +0,0 @@
-import { CanActivateFn } from '@angular/router';
-export declare const AXPPermissionGuard: CanActivateFn;

package/auth/lib/permission/permission.loader.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from "@angular/core";
-import { Observable } from "rxjs";
-import { AXPPermission } from "./permission.types";
-import { AXPSessionContext } from "../session.types";
-export interface AXPPermissionLoader {
-    getList(context: AXPSessionContext): Observable<AXPPermission[]>;
-}
-export declare const AXP_PERMISSION_LOADER: InjectionToken<AXPPermissionLoader>;

package/auth/lib/permission/permission.types.d.ts

@@ -1,13 +0,0 @@
-export type AXPPermission = string;
-export interface AXPPermissionGroupDefinition {
-    name: string;
-    title: string;
-    description?: string;
-    permissions: AXPPermissionDefinition[];
-}
-export type AXPPermissionDefinition = {
-    name: AXPPermission;
-    title: string;
-    description?: string;
-    children: AXPPermissionDefinition[];
-};

package/auth/lib/session.service.d.ts

@@ -1,59 +0,0 @@
-import { Observable } from 'rxjs';
-import { AXPApplication } from './application/application.types';
-import { AXPBaseCredentials, AXPSessionData } from './auth.strategy';
-import { AXPFeature } from './feature';
-import { AXPPermission } from './permission/permission.types';
-import { AXPSessionStatus } from './session.types';
-import { AXPTenant } from './tenant/tenant.types';
-import { AXPUser } from './user/user.types';
-import * as i0 from "@angular/core";
-export declare class AXPSessionService {
-    private eventService;
-    private authStrategyRegistry;
-    static readonly SESSION_KEY = "AXP_SESSION";
-    private readonly permissionLoader;
-    private readonly featureLoader;
-    private readonly tenantLoader;
-    private readonly applicationLoader;
-    private status;
-    readonly status$: Observable<AXPSessionStatus>;
-    private currentUserSubject;
-    readonly user$: Observable<AXPUser | null>;
-    get user(): AXPUser | null;
-    private currentTenantSubject;
-    readonly tenant$: Observable<AXPTenant | null>;
-    get tenant(): AXPTenant | null;
-    get tenants$(): Observable<AXPTenant[]>;
-    private currentApplicationSubject;
-    readonly application$: Observable<AXPApplication | null>;
-    get application(): AXPApplication | null;
-    get applications$(): Observable<AXPApplication[]>;
-    private permissionsSubject;
-    readonly permissions$: Observable<never[] | string[]>;
-    get permissions(): AXPPermission[];
-    private featuresSubject;
-    readonly features$: Observable<never[] | AXPFeature[]>;
-    get features(): AXPFeature[];
-    readonly isAuthenticated$: Observable<boolean>;
-    readonly isAuthorized$: Observable<boolean>;
-    restoreSession(): Promise<void>;
-    signin(credentials: AXPBaseCredentials): Promise<void>;
-    signout(): Promise<void>;
-    refreshToken(): Promise<any>;
-    setTenant(tenant: AXPTenant | null): Promise<void>;
-    setApplication(application: AXPApplication | null): Promise<void>;
-    private loadPermissions;
-    private loadFeatures;
-    signInComplete(): Promise<void>;
-    private setSession;
-    private updateSession;
-    getSessionData(): AXPSessionData | null;
-    private clearSession;
-    authorize(...keys: string[]): boolean;
-    isFeatureEnabled(...keys: string[]): boolean;
-    getToken(): string | undefined;
-    private checkTokenValidation;
-    private getContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSessionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSessionService>;
-}

package/auth/lib/session.types.d.ts

@@ -1,24 +0,0 @@
-import { AXPApplication } from "./application/application.types";
-import { AXPTenant } from "./tenant/tenant.types";
-import { AXPUser } from "./user/user.types";
-export declare class AXPSessionContext {
-    private _user;
-    get user(): AXPUser | null;
-    private _tenant;
-    get tenant(): AXPTenant | null;
-    private _application;
-    get application(): AXPApplication | null;
-    constructor(context: {
-        user: AXPUser | null;
-        tenant: AXPTenant | null;
-        application: AXPApplication | null;
-    });
-}
-export declare enum AXPSessionStatus {
-    Authenticated = "authenticated",
-    Unauthenticated = "unauthenticated",
-    Unauthorized = "unauthorized",
-    Authorized = "authorized",
-    Expired = "expired",
-    SignedOut = "signedOut"
-}

package/auth/lib/tenant/tenant.loader.d.ts

@@ -1,8 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Observable } from 'rxjs';
-import { AXPTenant } from './tenant.types';
-import { AXPSessionContext } from '../session.types';
-export interface AXPTenantLoader {
-    getList(context: AXPSessionContext): Observable<AXPTenant[]>;
-}
-export declare const AXP_TENANT_LOADER: InjectionToken<AXPTenantLoader>;

package/auth/lib/tenant/tenant.types.d.ts

@@ -1,8 +0,0 @@
-import { AXPLogoConfig } from '@acorex/platform/core';
-export interface AXPTenant {
-    id: string;
-    name: string;
-    title: string;
-    description?: string;
-    logo?: AXPLogoConfig;
-}

package/auth/lib/user/user.types.d.ts

@@ -1,6 +0,0 @@
-export interface AXPUser {
-    id: string;
-    name: string;
-    title: string;
-    avatar?: string;
-}

package/common/lib/app/app-version.provider.d.ts

@@ -1,10 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export interface AXPAppVersion {
-    version: string;
-    build: number;
-    date: Date;
-}
-export interface AXPAppVersionProvider {
-    provider(): Promise<AXPAppVersion>;
-}
-export declare const AXP_APP_VERSION_PROVIDER: InjectionToken<AXPAppVersionProvider>;