insite-users-server 1.0.403 → 1.0.472

package/dist/index.d.ts

@@ -0,0 +1,626 @@
+declare module "lib/regexps" {
+    export namespace regexps {
+        let _id: RegExp;
+        let email: RegExp;
+        let argon2: RegExp;
+        let sessionId: RegExp;
+        let role: RegExp;
+        let ip: RegExp;
+    }
+}
+declare module "lib/index" {
+    export * from "lib/regexps";
+}
+declare module "users/avatars/schema" {
+    export namespace schema {
+        let required: string[];
+        namespace properties {
+            namespace _id {
+                let bsonType: string;
+                let pattern: string;
+            }
+            namespace type {
+                let bsonType_1: string;
+                export { bsonType_1 as bsonType };
+                export let maxLength: number;
+            }
+            namespace size {
+                let bsonType_2: string;
+                export { bsonType_2 as bsonType };
+            }
+            namespace ts {
+                let bsonType_3: string;
+                export { bsonType_3 as bsonType };
+                let maxLength_1: number;
+                export { maxLength_1 as maxLength };
+            }
+            namespace data {
+                let bsonType_4: string;
+                export { bsonType_4 as bsonType };
+            }
+        }
+        let additionalProperties: boolean;
+    }
+}
+declare module "users/avatars/Avatars" {
+    export class Avatars {
+        constructor(users: any);
+        users: any;
+        collections: any;
+        collection: any;
+    }
+}
+declare module "users/avatars/types" {
+    import type { Binary } from "insite-db";
+    export type AvatarDoc = {
+        _id: string;
+        type: string;
+        size: number;
+        ts: string;
+        data: Binary;
+    };
+}
+declare module "users/avatars/index" {
+    export { Avatars } from "users/avatars/Avatars";
+    export * from "users/avatars/types";
+}
+declare module "abilities/tree" {
+    export const basisTree: {
+        _id: string;
+        title: string;
+        params: ({
+            _id: string;
+            title: string;
+            type: string;
+            min: number;
+            max: number;
+            items?: undefined;
+        } | {
+            _id: string;
+            title: string;
+            type: string;
+            items: {
+                _id: string;
+                title: string;
+            }[];
+            min?: undefined;
+            max?: undefined;
+        })[];
+    }[];
+}
+declare module "abilities/Abilities" {
+    export class Abilities extends Map<any, any> {
+        constructor(options?: {});
+        tree: any;
+        merge(target: any, source: any): any;
+        getMinimumOf(_id: any): {};
+        getMaximum(): any;
+        getSchemeFor(user: any): any;
+        #private;
+    }
+}
+declare module "abilities/index" {
+    export * from "abilities/Abilities";
+}
+declare module "orgs/Org" {
+    export class Org {
+        constructor(orgs: any, orgDoc: any);
+        _id: any;
+        isOrg: boolean;
+        ownerOrgs: Set<any>;
+        ownerUsers: Set<any>;
+        users: Set<any>;
+        slaveOrgs: Set<any>;
+        update({ _id, title, owners: ownerIds, ...restProps }: {
+            [x: string]: any;
+            _id: any;
+            title: any;
+            owners: any;
+        }, next: any): void;
+        title: any;
+        initials: any;
+        displayLabel: any;
+        ownerIds: any;
+        delete(): void;
+        #private;
+    }
+}
+declare module "orgs/schema" {
+    export namespace basisSchema {
+        let required: string[];
+        namespace properties {
+            namespace _id {
+                let bsonType: string;
+                let pattern: string;
+            }
+            namespace title {
+                let bsonType_1: string;
+                export { bsonType_1 as bsonType };
+                export let maxLength: number;
+            }
+            namespace note {
+                let bsonType_2: string;
+                export { bsonType_2 as bsonType };
+                let maxLength_1: number;
+                export { maxLength_1 as maxLength };
+            }
+            namespace owners {
+                let bsonType_3: string;
+                export { bsonType_3 as bsonType };
+                export let uniqueItems: boolean;
+                export namespace items {
+                    let bsonType_4: string;
+                    export { bsonType_4 as bsonType };
+                    let pattern_1: string;
+                    export { pattern_1 as pattern };
+                }
+                export let additionalItems: boolean;
+            }
+            namespace createdAt {
+                let bsonType_5: string;
+                export { bsonType_5 as bsonType };
+            }
+        }
+        let additionalProperties: boolean;
+    }
+}
+declare module "orgs/Orgs" {
+    export class Orgs extends Map<any, any> {
+        static resolve(org: any, slaveOrgs: any): void;
+        constructor(users: any, options?: {});
+        users: any;
+        collections: any;
+        collection: any;
+        null: Org;
+        load(orgDoc: any): void;
+        sorted: any[];
+        update(): void;
+        updateDebounced: ((this: unknown) => Promise<unknown>) & {
+            callback: () => unknown;
+            promise: Promise<unknown> & {
+                isResolved: boolean;
+            };
+            resolve: (value: unknown) => void;
+            run: () => Promise<unknown>;
+            clear: (shouldRun: boolean) => Promise<void>;
+        };
+        initialLoad: () => Promise<void>;
+        init: () => Promise<void>;
+        "new"({ title, note, ...restProps }: {
+            [x: string]: any;
+            title: any;
+            note: any;
+        }, ownerId: any): any;
+        collectionDelete(org: any): any;
+        replaceMap: Map<any, any>;
+        replaceHandlers: Set<any>;
+        replace(fromId: any): Promise<void>;
+    }
+    import { Org } from "orgs/Org";
+}
+declare module "orgs/index" {
+    export * from "orgs/Orgs";
+}
+declare module "roles/Role" {
+    export class Role {
+        constructor(roles: any, roleDoc: any);
+        _id: any;
+        ownInvolves: any[];
+        involves: Set<any>;
+        abilities: {};
+        inheritedAbilities: {};
+        update({ _id, involves: ownInvolveIds, abilities: ownAbilities, title, ...restProps }: {
+            [x: string]: any;
+            _id: any;
+            involves: any;
+            abilities: any;
+            title: any;
+        }, next: any): void;
+        ownInvolveIds: any;
+        ownAbilities: any;
+        title: any;
+        displayTitle: any;
+        delete(): void;
+        #private;
+    }
+}
+declare module "roles/schema" {
+    export namespace basisSchema {
+        let required: string[];
+        namespace properties {
+            namespace _id {
+                let bsonType: string;
+                let pattern: string;
+                namespace not {
+                    let _enum: string[];
+                    export { _enum as enum };
+                }
+            }
+            namespace involves {
+                let bsonType_1: string;
+                export { bsonType_1 as bsonType };
+                export let uniqueItems: boolean;
+                export namespace items {
+                    let bsonType_2: string;
+                    export { bsonType_2 as bsonType };
+                    let pattern_1: string;
+                    export { pattern_1 as pattern };
+                    export namespace not_1 {
+                        let _enum_1: string[];
+                        export { _enum_1 as enum };
+                    }
+                    export { not_1 as not };
+                }
+                export let additionalItems: boolean;
+            }
+            namespace abilities {
+                let bsonType_3: string;
+                export { bsonType_3 as bsonType };
+            }
+            namespace title {
+                let bsonType_4: string;
+                export { bsonType_4 as bsonType };
+                export let maxLength: number;
+            }
+            namespace description {
+                let bsonType_5: string;
+                export { bsonType_5 as bsonType };
+                let maxLength_1: number;
+                export { maxLength_1 as maxLength };
+            }
+            namespace createdAt {
+                let bsonType_6: string;
+                export { bsonType_6 as bsonType };
+            }
+        }
+        let additionalProperties: boolean;
+    }
+}
+declare module "roles/Roles" {
+    export class Roles extends Map<any, any> {
+        constructor(users: any, options?: {});
+        users: any;
+        collections: any;
+        abilities: any;
+        root: Role;
+        collection: any;
+        load(roleDoc: any): void;
+        resolve(role: any, involvedBy: any): void;
+        sorted: any[];
+        update(): void;
+        updateDebounced: ((this: unknown) => Promise<unknown>) & {
+            callback: () => unknown;
+            promise: Promise<unknown> & {
+                isResolved: boolean;
+            };
+            resolve: (value: unknown) => void;
+            run: () => Promise<unknown>;
+            clear: (shouldRun: boolean) => Promise<void>;
+        };
+        init: () => Promise<void>;
+        "new"({ _id, involves, title, description, ...restProps }: {
+            [x: string]: any;
+            _id: any;
+            involves: any;
+            title: any;
+            description: any;
+        }): any;
+        collectionDelete(role: any): any;
+        cleanUpIds(ids: any): any[];
+    }
+    import { Role } from "roles/Role";
+}
+declare module "roles/index" {
+    export * from "roles/Roles";
+}
+declare module "sessions/schema" {
+    export namespace basisSchema {
+        let required: string[];
+        namespace properties {
+            namespace _id {
+                let bsonType: string;
+                let pattern: string;
+            }
+            namespace user {
+                let bsonType_1: string;
+                export { bsonType_1 as bsonType };
+                let pattern_1: string;
+                export { pattern_1 as pattern };
+            }
+            namespace userAgent {
+                let bsonType_2: string;
+                export { bsonType_2 as bsonType };
+                export let maxLength: number;
+            }
+            namespace remoteAddress {
+                let bsonType_3: string;
+                export { bsonType_3 as bsonType };
+                let pattern_2: string;
+                export { pattern_2 as pattern };
+            }
+            namespace isOnline {
+                let bsonType_4: string;
+                export { bsonType_4 as bsonType };
+            }
+            namespace createdAt {
+                let bsonType_5: string;
+                export { bsonType_5 as bsonType };
+            }
+            namespace prolongedAt {
+                let bsonType_6: string;
+                export { bsonType_6 as bsonType };
+            }
+            namespace expiresAt {
+                let bsonType_7: string;
+                export { bsonType_7 as bsonType };
+            }
+        }
+        let additionalProperties: boolean;
+    }
+}
+declare module "sessions/Session" {
+    export class Session {
+        constructor(sessions: any, sessionDoc: any);
+        _id: any;
+        user: any;
+        update({ _id, user, isOnline, ...restProps }: {
+            [x: string]: any;
+            _id: any;
+            user: any;
+            isOnline: any;
+        }): void;
+        isOnline: any;
+        prolong({ _id, user, ...updates }: {
+            [x: string]: any;
+            _id: any;
+            user: any;
+        }): any;
+        offline(): any;
+        delete(): void;
+        #private;
+    }
+}
+declare module "sessions/Sessions" {
+    export class Sessions extends Map<any, any> {
+        constructor(users: any, options?: {});
+        users: any;
+        collections: any;
+        collection: any;
+        isInited: boolean;
+        load(sessionDoc: any): void;
+        init: () => Promise<void>;
+        "new"(user: any, props: any): Promise<Session>;
+    }
+    import { Session } from "sessions/Session";
+}
+declare module "sessions/index" {
+    export * from "sessions/Sessions";
+}
+declare module "users/schema" {
+    export namespace basisSchema {
+        export let required: string[];
+        export namespace properties {
+            namespace _id {
+                let bsonType: string;
+                let pattern: string;
+            }
+            namespace email {
+                let bsonType_1: string;
+                export { bsonType_1 as bsonType };
+                let pattern_1: string;
+                export { pattern_1 as pattern };
+            }
+            namespace password {
+                let bsonType_2: string;
+                export { bsonType_2 as bsonType };
+                let pattern_2: string;
+                export { pattern_2 as pattern };
+            }
+            namespace roles {
+                let bsonType_3: string;
+                export { bsonType_3 as bsonType };
+                export let uniqueItems: boolean;
+                export namespace items {
+                    let bsonType_4: string;
+                    export { bsonType_4 as bsonType };
+                    let pattern_3: string;
+                    export { pattern_3 as pattern };
+                }
+                export let additionalItems: boolean;
+            }
+            namespace name {
+                let bsonType_5: string;
+                export { bsonType_5 as bsonType };
+                let required_1: string[];
+                export { required_1 as required };
+                export namespace properties_1 {
+                    namespace first {
+                        let bsonType_6: string;
+                        export { bsonType_6 as bsonType };
+                        export let maxLength: number;
+                    }
+                    namespace middle {
+                        let bsonType_7: string;
+                        export { bsonType_7 as bsonType };
+                        let maxLength_1: number;
+                        export { maxLength_1 as maxLength };
+                    }
+                    namespace last {
+                        let bsonType_8: string;
+                        export { bsonType_8 as bsonType };
+                        let maxLength_2: number;
+                        export { maxLength_2 as maxLength };
+                    }
+                }
+                export { properties_1 as properties };
+                export let additionalProperties: boolean;
+            }
+            namespace org {
+                let oneOf: ({
+                    bsonType: string;
+                    pattern: string;
+                } | {
+                    bsonType: string;
+                    pattern?: undefined;
+                })[];
+            }
+            namespace job {
+                let bsonType_9: string;
+                export { bsonType_9 as bsonType };
+                let maxLength_3: number;
+                export { maxLength_3 as maxLength };
+            }
+            namespace avatar {
+                let oneOf_1: ({
+                    bsonType: string;
+                    maxLength: number;
+                } | {
+                    bsonType: string;
+                    maxLength?: undefined;
+                })[];
+                export { oneOf_1 as oneOf };
+            }
+            namespace createdAt {
+                let bsonType_10: string;
+                export { bsonType_10 as bsonType };
+            }
+        }
+        let additionalProperties_1: boolean;
+        export { additionalProperties_1 as additionalProperties };
+    }
+}
+declare module "users/User" {
+    export class User {
+        constructor(users: any, userDoc: any);
+        _id: any;
+        isUser: boolean;
+        roles: Set<any>;
+        slaveRoles: Set<any>;
+        slaveRoleIds: any[];
+        abilities: {};
+        slaveOrgs: Set<any>;
+        slaveUsers: Set<any>;
+        slaves: Set<any>;
+        slaveIds: any[];
+        permissiveIds: any[];
+        sessions: Set<any>;
+        isOnline: boolean;
+        update({ _id, name, email, roles: ownRoleIds, org: orgId, avatar, ...restProps }: {
+            [x: string]: any;
+            _id: any;
+            name: any;
+            email: any;
+            roles: any;
+            org: any;
+            avatar: any;
+        }): void;
+        email: any;
+        name: {
+            first: any;
+            middle: any;
+            last: any;
+        } | undefined;
+        initials: any;
+        displayLabel: any;
+        ownRoleIds: any;
+        org: any;
+        avatar: any;
+        avatarUrl: any;
+        updateRoles(): void;
+        ownRoles: any[] | undefined;
+        isRoot: boolean | undefined;
+        updatePermissions(): void;
+        trimSessions(): any;
+        updateIsOnline: ((this: unknown) => Promise<unknown>) & {
+            callback: () => unknown;
+            promise: Promise<unknown> & {
+                isResolved: boolean;
+            };
+            resolve: (value: unknown) => void;
+            run: () => Promise<unknown>;
+            clear: (shouldRun: boolean) => Promise<void>;
+        };
+        delete(): void;
+        #private;
+    }
+}
+declare module "users/Users" {
+    export class Users extends Map<any, any> {
+        constructor({ collections, indexes: customIndexes, schema: customSchema, initialRoot: initialRootProps, abilities: abilitiesOptions, roles: rolesOptions, orgs: orgsOptions, sessions: sessionsOptions, avatars: avatarsOptions }: {
+            collections: any;
+            indexes: any;
+            schema: any;
+            initialRoot: any;
+            abilities: any;
+            roles: any;
+            orgs: any;
+            sessions: any;
+            avatars: any;
+        });
+        collections: any;
+        abilities: Abilities;
+        collection: any;
+        roles: Roles;
+        orgs: Orgs;
+        sessions: Sessions;
+        avatars: Avatars;
+        isInited: boolean;
+        byEmail: Map<any, any>;
+        bySessionId: Map<any, any>;
+        sorted: any[];
+        isSortRequired: boolean;
+        load(userDoc: any): void;
+        sort(): void;
+        sortDebounced: ((this: unknown) => Promise<unknown>) & {
+            callback: () => unknown;
+            promise: Promise<unknown> & {
+                isResolved: boolean;
+            };
+            resolve: (value: unknown) => void;
+            run: () => Promise<unknown>;
+            clear: (shouldRun: boolean) => Promise<void>;
+        };
+        update(shouldUpdateRoles: any): void;
+        updateDebounced: ((this: unknown) => Promise<unknown>) & {
+            callback: () => unknown;
+            promise: Promise<unknown> & {
+                isResolved: boolean;
+            };
+            resolve: (value: unknown) => void;
+            run: () => Promise<unknown>;
+            clear: (shouldRun: boolean) => Promise<void>;
+        };
+        initialLoad: () => Promise<void>;
+        init: () => void;
+        "new"({ email, password, roles, name, org, job, ...restProps }: {
+            [x: string]: any;
+            email: any;
+            password: any;
+            roles: any;
+            name: any;
+            org: any;
+            job: any;
+        }): Promise<boolean>;
+        changePassword(_id: any, newPassword: any): Promise<void>;
+        login(email: any, password: any, sessionProps: any): Promise<import("sessions/Session").Session>;
+        logout(session: any): any;
+        sortIds(ids: any): any;
+        replaceMap: Map<any, any>;
+        replaceHandlers: Set<any>;
+        replace(fromId: any): Promise<void>;
+    }
+    import { Abilities } from "abilities/Abilities";
+    import { Roles } from "roles/Roles";
+    import { Orgs } from "orgs/Orgs";
+    import { Sessions } from "sessions/Sessions";
+    import { Avatars } from "users/avatars";
+}
+declare module "users/index" {
+    export * from "users/avatars/index";
+    export * from "users/Users";
+}
+declare module "index" {
+    import "@nesvet/deprecated-extensions/server";
+    export * from "users/index";
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/regexps.js","../src/lib/index.js","../src/users/avatars/schema.js","../src/users/avatars/Avatars.js","../src/users/avatars/types.ts","../src/users/avatars/index.ts","../src/abilities/tree.js","../src/abilities/Abilities.js","../src/abilities/index.js","../src/orgs/Org.js","../src/orgs/schema.js","../src/orgs/Orgs.js","../src/orgs/index.js","../src/roles/Role.js","../src/roles/schema.js","../src/roles/Roles.js","../src/roles/index.js","../src/sessions/schema.js","../src/sessions/Session.js","../src/sessions/Sessions.js","../src/sessions/index.js","../src/users/schema.js","../src/users/User.js","../src/users/Users.js","../src/users/index.ts","../src/index.ts"],"names":[],"mappings":"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"}