@taon-dev/session 21.0.216 → 21.0.240

package/full-dts/taon-notification/taon-notification.models.d.ts

@@ -0,0 +1,4 @@
+export declare enum TaonNotificationState {
+    Active = "active",
+    Inactive = "inactive"
+}

package/full-dts/taon-notification/taon-notification.provider.d.ts

@@ -0,0 +1,3 @@
+import { TaonBaseProvider } from 'taon/src';
+export declare class TaonNotificationProvider extends TaonBaseProvider {
+}

package/full-dts/taon-notification/taon-notification.repository.d.ts

@@ -0,0 +1,9 @@
+import { TaonBaseRepository } from 'taon/src';
+import { TaonNotificationEntity } from './taon-notification.entity';
+export declare class TaonNotificationRepository extends TaonBaseRepository<TaonNotificationEntity> {
+    entityClassResolveFn: () => typeof TaonNotificationEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+}

package/full-dts/taon-notification/taon-notification.subscriber.d.ts

@@ -0,0 +1,7 @@
+import { TaonBaseSubscriberForEntity } from 'taon/src';
+import { TaonNotificationEntity } from './taon-notification.entity';
+import { TaonNotificationProvider } from './taon-notification.provider';
+export declare class TaonNotificationSubscriber extends TaonBaseSubscriberForEntity {
+    taonNotificationProvider: TaonNotificationProvider;
+    listenTo(): typeof TaonNotificationEntity;
+}

package/full-dts/taon-notification/taon-notification.utils.d.ts

@@ -0,0 +1,4 @@
+import { TaonNotificationState } from './taon-notification.models';
+export declare namespace TaonNotificationUtils {
+    function isActive(state: string): state is TaonNotificationState;
+}

package/full-dts/taon-permission/index.d.ts

@@ -0,0 +1,11 @@
+export * from './taon-permission-api.service';
+export * from './taon-permission.abstract.context';
+export * from './taon-permission.constants';
+export * from './taon-permission.controller';
+export * from './taon-permission.entity';
+export * from './taon-permission.middleware';
+export * from './taon-permission.models';
+export * from './taon-permission.provider';
+export * from './taon-permission.repository';
+export * from './taon-permission.subscriber';
+export * from './taon-permission.utils';

package/full-dts/taon-permission/taon-permission-backoffice/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-permission-backoffice.component';

package/full-dts/taon-permission/taon-permission-backoffice/taon-permission-backoffice.models.d.ts

@@ -0,0 +1 @@
+export declare namespace TaonPermissionBackofficeModels { }

package/full-dts/taon-permission/taon-permission-chooser/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-permission-chooser.component';

package/full-dts/taon-permission/taon-permission-view-edit/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-permission-view-edit.component';

package/full-dts/taon-permission/taon-permission.abstract.context.d.ts

@@ -0,0 +1,16 @@
+export declare const TaonPermissionContext: {
+    readonly contextName: string;
+    readonly expressApp: import("express").Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/taon-permission/taon-permission.constants.d.ts

@@ -0,0 +1,2 @@
+import type { TaonPermissionEntity } from './taon-permission.entity';
+export declare const TaonPermissionDefaultsValues: Partial<TaonPermissionEntity>;

package/full-dts/taon-permission/taon-permission.controller.d.ts

@@ -0,0 +1,11 @@
+import { TaonSessionUserController } from '../taon-session-user/taon-session-user.controller';
+import { Taon, TaonBaseCrudController, Models } from 'taon/src';
+import { TaonPermissionEntity } from './taon-permission.entity';
+import { TaonPermissionRepository } from './taon-permission.repository';
+export declare class TaonPermissionController extends TaonBaseCrudController<TaonPermissionEntity> {
+    entityClassResolveFn: () => typeof TaonPermissionEntity;
+    taonPermissionRepository: TaonPermissionRepository;
+    private readonly taonSessionRepository;
+    beforeEachRequest({ req, res, methodConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    updateDescription(permissionId: number, description: string): Taon.Response<TaonPermissionEntity>;
+}

package/full-dts/taon-permission/taon-permission.entity.d.ts

@@ -0,0 +1,16 @@
+import { TaonRolePermissionEntity } from '../taon-role/taon-role-permission.entity';
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class TaonPermissionEntity extends TaonBaseAbstractEntity<TaonPermissionEntity> {
+    /**
+     * Examples:
+     *
+     * user.read
+     * user.write
+     * project.deploy
+     * billing.invoice.read
+     */
+    name: string;
+    code: string;
+    description?: string;
+    rolePermissions: TaonRolePermissionEntity[];
+}

package/full-dts/taon-permission/taon-permission.middleware.d.ts

@@ -0,0 +1,3 @@
+import { TaonBaseMiddleware } from 'taon/src';
+export declare class TaonPermissionMiddleware extends TaonBaseMiddleware {
+}

package/full-dts/taon-permission/taon-permission.models.d.ts

@@ -0,0 +1,4 @@
+export declare enum TaonPermissionState {
+    Active = "active",
+    Inactive = "inactive"
+}

package/full-dts/taon-permission/taon-permission.provider.d.ts

@@ -0,0 +1,3 @@
+import { TaonBaseProvider } from 'taon/src';
+export declare class TaonPermissionProvider extends TaonBaseProvider {
+}

package/full-dts/taon-permission/taon-permission.repository.d.ts

@@ -0,0 +1,7 @@
+import { TaonBaseRepository } from 'taon/src';
+import { TaonPermissionEntity } from './taon-permission.entity';
+export declare class TaonPermissionRepository extends TaonBaseRepository<TaonPermissionEntity> {
+    entityClassResolveFn: () => typeof TaonPermissionEntity;
+    getPermissionsForUserId(userId: number | string): Promise<TaonPermissionEntity[]>;
+    updateDescription(permissionId: number, description: string): Promise<TaonPermissionEntity>;
+}

package/full-dts/taon-permission/taon-permission.subscriber.d.ts

@@ -0,0 +1,7 @@
+import { TaonBaseSubscriberForEntity } from 'taon/src';
+import { TaonPermissionEntity } from './taon-permission.entity';
+import { TaonPermissionProvider } from './taon-permission.provider';
+export declare class TaonPermissionSubscriber extends TaonBaseSubscriberForEntity {
+    taonPermissionProvider: TaonPermissionProvider;
+    listenTo(): typeof TaonPermissionEntity;
+}

package/full-dts/taon-permission/taon-permission.utils.d.ts

@@ -0,0 +1,4 @@
+import { TaonPermissionState } from './taon-permission.models';
+export declare namespace TaonPermissionUtils {
+    function isActive(state: string): state is TaonPermissionState;
+}

package/full-dts/taon-role/index.d.ts

@@ -0,0 +1,8 @@
+export * from './taon-role-api.service';
+export * from './taon-role.abstract.context';
+export * from './taon-role.constants';
+export * from './taon-role.controller';
+export * from './taon-role.entity';
+export * from './taon-role.models';
+export * from './taon-role.provider';
+export * from './taon-role.repository';

package/full-dts/taon-role/taon-role-backoffice/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-role-backoffice.component';

package/full-dts/taon-role/taon-role-backoffice/taon-role-backoffice.models.d.ts

@@ -0,0 +1,9 @@
+export declare namespace TaonRoleBackofficeModels {
+    type AssignedPermissionRow = {
+        roleId: number;
+        permissionId: number;
+        name: string;
+        code: string;
+        description?: string;
+    };
+}

package/full-dts/taon-role/taon-role-chooser/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-role-chooser.component';

package/full-dts/taon-role/taon-role-permission.entity.d.ts

@@ -0,0 +1,9 @@
+import { TaonRoleEntity } from '../taon-role/taon-role.entity';
+import { TaonPermissionEntity } from '../taon-permission/taon-permission.entity';
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class TaonRolePermissionEntity extends TaonBaseAbstractEntity<TaonRolePermissionEntity> {
+    roleId: number;
+    permissionId: number;
+    role: TaonRoleEntity;
+    permission: TaonPermissionEntity;
+}

package/full-dts/taon-role/taon-role-permission.repository.d.ts

@@ -0,0 +1,13 @@
+import { TaonBaseRepository } from 'taon/src';
+import { TaonPermissionEntity } from '../taon-permission/taon-permission.entity';
+import { TaonRolePermissionEntity } from './taon-role-permission.entity';
+export declare class TaonRolePermissionRepository extends TaonBaseRepository<TaonRolePermissionEntity> {
+    entityClassResolveFn: () => typeof TaonRolePermissionEntity;
+    /**
+     * TODO remove this demo example method
+     */
+    countEntitesWithEvenId(): Promise<number>;
+    getPermissionsForRoleId(roleId: number): Promise<TaonPermissionEntity[]>;
+    assignPermissionToRole(roleId: number, permissionId: number): Promise<TaonRolePermissionEntity>;
+    unassignPermissionFromRole(roleId: number, permissionId: number): Promise<void>;
+}

package/full-dts/taon-role/taon-role.abstract.context.d.ts

@@ -0,0 +1,16 @@
+export declare const TaonRoleContext: {
+    readonly contextName: string;
+    readonly expressApp: import("express").Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/taon-role/taon-role.constants.d.ts

@@ -0,0 +1,2 @@
+import type { TaonRoleEntity } from './taon-role.entity';
+export declare const TaonRoleDefaultsValues: Partial<TaonRoleEntity>;

package/full-dts/taon-role/taon-role.controller.d.ts

@@ -0,0 +1,15 @@
+import { Taon, TaonBaseCrudController, Models } from 'taon/src';
+import { TaonPermissionEntity } from '../taon-permission/taon-permission.entity';
+import { TaonSessionUserController } from '../taon-session-user/taon-session-user.controller';
+import { TaonRoleEntity } from './taon-role.entity';
+import { TaonRoleRepository } from './taon-role.repository';
+export declare class TaonRoleController extends TaonBaseCrudController<TaonRoleEntity> {
+    entityClassResolveFn: () => typeof TaonRoleEntity;
+    taonRoleRepository: TaonRoleRepository;
+    private readonly taonRolePermissionRepository;
+    private readonly taonSessionRepository;
+    beforeEachRequest({ req, res, methodConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionUserController>): Promise<void>;
+    getPermissionsForRole(roleId: number): Taon.Response<TaonPermissionEntity[]>;
+    assignPermissionToRole(roleId: number, permissionId: number): Taon.Response<void>;
+    unassignPermissionFromRole(roleId: number, permissionId: number): Taon.Response<void>;
+}

package/full-dts/taon-role/taon-role.entity.d.ts

@@ -0,0 +1,18 @@
+import { TaonSessionUserRoleEntity } from '../taon-session-user/taon-session-user-role.entity';
+import { TaonRolePermissionEntity } from '../taon-role/taon-role-permission.entity';
+import { TaonGroupRoleEntity } from '../taon-group/taon-group-role.entity';
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class TaonRoleEntity extends TaonBaseAbstractEntity<TaonRoleEntity> {
+    /**
+     * Example:
+     * admin
+     * editor
+     * billing-manager
+     */
+    name: string;
+    code: string;
+    description?: string;
+    userRoles: TaonSessionUserRoleEntity[];
+    groupRoles: TaonGroupRoleEntity[];
+    rolePermissions: TaonRolePermissionEntity[];
+}

package/full-dts/taon-role/taon-role.models.d.ts

@@ -0,0 +1,4 @@
+export declare enum TaonRoleState {
+    Active = "active",
+    Inactive = "inactive"
+}

package/full-dts/taon-role/taon-role.provider.d.ts

@@ -0,0 +1,3 @@
+import { TaonBaseProvider } from 'taon/src';
+export declare class TaonRoleProvider extends TaonBaseProvider {
+}

package/full-dts/taon-role/taon-role.repository.d.ts

@@ -0,0 +1,6 @@
+import { TaonBaseRepository } from 'taon/src';
+import { TaonRoleEntity } from './taon-role.entity';
+export declare class TaonRoleRepository extends TaonBaseRepository<TaonRoleEntity> {
+    entityClassResolveFn: () => typeof TaonRoleEntity;
+    getRolesForUserId(userId: number | string): Promise<TaonRoleEntity[]>;
+}

package/full-dts/taon-session/index.d.ts

@@ -0,0 +1,12 @@
+export * from './taon-session';
+export * from './taon-session-backoffice';
+export * from './taon-session-button';
+export * from './taon-session.api.service';
+export * from './taon-session.config.service';
+export * from './taon-session.kv.repository';
+export * from './taon-session.abstract.context';
+export * from './taon-session.controller';
+export * from './taon-session.middleware';
+export * from './taon-session.models';
+export * from './taon-session.provider';
+export * from './taon-session.utils';

package/full-dts/taon-session/taon-profile/index.d.ts

@@ -0,0 +1,8 @@
+export * from './taon-profile.api.service';
+export * from './taon-profile.config.service';
+export * from './taon-profile.abstract.context';
+export * from './taon-profile.constants';
+export * from './taon-profile.controller';
+export * from './taon-profile.entity';
+export * from './taon-profile.models';
+export * from './taon-profile.provider';

package/full-dts/taon-session/taon-profile/taon-profile-picture/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-profile-picture.component';

package/full-dts/taon-session/taon-profile/taon-profile-picture/taon-profile-picture.models.d.ts

@@ -0,0 +1 @@
+export declare namespace TaonProfilePictureModels { }

package/full-dts/taon-session/taon-profile/taon-profile.abstract.context.d.ts

@@ -0,0 +1,16 @@
+export declare const TaonProfileAbstractContext: {
+    readonly contextName: string;
+    readonly expressApp: import("express").Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/taon-session/taon-profile/taon-profile.constants.d.ts

@@ -0,0 +1,6 @@
+import type { TaonProfileEntity } from './taon-profile.entity';
+export declare const TaonProfileDefaultsValues: Partial<TaonProfileEntity>;
+export declare enum TaonProfileErrors {
+    INVALID_PASSWORD_EXAMPLE_ERROR = "INVALID_PASSWORD_EXAMPLE_ERROR"
+}
+export declare const TaonProfileTranslationErorsMap: Map<TaonProfileErrors, string>;

package/full-dts/taon-session/taon-profile/taon-profile.controller.d.ts

@@ -0,0 +1,21 @@
+import { ExpressRequest, ExpressResponse, Models, TaonStorageObject, TaonUploadedFile } from 'taon/src';
+import { TaonBaseStorageController } from 'taon/src';
+import { TaonProfileModels } from './taon-profile.models';
+export declare class TaonProfileController extends TaonBaseStorageController<TaonProfileModels.PictureQuery> {
+    private readonly taonSessionRepository;
+    private readonly authRepository;
+    private readonly userRepository;
+    beforeEachRequest({ req, res, methodConfig, classConfig, }: Models.TaonCtrlBeforeEachRequestParams<TaonProfileController>): Promise<void>;
+    protected handleUploadFiles(bodyFormDataFiles: TaonUploadedFile[], queryParams?: TaonProfileModels.PictureQuery, req?: ExpressRequest<any>, res?: ExpressResponse<any>): Promise<TaonStorageObject[]>;
+    afterFileUploadHook(fileObject?: TaonStorageObject, queryParams?: TaonProfileModels.PictureQuery): Promise<void>;
+    buildStorageDownloadUrl(options: {
+        req: any;
+        key: string;
+        private: boolean;
+        token?: string;
+    }): string;
+    createStorageDownloadToken(options: {
+        key: string;
+        expiresAt: number;
+    }): Promise<string>;
+}

package/full-dts/taon-session/taon-profile/taon-profile.entity.d.ts

@@ -0,0 +1,4 @@
+import { TaonBaseAbstractEntity } from 'taon/src';
+export declare class TaonProfileEntity extends TaonBaseAbstractEntity<TaonProfileEntity> {
+    description?: string;
+}

package/full-dts/taon-session/taon-profile/taon-profile.kv.repository.d.ts

@@ -0,0 +1,7 @@
+import { TaonBaseKvRepository } from 'taon/src';
+import { TaonProfileEntity } from './taon-profile.entity';
+export declare class TaonProfileKvRepository extends TaonBaseKvRepository<{
+    usersToNotify: TaonProfileEntity[];
+}> {
+    notifyUsers(users: TaonProfileEntity[]): Promise<void>;
+}

package/full-dts/taon-session/taon-profile/taon-profile.models.d.ts

@@ -0,0 +1,8 @@
+export declare namespace TaonProfileModels {
+    const PROFILE_PICTURE_FILE_NAME = "profile-picture";
+    interface PictureQuery {
+        userId?: number;
+    }
+    function pictureKey(userId?: number | string): string;
+    const PROFILE_PICTURE_ACCEPT = "image/png,image/jpeg,image/webp,image/gif";
+}

package/full-dts/taon-session/taon-profile/taon-profile.provider.d.ts

@@ -0,0 +1,12 @@
+import { TaonBaseClass, TaonBaseProvider } from 'taon/src';
+export declare class TaonTaonProfileConfig extends TaonBaseClass {
+    name: string;
+}
+export declare class TaonProfileProvider extends TaonBaseProvider {
+    enabledTaonProfileOption: boolean;
+    config: TaonTaonProfileConfig;
+    clone(): {
+        enabledTaonProfileOption: boolean;
+        config: any;
+    };
+}

package/full-dts/taon-session/taon-session/index.d.ts

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

package/full-dts/taon-session/taon-session/taon-session-profile/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-session-profile.component';

package/full-dts/taon-session/taon-session/taon-session-profile/taon-session-profile.models.d.ts

@@ -0,0 +1 @@
+export declare namespace TaonSessionProfileModels { }

package/full-dts/taon-session/taon-session-backoffice/index.d.ts

@@ -0,0 +1,6 @@
+export * from './taon-session-backoffice.component';
+export * from './taon-session-backoffice.routes';
+export * from './taon-session-backoffice.api.service';
+export * from './taon-session-details.component';
+export * from './taon-session-backoffice.controller';
+export * from './taon-session-backoffice.models';

package/full-dts/taon-session/taon-session-backoffice/taon-session-backoffice.controller.d.ts

@@ -0,0 +1,13 @@
+import { Models, Taon, TaonBaseCrudController, TaonPaginationQuery } from 'taon/src';
+import { TaonSessionEntity } from '../taon-session.entity';
+import { TaonSessionBackofficeModels } from './taon-session-backoffice.models';
+export declare class TaonSessionBackofficeController extends TaonBaseCrudController<TaonSessionBackofficeModels.SessionRow, {}, TaonSessionBackofficeController> {
+    entityClassResolveFn: () => typeof TaonSessionEntity;
+    private readonly taonSessionRepository;
+    private readonly taonAuthContextRepository;
+    private readonly taonSessionUserRepository;
+    private readonly taonSessionUserIdentityRepository;
+    beforeEachRequest({ req, res, }: Models.TaonCtrlBeforeEachRequestParams<TaonSessionBackofficeController>): Promise<void>;
+    protected defaultPaginationQuery(query: TaonPaginationQuery<TaonSessionBackofficeController>): Promise<[TaonSessionBackofficeModels.SessionRow[], number]>;
+    getBy(id: number | string): Taon.Response<TaonSessionBackofficeModels.SessionDetails>;
+}

package/full-dts/taon-session/taon-session-backoffice/taon-session-backoffice.models.d.ts

@@ -0,0 +1,10 @@
+import type { TaonSessionUserIdentityEntity } from '../../taon-session-user/taon-session-user-identity.entity';
+import type { TaonSessionUserEntity } from '../../taon-session-user/taon-session-user.entity';
+import type { TaonSessionEntity } from '../taon-session.entity';
+export declare namespace TaonSessionBackofficeModels {
+    type SessionRow = Pick<TaonSessionEntity, 'id' | 'userId' | 'deviceName' | 'ip'>;
+    type SessionDetails = SessionRow & Pick<TaonSessionEntity, 'identityId' | 'authenticationProvider' | 'userAgent' | 'createdAt' | 'lastActivityAt' | 'expiresAt' | 'revokedAt' | 'revokeReason'> & {
+        user: Pick<TaonSessionUserEntity, 'id' | 'username'> | null;
+        identity: Pick<TaonSessionUserIdentityEntity, 'id' | 'email' | 'provider'> | null;
+    };
+}

package/full-dts/taon-session/taon-session-button/index.d.ts

@@ -0,0 +1 @@
+export * from './taon-session-button.component';

package/full-dts/taon-session/taon-session.abstract.context.d.ts

@@ -0,0 +1,16 @@
+export declare const TaonSessionAbstractContext: {
+    readonly contextName: string;
+    readonly expressApp: import("express").Application;
+    readonly appId: string;
+    cloneAsRemote: (cloneOpt?: Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideRemoteHost" | "overrideContextName" | "overrideUseSession">) => /*elided*/ any;
+    cloneAsNormal: (cloneOpt?: Partial<Pick<import("taon/src").Models.TaonCtxCloneParams, "overrideHost" | "overrideContextName" | "overrideUseSession">>) => /*elided*/ any;
+    __ref(): Promise<import("taon/src").EndpointContext>;
+    readonly __refSync: import("taon/src").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: (overrideOptions?: import("taon/src").Models.TaonInitializeParams) => Promise<import("taon/src").EndpointContext>;
+    readonly realtime: {
+        readonly client: import("taon/src").RealtimeClient;
+        readonly server: import("taon/src").RealtimeServer;
+    };
+};

package/full-dts/taon-session/taon-session.controller.d.ts

@@ -0,0 +1,25 @@
+import { TaonAuthContextEntity } from '@taon-dev/session/src';
+import { Taon, TaonBaseController } from 'taon/src';
+import { TaonSessionIdentityProvider, TaonSessionUserEntity } from '../taon-session-user';
+import { TaonLoginData } from './taon-session.models';
+export declare class TaonSessionController extends TaonBaseController {
+    private readonly taonSessionKvRepository;
+    private readonly taonSessionUserIdentityRepository;
+    private readonly taonSessionProvider;
+    private readonly taonSessionUserRepository;
+    private readonly taonAuthContextRepository;
+    private readonly taonSessionRepository;
+    createUser(email: string, password: string): Taon.Response<TaonSessionUserEntity | null>;
+    userExists(email: string): Taon.Response<boolean>;
+    private getGoogleIdentity;
+    connectIdentity(data: TaonLoginData): Taon.Response<boolean>;
+    usernameAvailable(username: string): Taon.Response<boolean>;
+    changeUsername(username: string): Taon.Response<boolean>;
+    disconnectIdentity(provider: TaonSessionIdentityProvider): Taon.Response<boolean>;
+    login(data: TaonLoginData): Taon.Response<boolean>;
+    refresh(): Taon.Response<boolean>;
+    logout(): Taon.Response<boolean>;
+    context(): Taon.Response<TaonAuthContextEntity>;
+    emptyContext(): Taon.Response<TaonAuthContextEntity>;
+    getCurrentUserId(): Taon.Response<number>;
+}

package/full-dts/taon-session/taon-session.entity.d.ts

@@ -0,0 +1,21 @@
+import { TaonBaseAbstractEntity } from 'taon/src';
+import { TaonSessionUserEntity } from '../taon-session-user/taon-session-user.entity';
+import { TaonSessionIdentityProvider } from '../taon-session-user/taon-session-user.models';
+export declare class TaonSessionEntity extends TaonBaseAbstractEntity<TaonSessionEntity> {
+    userId: number;
+    identityId?: number;
+    authenticationProvider?: TaonSessionIdentityProvider;
+    user: TaonSessionUserEntity;
+    /**
+     * Store HASH of session token, not raw token.
+     */
+    tokenHash: string;
+    userAgent?: string;
+    ip?: string;
+    deviceName?: string;
+    lastActivityAt?: Date;
+    expiresAt: Date;
+    revokedAt?: Date;
+    revokeReason?: string;
+    createdAt: Date;
+}

package/{lib/taon-session/taon-session-kv.repository.d.ts → full-dts/taon-session/taon-session.kv.repository.d.ts}

@@ -1,10 +1,14 @@
 import type express from 'express';
-import { TaonBaseKvRepository } from 'taon';
+import { TaonBaseKvRepository } from 'taon/src';
 import { TaonSessionProvider } from './taon-session.provider';
-export declare class TaonSessionKvRepository extends TaonBaseKvRepository {
+export declare class TaonSessionKvRepository extends TaonBaseKvRepository<Record<string, {
+    userId: number;
+    expiresAt: number;
+    sessionId?: number;
+}>> {
     taonSessionProvider: TaonSessionProvider;
-    createAccessToken(userId: string): string;
-    createRefreshToken(userId: string): string;
+    createAccessToken(userId: number, sessionId?: number): Promise<string>;
+    createRefreshToken(userId: number, sessionId?: number): Promise<string>;
     setAuthCookies(res: express.Response, accessToken: string, refreshToken: string): void;
     clearAuthCookies(res: express.Response): void;
     getTokenFromRequest(req: express.Request): string | null;

package/full-dts/taon-session/taon-session.middleware.d.ts

@@ -0,0 +1,6 @@
+import { TaonBaseMiddleware, TaonServerMiddlewareInterceptOptions } from 'taon/src';
+import { TaonSessionRepository } from './taon-session.repository';
+export declare class TaonSessionMiddleware extends TaonBaseMiddleware {
+    taonSessionRepository: TaonSessionRepository;
+    interceptServerMethod(data: TaonServerMiddlewareInterceptOptions): Promise<void>;
+}

package/full-dts/taon-session/taon-session.models.d.ts

@@ -0,0 +1,33 @@
+export interface TaonLoginData {
+    email?: string;
+    password?: string;
+    googleCode?: string;
+}
+export interface GoogleCodeResponse {
+    code?: string;
+    error?: string;
+    error_description?: string;
+}
+export declare enum TaonSessionState {
+    LOADING_INITIAL_AUTH_INFO = "LOADING_INITIAL_AUTH_INFO",
+    LOGIN_OR_REGISTER = "LOGIN_OR_REGISTER",
+    ENTER_PASSWORD = "ENTER_PASSWORD",
+    ENTER_REGISTRATION_PASSWORDS = "ENTER_REGISTRATION_PASSWORDS",
+    LOADING_AUTH = "LOADING_AUTH",
+    LOADING_CHECK_USER_EMAIL_EXISTS = "LOADING_CHECK_USER_EMAIL_EXISTS",
+    LOADING_CREATING_USER = "LOADING_CREATING_USER",
+    LOADING_LOGOUT_INFO = "LOADING_LOGOUT_INFO",
+    TWO_FA_EMAIL = "TWO_FA_EMAIL",
+    TWO_FA_SMS = "TWO_FA_SMS",
+    TWO_FA_AUTHENTICATOR = "TWO_FA_AUTHENTICATOR",
+    LOGIN_SUCCESS = "LOGIN_SUCCESS",
+    PROFILE_INFO = "PROFILE_INFO",
+    PASSWORD_CHANGE = "PASSWORD_CHANGE",
+    AVATAR_CHANGE = "AVATAR_CHANGE"
+}
+export declare enum TaonLoginErrors {
+    INVALID_PASSWORD = "INVALID_PASSWORD",
+    INVALID_SOCIAL_LOGIN = "INVALID_SOCIAL_LOGIN",
+    PASSWORDS_DO_NOT_MATCH = "PASSWORDS_DO_NOT_MATCH"
+}
+export declare const TaonErorsMap: Map<TaonLoginErrors, string>;