@unipin/angular-applet 18.9.7 → 21.0.1

package/package.json

@@ -1,43 +1,146 @@
 {
   "name": "@unipin/angular-applet",
-  "version": "18.9.7",
-  "sideEffects": false,
-  "homepage": "https://backoffice.unipin.com/",
-  "description": "Angular specific wrappers for UniPin applet",
+  "version": "21.0.1",
   "peerDependencies": {
-    "@angular-architects/module-federation-tools": "17.x.x",
-    "@angular/common": "18.x.x",
-    "@angular/core": "18.x.x",
-    "@ionic/angular": "7.x.x",
-    "ionicons": "^7.x.x",
-    "@apollo/client": "3.x.x",
-    "apollo-angular": "8.x.x",
-    "graphql": "16.x.x"
+    "@angular/cdk": "21.x.x",
+    "@angular/common": "21.x.x",
+    "@angular/core": "21.x.x",
+    "@angular/elements": "21.x.x",
+    "@unipin/angular-gql": "1.x.x",
+    "@ng-icons/core": "33.x.x",
+    "@ng-icons/material-icons": "33.x.x",
+    "@ng-select/ng-select": "21.x.x",
+    "angular-froala-wysiwyg": "4.x.x",
+    "angular-split": "20.x.x",
+    "class-variance-authority": "0.x.x",
+    "clsx": "2.x.x",
+    "date-fns": "4.x.x",
+    "ngx-json-viewer": "3.x.x",
+    "ngx-sonner": "3.x.x",
+    "tailwind-merge": "3.x.x",
+    "marked": "17.x.x"
   },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "angular-split": "18.x.x",
-    "@angular/elements": "18.x.x",
-    "@ng-select/ng-select": "13.x.x",
-    "@ag-grid-community/core": "31.x.x",
-    "@ag-grid-community/angular": "31.x.x",
-    "@ag-grid-community/client-side-row-model": "31.x.x",
-    "@ag-grid-community/infinite-row-model": "31.x.x"
+    "tslib": "^2.3.0"
   },
+  "sideEffects": false,
+  "module": "fesm2022/unipin-angular-applet.mjs",
+  "typings": "types/unipin-angular-applet.d.ts",
   "exports": {
-    "./scss/*": {
-      "style": "./src/assets/scss/*"
-    },
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/unipin-angular-applet.mjs",
-      "esm": "./esm2022/unipin-angular-applet.mjs",
+      "types": "./types/unipin-angular-applet.d.ts",
       "default": "./fesm2022/unipin-angular-applet.mjs"
+    },
+    "./accordion": {
+      "types": "./types/unipin-angular-applet-accordion.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-accordion.mjs"
+    },
+    "./alert": {
+      "types": "./types/unipin-angular-applet-alert.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-alert.mjs"
+    },
+    "./alert-dialog": {
+      "types": "./types/unipin-angular-applet-alert-dialog.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-alert-dialog.mjs"
+    },
+    "./auth": {
+      "types": "./types/unipin-angular-applet-auth.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-auth.mjs"
+    },
+    "./avatar": {
+      "types": "./types/unipin-angular-applet-avatar.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-avatar.mjs"
+    },
+    "./badge": {
+      "types": "./types/unipin-angular-applet-badge.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-badge.mjs"
+    },
+    "./buttons": {
+      "types": "./types/unipin-angular-applet-buttons.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-buttons.mjs"
+    },
+    "./calendar": {
+      "types": "./types/unipin-angular-applet-calendar.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-calendar.mjs"
+    },
+    "./collapsible": {
+      "types": "./types/unipin-angular-applet-collapsible.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-collapsible.mjs"
+    },
+    "./common": {
+      "types": "./types/unipin-angular-applet-common.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-common.mjs"
+    },
+    "./containers": {
+      "types": "./types/unipin-angular-applet-containers.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-containers.mjs"
+    },
+    "./dialog": {
+      "types": "./types/unipin-angular-applet-dialog.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-dialog.mjs"
+    },
+    "./forms": {
+      "types": "./types/unipin-angular-applet-forms.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-forms.mjs"
+    },
+    "./froala": {
+      "types": "./types/unipin-angular-applet-froala.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-froala.mjs"
+    },
+    "./grids": {
+      "types": "./types/unipin-angular-applet-grids.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-grids.mjs"
+    },
+    "./infinite-scroll": {
+      "types": "./types/unipin-angular-applet-infinite-scroll.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-infinite-scroll.mjs"
+    },
+    "./json-viewer": {
+      "types": "./types/unipin-angular-applet-json-viewer.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-json-viewer.mjs"
+    },
+    "./loading-dialog": {
+      "types": "./types/unipin-angular-applet-loading-dialog.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-loading-dialog.mjs"
+    },
+    "./markdown": {
+      "types": "./types/unipin-angular-applet-markdown.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-markdown.mjs"
+    },
+    "./micro-frontend": {
+      "types": "./types/unipin-angular-applet-micro-frontend.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-micro-frontend.mjs"
+    },
+    "./popover": {
+      "types": "./types/unipin-angular-applet-popover.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-popover.mjs"
+    },
+    "./progress-bar": {
+      "types": "./types/unipin-angular-applet-progress-bar.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-progress-bar.mjs"
+    },
+    "./skeleton": {
+      "types": "./types/unipin-angular-applet-skeleton.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-skeleton.mjs"
+    },
+    "./spinner": {
+      "types": "./types/unipin-angular-applet-spinner.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-spinner.mjs"
+    },
+    "./swipeable": {
+      "types": "./types/unipin-angular-applet-swipeable.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-swipeable.mjs"
+    },
+    "./tabs": {
+      "types": "./types/unipin-angular-applet-tabs.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-tabs.mjs"
+    },
+    "./tooltip": {
+      "types": "./types/unipin-angular-applet-tooltip.d.ts",
+      "default": "./fesm2022/unipin-angular-applet-tooltip.mjs"
     }
-  },
-  "module": "fesm2022/unipin-angular-applet.mjs",
-  "typings": "index.d.ts"
+  }
 }

package/types/unipin-angular-applet-accordion.d.ts

@@ -0,0 +1,60 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare class UpAccordionDirective implements OnInit {
+    readonly dir: _angular_core.InputSignal<"ltr" | "rtl">;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly type: _angular_core.ModelSignal<"single" | "multiple">;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | string[]>;
+    readonly value: _angular_core.ModelSignal<string | string[] | undefined>;
+    readonly defaultValue: _angular_core.ModelSignal<string | string[] | undefined>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAccordionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAccordionDirective, "[upAccordion]", ["upAccordion"], { "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; }, { "type": "typeChange"; "valueChange": "valueChange"; "value": "valueChange"; "defaultValue": "defaultValueChange"; }, never, never, true, never>;
+}
+
+declare class UpAccordionItemDirective {
+    readonly wrapper: UpAccordionDirective;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly isOpened: _angular_core.ModelSignal<boolean>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _computedClass: _angular_core.Signal<string>;
+    constructor(wrapper: UpAccordionDirective);
+    setOpen(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAccordionItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAccordionItemDirective, "[upAccordionItem]", ["upAccordionItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "isOpened": { "alias": "isOpened"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "isOpened": "isOpenedChange"; }, never, never, true, never>;
+}
+
+declare class UpAccordionTriggerDirective {
+    readonly item: UpAccordionItemDirective;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected _computedClass: _angular_core.Signal<string>;
+    constructor(item: UpAccordionItemDirective);
+    toggleState(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    protected focusNextItem(): void;
+    protected focusPreviousItem(): void;
+    protected focusFirstItem(): void;
+    protected focusLastItem(): void;
+    protected getAllTriggers(): HTMLElement[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAccordionTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAccordionTriggerDirective, "[upAccordionTrigger]", never, { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpAccordionContentDirective {
+    protected readonly item: UpAccordionItemDirective;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected _computedClass: _angular_core.Signal<string>;
+    constructor(item: UpAccordionItemDirective);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAccordionContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAccordionContentDirective, "[upAccordionContent]", ["upAccordionContent"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { UpAccordionContentDirective, UpAccordionDirective, UpAccordionItemDirective, UpAccordionTriggerDirective };

package/types/unipin-angular-applet-alert-dialog.d.ts

@@ -0,0 +1,35 @@
+import { ButtonVariants } from '@unipin/angular-applet/buttons';
+import { UpDialogService, UpDialogRef } from '@unipin/angular-applet/dialog';
+import * as i0 from '@angular/core';
+
+type AlertOptions = {
+    title: string;
+    buttons: AlertButton[];
+    description?: string;
+    fields?: AlertFormField[];
+};
+type AlertButton = {
+    text: string;
+    additionalClass?: string;
+    variant?: ButtonVariants['variant'];
+    handler?: (form?: Record<string, any>) => void;
+};
+type AlertFormField = {
+    name: string;
+    type: 'text' | 'number' | 'checkbox' | 'password';
+    required?: boolean;
+    placeholder?: string;
+};
+
+declare class UpAlertController {
+    protected dialog: UpDialogService;
+    protected readonly MAX_FIELDS = 3;
+    protected readonly MAX_BUTTONS = 2;
+    constructor(dialog: UpDialogService);
+    show(options: AlertOptions, canDismiss?: boolean): UpDialogRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpAlertController, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpAlertController>;
+}
+
+export { UpAlertController };
+export type { AlertButton, AlertFormField, AlertOptions };

package/types/unipin-angular-applet-alert.d.ts

@@ -0,0 +1,34 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as _angular_core from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariants = VariantProps<typeof alertVariants>;
+
+declare class UpAlertDirective {
+    readonly variant: _angular_core.InputSignal<"default" | "success" | "warning" | "destructive" | null | undefined>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAlertDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAlertDirective, "[upAlert]", ["upAlert"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpAlertTitleDirective {
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAlertTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAlertTitleDirective, "[upAlertTitle]", ["upAlertTitle"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpAlertDescriptionDirective {
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAlertDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAlertDescriptionDirective, "[upAlertDescription]", ["upAlertDescription"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { UpAlertDescriptionDirective, UpAlertDirective, UpAlertTitleDirective, alertVariants };
+export type { AlertVariants };

package/types/unipin-angular-applet-auth.d.ts

@@ -0,0 +1,225 @@
+import { AppLoginSubject, Maybe, MutationAuthMsRefreshAccessTokenArgs, Token, LoginRq, LoginResponse, PermissionFilter, AppPermDfn } from '@unipin/graphql-schema';
+import * as i0 from '@angular/core';
+import { Provider, WritableSignal, TemplateRef, ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
+import { CanActivateFn, Router, ActivatedRoute } from '@angular/router';
+import { HttpInterceptorFn } from '@angular/common/http';
+import { Observable, Subscription } from 'rxjs';
+import { GqlParser, CacheStrategy, QueryResult, MutationResult } from '@unipin/angular-gql';
+
+type User = AppLoginSubject & {
+    email: string;
+    photo: string;
+    mobileNumber?: string | null;
+};
+
+type LoadingConfig = {
+    permTypes: string[];
+    permModules: string[];
+    subjectGuidStorageKey?: string;
+};
+declare function provideLoadingConfig(config: LoadingConfig): Provider;
+
+declare const authGuard: CanActivateFn;
+
+declare const permissionGuard: CanActivateFn;
+
+declare const authorizationInterceptor: HttpInterceptorFn;
+
+declare const refreshTokenInterceptor: HttpInterceptorFn;
+
+/**
+ * The `AuthResolver` service provides methods for handling authentication-related tasks,
+ * such as checking user login status, retrieving authentication tokens, and managing token expiration.
+ */
+declare class AuthResolver {
+    /**
+     * Checks if the user is logged in by verifying the presence of an authentication token.
+     * @returns {boolean} - True if the user is logged in; otherwise, false.
+     */
+    isUserLoggedIn(): boolean;
+    /**
+     * Retrieves the authentication token, resolving it if needed.
+     * @returns {string | null} - The authentication token if the user is logged in; otherwise, null.
+     */
+    getAuthToken(): string | null;
+    /**
+     * Resolves the user's authentication token by checking expiration and whether the user still logged in or not.
+     */
+    protected resolveUserAuthToken(): void;
+    /**
+     * Checks if a given token is expired or not yet.
+     * @param {string | null} token - The token to be checked for expiration.
+     * @returns {boolean} - True if the token is expired; otherwise, false.
+     */
+    protected isTokenExpired(token: string | null): boolean;
+    /**
+     * Retrieves the expiration date of a token.
+     * @param {string | null} token - The token for which to retrieve the expiration date.
+     * @returns {Date | null} - The expiration date of the token if available; otherwise, null.
+     */
+    protected getTokenExpirationDate(token: string | null): Date | null;
+    /**
+     * Decodes a JWT token to extract payload information.
+     * @param {string | null} token - The JWT token to be decoded.
+     * @returns {string | null} - The decoded payload as a string if successful; otherwise, null.
+     */
+    protected decodeToken(token: string | null): string | null;
+    /**
+     * Decodes a base64url-encoded string.
+     * @param {string} str - The base64url-encoded string to be decoded.
+     * @returns {string} - The decoded string.
+     */
+    protected urlBase64Decode(str: string): string;
+    /**
+     * Decodes a Unicode string from a base64-encoded string.
+     * @param {string} str - The base64-encoded string to be decoded.
+     * @returns {string} - The decoded Unicode string.
+     */
+    protected b64DecodeUnicode(str: string): string;
+    /**
+     * Decodes a base64-encoded string.
+     * @param {string} str - The base64-encoded string to be decoded.
+     * @returns {string} - The decoded string.
+     */
+    protected b64decode(str: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthResolver>;
+}
+
+declare class ProfileService {
+    protected readonly gql: GqlParser;
+    constructor(gql: GqlParser);
+    transformSubjetToUser(subject: AppLoginSubject): User;
+    /**
+     * A method to get the user profile information.
+     * @param {string} extraAttr - Contain extra attribute to get the user profile information.
+     * @param {CacheStrategy | undefined} cacheStrategy - Specifies how Apollo Client should handle data retrieval, determining whether it should make a network request to fetch fresh data from the server or use data from the local cache.
+     *
+     * @returns {Observable<QueryResult<{ authMsMyProfile: Maybe<AppLoginSubject> }>>} Contain user profile information.
+     */
+    getMyProfile(extraAttr?: string, cacheStrategy?: CacheStrategy): Observable<QueryResult<{
+        authMsMyProfile: Maybe<AppLoginSubject>;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileService>;
+}
+
+declare class AuthService {
+    protected readonly gql: GqlParser;
+    protected readonly profileService: ProfileService;
+    /**
+     * Both `authToken` and `refreshToken` are public static variable to store the auth token and refresh token obtained form the login API.
+     * They will be set as header param inside API calls.
+     * @type {string}
+     *
+     * @default ''
+     */
+    static authToken: string;
+    static refreshToken: string;
+    /**
+     * A public variable to store the logined user information.
+     * @type {User} An interface contain user information.
+     * @default {} as User
+     */
+    user: WritableSignal<User>;
+    constructor(gql: GqlParser, profileService: ProfileService);
+    static logout(): void;
+    logout(): void;
+    /**
+     * This method is used by the `refreshTokenInterceptor`, to get the new token shortly before the auth token is expired.
+     * @param {MutationAuthMsRefreshAccessTokenArgs} variables - Contain `refreshToken` attribute which is the current refresh token.
+     * @returns {Observable<MutationResult<{ authMsRefreshAccessToken: Token }>>} Contain new `authToken` and `refreshToken`.
+     */
+    refreshToken(variables: MutationAuthMsRefreshAccessTokenArgs): Observable<MutationResult<{
+        authMsRefreshAccessToken: Token;
+    }>>;
+    /**
+     * A method to authenticate the user to get the session for applet or platform.
+     * When successful it will set the user information to the `user` variable, `authToken` and `refreshToken`.
+     * It will set the `authToken`, `refreshToken`, `userGuid` and `roles` to the localStorage also for API calls.
+     *
+     * @param {{ email: string, password: string, sourcePlatform: string }} input - Contain `email` which is registered user email, `password` which is registered user password and `sourcePlatform` it's value can be `ADMIN` to get the applet session or `CP_COMMERCE` to get the platform session.
+     *
+     * @returns {Observable<MutationResult<{ authMsLogin: LoginResponse }>>} Contain logined user information.
+     */
+    login(input: LoginRq): Observable<MutationResult<{
+        authMsLogin: LoginResponse;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+declare class PermissionService {
+    protected readonly gql: GqlParser;
+    readonly permissions: i0.WritableSignal<Map<string, boolean>>;
+    /**
+     * A boolean value that tells the permission service is initiated (permissions list is retrieved from Backend) or not.
+     * @default false
+     */
+    isInitiated: boolean;
+    constructor(gql: GqlParser);
+    /**
+     * A method that checking if the user has the permission or not based on the params value.
+     * @param {string} permission - Permission code that wanted to be checked
+     *
+     * @returns {boolean} Contain boolean value that tells the user has the permission or not.
+     */
+    has(permission: string): boolean;
+    /**
+     * A method that set the permissions and permission modules.
+     * @param {string[]} permCodes - Contain list of permission codes.
+     */
+    setPermission(permCodes: string[]): void;
+    /**
+     * A method that get the query value with authMsPermission as the object.
+     * @param {PermissionFilter} filter - Contain filter as a conditions for the query.
+     * @returns {Observable<ApolloQueryResult<{ authMsPermission: { data: AppPermDfn[] }}>>} Contain query value.
+     */
+    getPermissions(filter: PermissionFilter, cacheStrategy?: CacheStrategy): Observable<QueryResult<{
+        authMsPermission: {
+            data: AppPermDfn[];
+        };
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionService>;
+}
+
+/**
+ * The `PermissionDirective` is a directive that conditionally renders content based on user permissions.
+ * @selector '[hasPermission]'
+ *
+ * @example
+ * ```html
+ *   <div *hasPermission="'MERCHANT.CONTRACT.READ'"></div>
+ * ```
+ */
+declare class PermissionDirective {
+    protected readonly service: PermissionService;
+    protected readonly templateRef: TemplateRef<any>;
+    protected readonly viewContainer: ViewContainerRef;
+    constructor(service: PermissionService, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    set hasPermission(permission: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PermissionDirective, "[hasPermission]", ["hasPermission"], { "hasPermission": { "alias": "hasPermission"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class UnauthorizedPage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnauthorizedPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UnauthorizedPage, "up-unauthorized", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoadingPage implements OnInit, OnDestroy {
+    readonly config: LoadingConfig;
+    protected readonly router: Router;
+    protected readonly route: ActivatedRoute;
+    protected readonly permissionService: PermissionService;
+    protected sub?: Subscription;
+    constructor(config: LoadingConfig, router: Router, route: ActivatedRoute, permissionService: PermissionService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingPage, "up-loading", never, {}, {}, never, never, true, never>;
+}
+
+export { AuthResolver, AuthService, LoadingPage, PermissionDirective, PermissionService, ProfileService, UnauthorizedPage, authGuard, authorizationInterceptor, permissionGuard, provideLoadingConfig, refreshTokenInterceptor };
+export type { LoadingConfig, User };

package/types/unipin-angular-applet-avatar.d.ts

@@ -0,0 +1,16 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, Renderer2 } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare class UpAvatarDirective {
+    protected readonly el: ElementRef;
+    protected readonly renderer: Renderer2;
+    readonly initialText: _angular_core.InputSignal<string>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    constructor(el: ElementRef, renderer: Renderer2);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpAvatarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpAvatarDirective, "[upAvatar]", ["upAvatar"], { "initialText": { "alias": "initial"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { UpAvatarDirective };

package/types/unipin-angular-applet-badge.d.ts

@@ -0,0 +1,20 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as _angular_core from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariants = VariantProps<typeof badgeVariants>;
+
+declare class UpBadgeDirective {
+    readonly variant: _angular_core.InputSignal<"default" | "secondary" | "destructive" | "outline" | null | undefined>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpBadgeDirective, "[upBadge]", ["upBadge"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { UpBadgeDirective, badgeVariants };
+export type { BadgeVariants };

package/types/unipin-angular-applet-buttons.d.ts

@@ -0,0 +1,37 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as _angular_core from '@angular/core';
+import { ElementRef, ModelSignal } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare const buttonVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+
+declare class UpButtonDirective {
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    readonly variant: _angular_core.InputSignal<"default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpButtonDirective, "[upButton]", ["upButton"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpSplitButtonComponent {
+    readonly _buttons: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly _descriptions: _angular_core.Signal<readonly ElementRef<any>[]>;
+    readonly activeIndex: ModelSignal<number>;
+    splitBtnItems: {
+        labels: string[];
+        descriptions: string[];
+        variant: ButtonVariants["variant"][];
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpSplitButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpSplitButtonComponent, "up-split-button", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["_buttons", "_descriptions"], ["*"], true, never>;
+}
+
+export { UpButtonDirective, UpSplitButtonComponent, buttonVariants };
+export type { ButtonVariants };

package/types/unipin-angular-applet-calendar.d.ts

@@ -0,0 +1,44 @@
+import * as date_fns from 'date-fns';
+import * as _angular_core from '@angular/core';
+
+type SingleDate = Date | null;
+type RangeDate = {
+    from: Date | null;
+    to: Date | null;
+};
+
+declare class UpCalendarComponent {
+    readonly minDate: _angular_core.InputSignal<SingleDate>;
+    readonly maxDate: _angular_core.InputSignal<SingleDate>;
+    readonly variant: _angular_core.InputSignal<"single" | "range">;
+    readonly selected: _angular_core.OutputEmitterRef<SingleDate>;
+    readonly rangeSelected: _angular_core.OutputEmitterRef<RangeDate>;
+    readonly today: Date;
+    readonly activeDay: _angular_core.ModelSignal<SingleDate>;
+    readonly activeRangeDay: _angular_core.ModelSignal<RangeDate>;
+    readonly rangeTo: _angular_core.WritableSignal<SingleDate>;
+    readonly rangeFrom: _angular_core.WritableSignal<SingleDate>;
+    readonly selectedYear: _angular_core.WritableSignal<number>;
+    readonly selectedMonth: _angular_core.WritableSignal<number>;
+    readonly firstDayOfActiveMonth: _angular_core.Signal<Date>;
+    readonly daysOfMonth: _angular_core.Signal<date_fns.EachDayOfIntervalResult<{
+        start: Date;
+        end: Date;
+    }, undefined>>;
+    readonly weekDays: string[];
+    readonly months: string[];
+    readonly years: number[];
+    constructor();
+    changeMonth(event: Event): void;
+    changeYear(event: Event): void;
+    previousMonth(): void;
+    nextMonth(): void;
+    selectDate(day: Date): void;
+    protected handleRangeSelection(day: Date): void;
+    protected setRange(from: SingleDate, to: SingleDate): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpCalendarComponent, "up-calendar", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "activeDay": { "alias": "activeDay"; "required": false; "isSignal": true; }; "activeRangeDay": { "alias": "activeRangeDay"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "rangeSelected": "rangeSelected"; "activeDay": "activeDayChange"; "activeRangeDay": "activeRangeDayChange"; }, never, never, true, never>;
+}
+
+export { UpCalendarComponent };
+export type { RangeDate, SingleDate };