robbyson-frontend-library 0.0.1-rc1

package/src/index.ts

@@ -0,0 +1,26 @@
+export * from "./ioc";
+
+// Factories
+export * from "./factories";
+
+// Models
+export * from "./models/theme-base";
+export * from "./models/user-mirror.model";
+export * from "./models/user-session.model";
+export * from "./models/send-user-to-login.model";
+export * from "./models/angel-friend-status.model";
+
+// Repositories
+export * from "./repositories/base.repository";
+
+// Components
+export * from "./components";
+
+// States
+export * from "./states";
+
+// Utils
+export * from "./utils";
+
+// Constants 
+export * from "./constants";

package/src/ioc.ts

@@ -0,0 +1,18 @@
+export class IoC {
+
+    private static _registed: { identifier: string, instance: any }[] = [];
+
+    public static GetInstance<T>(instanceIdentifier: string): T {
+        var implementation: any;
+        IoC._registed.forEach((registeredInstance) => {
+            if (registeredInstance.identifier === instanceIdentifier)
+                implementation = registeredInstance.instance as T;
+        });
+
+        return implementation as T;
+    }
+
+    public static Register(instanceIdentifier: string, instance: any) {
+        IoC._registed.push({ identifier: instanceIdentifier, instance });
+    }
+}

package/src/models/angel-friend-status.model.ts

@@ -0,0 +1,7 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+// TODO: ADD OTHERS TYPES
+export class AngelFriendStatusModel extends BaseRepositoryModel {
+    activeSponsorships: [];
+    configuration: { possibleGodfather: boolean };
+}

package/src/models/base.repository.model.ts

@@ -0,0 +1,3 @@
+export class BaseRepositoryModel {
+
+}

package/src/models/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./theme-base";
+export * from "./user-session.model";
+export * from "./user-mirror.model";
+export * from "./result-level.model";
+export * from "./angel-friend-status.model";
+export * from "./send-user-to-login.model";
+export * from "./term-of-use.model";

package/src/models/result-level.model.ts

@@ -0,0 +1,6 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class ResultLevelModel extends BaseRepositoryModel {
+    level: number;
+    kiteLevel: number;
+}

package/src/models/send-user-to-login.model.ts

@@ -0,0 +1,10 @@
+export class SendUserToAuthModel {
+    login: string;
+    password: string;
+    system_id: number;
+    recaptchaResponse?: string | null;
+    timeZone: {
+        local: string;
+        offset: number;
+    };
+}

package/src/models/term-of-use.model.ts

@@ -0,0 +1,6 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class TermsOfUseModel extends BaseRepositoryModel {
+    _id: string;
+    texto: string;
+}

package/src/models/theme-base.ts

@@ -0,0 +1,171 @@
+
+class ThemeBaseColors {
+    primary1: string;
+    primary2: string;
+    secondary1: string;
+    secondary2: string;
+    secondary3: string;
+    brand1: string;
+    brand2: string;
+    hover1: string;
+    solidBackground: string;
+    gradientBackground: string;
+    levels: {
+        shade100: string,
+        shade75: string,
+        shade50: string,
+        shade25: string,
+        radialGradient: string;
+    }[];
+    neutral90: string;
+    neutral80: string;
+    neutral70: string;
+    neutral60: string;
+    neutral50: string;
+    neutral40: string;
+    neutral30: string;
+    neutral20: string;
+    neutral10: string;
+    neutral0: string;
+    successes: {
+        text: string,
+        hover: string,
+        dark: string,
+        default: string,
+        light: string,
+        background: string
+    };
+    errors: {
+        text: string,
+        hover: string,
+        dark: string,
+        default: string,
+        light: string,
+        background: string
+    };
+    warnings: {
+        text: string,
+        hover: string,
+        dark: string,
+        default: string,
+        light: string,
+        background: string
+    };
+    itemsTags: {
+        experience: {
+            text: string,
+            background: string
+        },
+        physical: {
+            text: string,
+            background: string
+        },
+        auction: {
+            text: string,
+            background: string
+        },
+        raffle: {
+            text: string,
+            background: string
+        },
+        crowdfunding: {
+            text: string,
+            background: string
+        },
+        voucher: {
+            text: string,
+            background: string
+        }
+    };
+    complementary: {
+        agendaReminder: string;
+    };
+
+}
+
+export type IconHandle = 'active-bold' | 'active-thin' | 'add-challenge-bold' | 'avatar-login' | 'add-challenge-thin' | 'add-notification-bold' | 'add-notification-thin' | 'add-quiz-bold' | 'add-quiz-thin' | 'angel-friend-add-bold' | 'angel-friend-add-thin' | 'angel-friend-bold' | 'angel-friend-thin' | 'attachment-bold' | 'attachment-thin' | 'auction-bold' | 'auction-thin' | 'available-bold' | 'available-thin' | 'broadcast-bold' | 'broadcast-thin' | 'calendar-bold' | 'calendar-thin' | 'camera-bold' | 'camera-thin' | 'cancel-bold' | 'cancel-thin' | 'challenge-bold' | 'challenge-thin' | 'chat-bold' | 'chatbot-bold' | 'chatbot-thin' | 'chat-fil-bold' | 'chat-fill-thin' | 'chat-smile-bold' | 'chat-smile-thin' | 'chat-thin' | 'check-bold' | 'check-thin' | 'chocolate-menu' | 'chronometer-bold' | 'chronometer-thin' | 'clock-bold' | 'clock-thin' | 'close-bold' | 'close-thin' | 'cloud-bold' | 'cloud-thin' | 'coin-bold' | 'coin-thin' | 'column-view-active-bold' | 'column-view-active-thin' | 'column-view-bold' | 'column-view-thin' | 'contacts-bold' | 'contacts-thin' | 'delete-bold' | 'delete-thin' | 'documents-bold' | 'documents-thin' | 'down-arrow' | 'download-bold' | 'download-thin' | 'downward-arrow-bold' | 'downward-arrow-thin' | 'duplicate-bold' | 'duplicate-thin' | 'eagle-bold' | 'eagle-thin' | 'edit-bold' | 'edit-thin' | 'emoji-bold' | 'emoji-thin' | 'family-bold' | 'family-thin' | 'filter-active-bold' | 'filter-active-thin' | 'filter-inactive-bold' | 'filter-inactive-thin' | 'filter' | 'forward-bold' | 'forward-thin' | 'goal-bold' | 'goal-thin' | 'grid-view-active-bold' | 'grid-view-active-thin' | 'grid-view-bold' | 'grid-view-thin' | 'group-bold' | 'group-brackets-bold' | 'group-brackets-thin' | 'group-fill-bold' | 'group-fill-thin' | 'group-thin' | 'guide-bold' | 'guide-thin' | 'health-bold' | 'health-thin' | 'heart-bold' | 'heart-fill-bold' | 'heart-fill-thin' | 'heart-thin' | 'humor-bold' | 'humor-thin' | 'inactive-bold' | 'inactive-thin' | 'indicator-bold' | 'indicator-thin' | 'info-bold' | 'info-thin' | 'integration-bold' | 'integration-thin' | 'learning-bold' | 'learning-thin' | 'leave-bold' | 'leave-thin' | 'left-arrow-large' | 'left-arrow-small' | 'like-bold' | 'like-fill-bold' | 'like-fill-thin' | 'like-thin' | 'magnifying-glass-bold' | 'magnifying-glass-thin' | 'minus' | 'more-vert' | 'mountain-bold' | 'mountain-thin' | 'new-document-bold' | 'new-document-thin' | 'new-tip-thin-1' | 'new-tip-thin' | 'notification-bold' | 'notification-thin' | 'objetive-bold' | 'objetive-thin' | 'order-bold-1' | 'order-bold' | 'order-thin-1' | 'order-thin' | 'performance-bold' | 'performance-thin' | 'phone-bold' | 'phone-thin' | 'plus' | 'quiz-bold' | 'quiz-thin' | 'raffle-bold' | 'raffle-draw-bold' | 'raffle-draw-thin' | 'raffle-thin' | 'relationship-bold' | 'relationship-thin' | 'reports-bold' | 'reports-thin' | 'right-arrow-large' | 'right-arrow-small' | 'send-bold' | 'send-thin' | 'settings-bold' | 'settings-thin' | 'star-bold' | 'star-thin' | 'store-bold' | 'store-item-bold' | 'store-item-thin' | 'store-thin' | 'tag-bold' | 'tag-thin' | 'test-bold' | 'test-thin' | 'tips-bold' | 'tips-thin' | 'tree-bold' | 'tree-thin' | 'trophy-bold' | 'trophy-thin' | 'up-arrow' | 'upload-bold' | 'upload-thin' | 'upward-arrow-bold' | 'upward-arrow-thin' | 'user-bold' | 'user-thin' | 'variable-pay-bold' | 'variable-pay-thin' | 'view-bold' | 'view-thin' | 'not-view-thin' | 'not-view-bold' | 'work-bold' | 'working' | 'work-thin';
+
+class ThemeBaseRect {
+    top: string;
+    right: string;
+    bottom: string;
+    left: string;
+}
+
+class ThemeTypography {
+    fontFamily: string; // font-family
+    size: string; // size
+    textTransform: string; //text-transform
+    letterSpacing: string; //letter-spacing
+    lineHeight: string; //line-height
+    fontWeight: string; //font-weight
+}
+
+class ThemeTransition {
+    transitionPrimary1: string;
+}
+
+class ThemeAssets {
+    src: string;
+    width: string;
+    height: string;
+}
+
+export class ThemeBase {
+    colors: ThemeBaseColors;
+    fonts: {
+        fontFamily: string; // font-family
+        fontWeight: string; // font-weight
+        fontStyle: string; // font-style
+        src: string; // src  
+    }[];
+    transitions: ThemeTransition;
+    typography: {
+        h1: ThemeTypography,
+        h2: ThemeTypography,
+        h3: ThemeTypography,
+        h4: ThemeTypography,
+        h5: ThemeTypography,
+        h6: ThemeTypography,
+        subtitle1: ThemeTypography,
+        subtitle2: ThemeTypography,
+        body1Medium: ThemeTypography,
+        body1Book: ThemeTypography,
+        body1BookItalic: ThemeTypography,
+        body1Link: ThemeTypography,
+        body2Medium: ThemeTypography,
+        body2Book: ThemeTypography,
+        buttonMedium: ThemeTypography,
+        chip: ThemeTypography,
+        chipMedium: ThemeTypography,
+        overline: ThemeTypography,
+        small: ThemeTypography,
+        toolTip: ThemeTypography,
+    };
+    assets: {
+        logoText: ThemeAssets;
+        logoComplete: ThemeAssets;
+        logoIcon: ThemeAssets;
+        logoTextNegative: ThemeAssets;
+        logoCompleteNegative: ThemeAssets;
+        logoIconNegative: ThemeAssets;
+        backgroundLogo: ThemeAssets;
+        logoMobile: ThemeAssets;
+        loginRobbysonAvatar: ThemeAssets;
+    };
+
+    constructor() {
+        this.colors = new ThemeBaseColors();
+        this.assets = {
+            logoText: new ThemeAssets(),
+            logoComplete: new ThemeAssets(),
+            logoIcon: new ThemeAssets(),
+            logoTextNegative: new ThemeAssets(),
+            logoCompleteNegative: new ThemeAssets(),
+            logoIconNegative: new ThemeAssets(),
+            backgroundLogo: new ThemeAssets(),
+            logoMobile: new ThemeAssets(),
+            loginRobbysonAvatar: new ThemeAssets(),
+        };
+    }
+};

package/src/models/user-mirror.model.ts

@@ -0,0 +1,10 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+
+export class UserMirrorModel extends BaseRepositoryModel {
+    beginDate: Date;
+    endDate: Date;
+    identification: string;
+    name: string;
+    user_id: string;
+    _id: string;
+}

package/src/models/user-session.model.ts

@@ -0,0 +1,103 @@
+import { BaseRepositoryModel } from "./base.repository.model";
+import { UserMirrorModel } from "./user-mirror.model";
+
+export class UserSessionModel extends BaseRepositoryModel {
+    _id: number;
+    name: string;
+    identification: string;
+    externalKey: string;
+    RobbysonUserId: number;
+    primaryAttribute: {
+        attribute: {
+            _id: string,
+            primary: boolean
+        },
+        _id: string,
+        active: boolean
+    };
+    passwordUpdatedAt: Date;
+    hierarchy: {
+        hierarchyLevel: {
+            _id: string,
+            name: string,
+            weight: number,
+            permission: {
+                application: {
+                    _id: number,
+                    description: string
+                },
+                _id: string,
+                send?: boolean,
+                receive?: boolean
+            }[]
+        },
+        parents: string[];
+        _id: string;
+        date: Date;
+        identification: string,
+        attributes:
+        {
+            attribute: {
+                _id: string,
+                primary: boolean
+            },
+            _id: string,
+            active: boolean
+        }[],
+        name: string
+    };
+    nickname: string;
+    about: string;
+    contractor: { // @TODO: this field is not completed filled as ClienteRobbyson and both needs to be the same, fix it at service-authentication
+        _id: number,
+        active: boolean,
+        closingDay: number,
+        coins_indicator_id: number,
+        enableEAD: boolean,
+        enableHumor: boolean,
+        enableRobbysonCorporateApp: boolean,
+        enableMeetings: boolean,
+        locale: {
+            identifier: string,
+            name: string
+        },
+        minDaysToEarnCoins: number,
+        name: string,
+        timezone: string,
+        usesAccessControl: boolean,
+        usesCustomClosingDay: boolean,
+        usesExternalAuthentication: boolean,
+        passwordLength?: number,
+        passwordExpirationDays?: number,
+        usesSpeedTest: boolean,
+        sessionTime?: boolean
+    };
+    ClienteRobbyson: { // @TODO: Merge it with contractor
+        IdIndicadorTaxaAcesso: number,
+        IdIndicadorHumorToPraBaixo: number,
+        IdIndicadorHumorToDeBoa: number,
+        IdIndicadorHumorTopDeMais: number,
+        IdClassificacaoMensagemPrivada: number,
+        usesRobbysonAuthentication: boolean,
+        externalAuth?: boolean,
+        usesCustomClosingDay: boolean,
+        idAngelFriendClassification: number,
+        enableGuidance: boolean,
+        treeVisualizationMonths: number,
+        embeddedThirdPartyRv: boolean,
+        chatSendFiles: boolean,
+        chatMaxSizeFile?: number
+    };
+    UsuarioAceitouTermoUsoAtual: boolean;
+    isAcceptedLastUseTerm: boolean;
+    UsuarioJaLogou: boolean;
+    firstAccess: boolean;
+    forceAvatarDisplay?: boolean;
+    Admin: boolean;
+    Operation: boolean;
+    login: string;
+    system_id: number;
+    mirror: boolean;
+    userMirror?: UserMirrorModel;
+    SessionKey: string;
+}

package/src/repositories/angel-friend.repository.interface.ts

@@ -0,0 +1,5 @@
+import { AngelFriendStatusModel } from "../models";
+
+export interface IAngelFriendRepository {
+    getAngelFriendStatus(_id: number): Promise<AngelFriendStatusModel>;
+}

package/src/repositories/authentication.repository.interface.ts

@@ -0,0 +1,14 @@
+import { UserSessionModel, SendUserToAuthModel } from "../models";
+
+export interface IAuthenticationRepository {
+    auth({
+        login,
+        password,
+        system_id,
+        recaptchaResponse,
+        timeZone,
+    }: SendUserToAuthModel): Promise<UserSessionModel>;
+
+    getRecaptchaWhiteListed(): Promise<boolean>;
+  
+}

package/src/repositories/base.repository.tsx

@@ -0,0 +1,128 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import moment from 'moment';
+import { CacheConfig, CacheControl, Cache } from '../utils';
+import sha1 from 'crypto-js/sha1';
+import { GlobalStore, IGlobalStore } from 'redux-micro-frontend';
+import { IPlatformState } from '../states';
+import { ResponseFactory } from '../factories';
+
+export class BaseRepository {
+
+    protected _axioInstance: AxiosInstance;
+    private static _sessionKey: string = "";
+    private static _systemId: number = 1;
+    private static _baseURL: string = "";
+    private static _source: any;
+
+    private static _globalStore: IGlobalStore;
+    private static _globalState: IPlatformState;
+
+    public constructor() {
+        this._axioInstance = axios.create({
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        BaseRepository.updateGlobalState();
+        this.configure();
+    }
+
+    protected static updateGlobalState() {
+        BaseRepository._globalStore = GlobalStore.Get();
+        BaseRepository._globalState = BaseRepository._globalStore.GetGlobalState();
+    }
+
+    protected async get<T>(url: string, config?: CacheConfig): Promise<T> {
+        if (config && config.cache) {
+            return new Promise(async (resolve, reject) => {
+                try {
+
+                    const key: string = sha1(
+                        url + JSON.stringify(config.params),
+                    ).toString();
+
+                    const { expire, value }: Cache =
+                        (await CacheControl.getCache(key)) || {};
+
+                    const isExpired: boolean = moment().isSameOrAfter(
+                        moment(expire),
+                    );
+
+                    if (value && !isExpired) {
+                        console.log('RECOVERED FROM CACHE', url);
+                        return setTimeout(
+                            () => resolve(value),
+                            config.delayOnCache || 0,
+                        );
+                    }
+
+                    const response = ResponseFactory.Create<T>(await this._axioInstance.get(url, config));
+                    console.log('SENT REQUEST', url);
+                    CacheControl.setCache(
+                        key,
+                        response,
+                        config.maxAge || [0, 'seconds'],
+                        config.type,
+                    );
+                    return setTimeout(
+                        () => resolve(response),
+                        config.delayOnCache || 0,
+                    );
+                } catch (error) {
+                    console.log('====================> ERROR CACHE', error);
+                    reject(error);
+                }
+            });
+        }
+        return ResponseFactory.Create<T>(await this._axioInstance.get(url, config));
+    }
+
+    protected async post<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>( await this._axioInstance.post(url, data, config));
+    }
+
+    protected async delete<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.delete(url, config));
+    }
+
+    protected async put<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.put(url, data, config));
+    }
+
+    protected async patch<T>(url: string, data: any, config?: AxiosRequestConfig): Promise<T> {
+        return ResponseFactory.Create<T>(await this._axioInstance.patch(url, data, config));
+    }
+
+    public configure() {
+        this._axioInstance.interceptors.request.clear();
+        this._axioInstance.interceptors.request.use(
+            this.axioConfigurationMiddleware,
+            error => Promise.reject(error),
+        );
+        this._axioInstance.interceptors.response.use((res) => {
+            return res
+        }, (err) => {
+            Promise.reject(ResponseFactory.Create<any>(err))
+        })
+    }
+
+    public axioConfigurationMiddleware(config: any) {
+        BaseRepository.updateGlobalState();
+
+        config.url = `${BaseRepository._globalState.Global.RootApp.apisUrls.private}${config.url}`;
+        if (BaseRepository._source && BaseRepository._source.token) {
+            config.cancelToken = BaseRepository._source.token;
+        }
+
+        const sessionKey = BaseRepository._globalState.Global.RootApp.userSession?.SessionKey;
+        
+        if (sessionKey) {
+            config.headers.SessionKey = sessionKey;
+        }
+
+        config.headers['x-system-id'] = BaseRepository._systemId;
+
+        return config;
+    }
+}

package/src/repositories/index.d.ts

@@ -0,0 +1,7 @@
+export * from './authentication.repository.interface';
+export * from './locale.repository.interface';
+export * from './theme.repository.interface';
+export * from './results.repository.interface';
+export * from './angel-friend.repository.interface';
+export * from './user.repository.interface';
+export * from "./terms-of-use.repository.interface";

package/src/repositories/locale.repository.interface.ts

@@ -0,0 +1,4 @@
+export interface ILocaleRepository {
+    getByContractor(contractorId: number, languageIdentifier: string): Promise<any>;
+    getByHeader(): Promise<any>;
+}

package/src/repositories/results.repository.interface.ts

@@ -0,0 +1,5 @@
+import { ResultLevelModel } from "../models";
+
+export interface IResultsRepository {
+    getMonthlyKiteLevelResults(identification: string): Promise<ResultLevelModel>;
+}

package/src/repositories/terms-of-use.repository.interface.ts

@@ -0,0 +1,6 @@
+import { TermsOfUseModel } from "../models";
+
+export interface ITermsOfUseRepository {
+    getTermsOfUse(attributesIds: string[]): Promise<TermsOfUseModel>;
+    acceptTermsOfUse(_id: string): Promise<void>;
+}

package/src/repositories/theme.repository.interface.ts

@@ -0,0 +1,5 @@
+import { ThemeBase } from "../models/theme-base";
+
+export interface IThemeRepository {
+    getContractorTheme(contractorId: number): Promise<ThemeBase>;
+}

package/src/repositories/user.repository.interface.ts

@@ -0,0 +1,15 @@
+import { UserMirrorModel } from "../models";
+
+export interface IUserRepository {
+    getRobbysonUser(body: {
+        filter: {
+            robbyson_user_id: number[],
+        },
+        pagination: {
+            limit: number,
+        },
+    }): Promise<any>;
+
+    getUserMirror(_id: number): Promise<UserMirrorModel>;
+    
+}

package/src/services/angel-friend.service.interface.ts

@@ -0,0 +1,3 @@
+export interface IAngelFriendService {
+    getAngelFriendStatus(_id: number): Promise<void>;
+}

package/src/services/authentication.service.interface.ts

@@ -0,0 +1,17 @@
+import { SendUserToAuthModel, UserSessionModel } from "../models";
+
+export interface IAuthenticationService {
+    auth({
+        login,
+        password,
+        system_id,
+        recaptchaResponse,
+    }: SendUserToAuthModel): Promise<UserSessionModel>;
+
+    getLoggedUser(): UserSessionModel;
+    checkSession(): boolean;
+    getUserSession(): UserSessionModel | undefined
+    clearSession(): void;
+    ipWhiteList(): boolean;
+    getRecaptchaWhiteListed(): Promise<void>;
+}

package/src/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./authentication.service.interface";
+export * from "./locale.service.interface";
+export * from "./theme.service.interface";
+export * from "./results.service.interface";
+export * from "./angel-friend.service.interface";
+export * from "./user.service.interface";
+export * from "./terms-of-use.service.interface";

package/src/services/locale.service.interface.ts

@@ -0,0 +1,4 @@
+export interface ILocaleService {
+    setApplicationLocale(contractorId?: number, languageIdentifier?: string): Promise<Boolean>;
+    getLocaleByHandle(handle: string, ...args: string[]): string
+}

package/src/services/results.service.interface.ts

@@ -0,0 +1,3 @@
+export interface IResultsService {
+    getMonthlyKiteLevelResults(identification: string): Promise<void>;
+}

package/src/services/terms-of-use.service.interface.ts

@@ -0,0 +1,7 @@
+import { TermsOfUseModel } from "../models";
+
+export interface ITermsOfUseService {
+    getTermsOfUse(attributesIds: string[]): Promise<TermsOfUseModel>;
+    acceptTermsOfUse(_id: string): Promise<void>;
+    acceptTermsOfUseAndUpdateUserSession(_id: string): Promise<void>;
+}

package/src/services/theme.service.interface.ts

@@ -0,0 +1,8 @@
+import { IconHandle } from "../models";
+
+export interface IThemeService {
+    setApplicationTheme(contractorId?: number): Promise<Boolean>;
+    getIconAssetUrl(iconHandle: IconHandle): string;
+    getIconsList(): readonly IconHandle[];
+    getIconsPath(): string;
+}

package/src/services/user.service.interface.ts

@@ -0,0 +1,14 @@
+import { UserMirrorModel } from "../models";
+
+export interface IUserService {
+    getRobbysonUser(body: {
+        filter: {
+            robbyson_user_id: number[],
+        },
+        pagination: {
+            limit: number,
+        },
+    }): Promise<any>;
+
+    getUserMirror(_id: number): Promise<UserMirrorModel>;
+}

package/src/states/index.ts

@@ -0,0 +1,3 @@
+export * from './main-container/plataform.state.interface';
+export * from './main-container/app.state.interface';
+export * from './main-container/root-app.state.interface';