@holoyan/adonisjs-permissions 0.8.21 → 0.8.23

package/README.md

@@ -3,6 +3,11 @@
 [//]: # ([![test](https://github.com/holoyan/adonisjs-permissions/actions/workflows/test.yml/badge.svg)](https://github.com/holoyan/adonisjs-permissions/actions/workflows/test.yml))
 [![license](https://poser.pugx.org/silber/bouncer/license.svg)](https://github.com/holoyan/adonisjs-permissions/blob/master/LICENSE.md)
 
+## How can you support me?
+
+- It's simple, just star this repository, that is enough to keep me motivated to maintain this package.
+
+
 ## Table of Contents
 
 <details><summary>Click to expand</summary><p>
@@ -128,7 +133,7 @@ export default class Post extends BaseModel implements AclModelInterface {
 ## Release Notes
 
 Version: >= 'v0.8.21'
-* Update: UUID version to ^10.0.0
+* Added `sync` methods
 
 ## Mixins
 
@@ -984,7 +989,144 @@ await trx.commit()
 
 ## Cheat sheet
 
-Coming soon
+Model methods
+```typescript 
+// getting model roles
+await Acl.model(user).roles()
+
+// Checking the current model's roles
+await Acl.model(user).hasRole('role_slug')
+await Acl.model(user).hasAllRoles('role_slug1', 'role_slug2')
+await Acl.model(user).hasAnyRole('role_slug1', 'role_slug2')
+
+// assigning roles
+await Acl.model(user).assignRole('role_slug')
+await Acl.model(user).assign('role_slug') // alias for assignRole()
+await Acl.model(user).assignAllRoles('role_slug1', 'role_slug2')
+
+// revoking roles
+await Acl.model(user).revokeRole('role_slug')
+await Acl.model(user).revokeAllRoles('role_slug1', 'role_slug2')
+await Acl.model(user).flushRoles() // remove all roles
+
+// syncing roles
+await Acl.model(user).syncRoles(['role_slug1', 'role_slug2']) // remove all roles and assign new
+await Acl.model(user).syncRolesWithoutDetaching(['role_slug1', 'role_slug2') // assign new roles without removing old
+
+
+// getting model permissions
+
+await Acl.model(user).permissions()
+await Acl.model(user).globalPermissions() // get list of global permissions
+await Acl.mode(user).onResourcePermissions() // get list of on resrouce permissions
+await Acl.model(user).directPermissions() // list of permissions assigned to the user drectly 
+await Acl.model(user).rolePermissions() // Get permissions through roles
+await Acl.model(user).directGlobalPermissions()
+await Acl.model(user).directResourcePermissions()
+
+// checking for permission
+await Acl.model(user).hasPermission(permission)
+await Acl.model(user).hasAllPermissions([permission1, permission2])
+await Acl.model(user).hasAnyPermission([permission1, permission2])
+await Acl.model(user).hasAnyDirectPermission([permission1, permission2])
+await Acl.model(user).hasDirectPermission(permission1)
+await Acl.model(user).hasAllPermissionsDirect([permission1, permission2])
+await Acl.model(user).can(permission1) // alias for hasPermission()
+await Acl.model(user).canAll([permission1, permission2])
+await Acl.model(user).canAny([permission1, permission2])
+
+// check Contains vs hasPermission section to see the diferrence 
+await Acl.model(user).containsPermission(permission)
+await Acl.model(user).contains(permission) // alias for containsPermission
+await Acl.model(user).containsAllPermissions([permission1])
+await Acl.model(user).containsAnyPermission([permission1])
+await Acl.model(user).containsDirectPermission([permission1])
+await Acl.model(user).containsAllPermissionsDirectly([permission1])
+await Acl.model(user).containsAnyPermissionDirectly([permission1])
+
+// assigning permissions
+await Acl.model(user).assignDirectPermission(permission)
+await Acl.model(user).assignDirectAllPermissions([permission1, permission2])
+await Acl.model(user).allow(permission1) // alias for assignDirectPermission()
+await Acl.model(user).allowAll([permission1, permission2])
+
+// reviking permissions
+await Acl.model(user).revokePermission(permission1)
+await Acl.model(user).revoke(permission1) // alias for revokePermission()
+await Acl.model(user).revokeAllPermissions([permission1, permission2])
+await Acl.model(user).revokeAll([permission1, permission2]) // alias for revokeAllPermissions()
+await Acl.model(user).flushPermissions() // revoke/delete all direct assigned permissions
+await Acl.model(user).flush() // revoke/delete all assigned roles and permissions
+
+// sync permissions
+await Acl.model(user).syncPermissions([permission1, permission2]) // all direct assigned permissions will be revoked and only permission1, permission2 will be assigned
+
+// forbid/unforbiding permissions
+await Acl.model(user).forbid(permission1)
+await Acl.model(user).forbidAll([permission1, permission2])
+await Acl.model(user).unforbid(permission1)
+await Acl.model(user).unforbidAll([permission1, permission2])
+
+```
+
+Role methods 
+
+```typescript
+
+await Acl.role(myAdminRole).models() // get list of models assigned to the role
+await Acl.role(myAdminRole).modelsFor('ALIAS_FOR_MODEL')
+
+await Acl.role(myAdminRole).permissions() 
+await Acl.role(myAdminRole).globalPermissions()
+await Acl.role(myAdminRole).onResourcePermissions()
+
+// checking for a permissions
+await Acl.role(myAdminRole).hasPermission(permission)
+await Acl.role(myAdminRole).hasAllPermissions([permission1, permission2])
+await Acl.role(myAdminRole).hasAnyPermissions([permission1, permission2])
+await Acl.role(myAdminRole).can(permission) // alias for hasPermission
+await Acl.role(myAdminRole).canAll([permission1, permission2])
+await Acl.role(myAdminRole).canAny([permission1, permission2])
+
+await Acl.role(myAdminRole).containsPermission(permission)
+await Acl.role(myAdminRole).containsAllPermissions([permission1, permission2])
+await Acl.role(myAdminRole).containsAnyPermissions([permission1, permission2])
+await Acl.role(myAdminRole).forbidden(permission) // check if permission forbidden for a role
+
+// assigning permission
+await Acl.role(myAdminRole).give(permission)
+await Acl.role(myAdminRole).assign(permission) // alias for give()
+await Acl.role(myAdminRole).allow(permission) // alias for give()
+
+await Acl.role(myAdminRole).giveAll([permission1])
+await Acl.role(myAdminRole).assignAll([permission1])
+await Acl.role(myAdminRole).allowAll([permission1])
+
+// revoking permission
+await Acl.role(myAdminRole).revokePermission(permission1)
+await Acl.role(myAdminRole).revoke(permission1) // alias for revokePermission()
+await Acl.role(myAdminRole).revokeAllPermissions([permission1])
+await Acl.role(myAdminRole).revokeAll([permission1]) // alias for revokeAllPermissions()
+await Acl.role(myAdminRole).flush() // revoke all
+
+await Acl.role(myAdminRole).sync([permission1, permission2]) // revoke all and assign only permission1, permission2
+
+// forbid/unforbid
+
+await Acl.role(myAdminRole).forbid(permission)
+await Acl.role(myAdminRole).unforbid(permission)
+
+```
+
+Permission methods
+```typescript
+await Acl.permission(myPermission).roles() // list of roles
+await Acl.permission(myPermission).modelsFor('MODEL_ALIAS')
+await Acl.permission(myPermission).belongsToRole(role_slug) // check if permission belongs to role
+await Acl.permission(myPermission).attachToRole(role_slug)
+await Acl.permission(myPermission).detachFromRole(role_slug)
+
+```
 
 
 ## TODO

package/build/src/acl.d.ts

@@ -1,5 +1,5 @@
 import { RoleHasModelPermissions } from './services/roles/role_has_model_permissions.js';
-import { ModelHasRolePermissions } from './services/model_has_role_permissions.js';
+import { ModelHasRolePermissions } from './services/models/model_has_role_permissions.js';
 import { AclModel, MorphInterface, OptionsInterface, PermissionInterface, RoleInterface, ScopeInterface } from './types.js';
 import ModelManager from './model_manager.js';
 import EmptyPermission from './services/permissions/empty_permission.js';

package/build/src/acl.js

@@ -1,5 +1,5 @@
 import { RoleHasModelPermissions } from './services/roles/role_has_model_permissions.js';
-import { ModelHasRolePermissions } from './services/model_has_role_permissions.js';
+import { ModelHasRolePermissions } from './services/models/model_has_role_permissions.js';
 import PermissionHasModelRoles from './services/permissions/permission_has_model_roles.js';
 import ModelManager from './model_manager.js';
 import EmptyPermission from './services/permissions/empty_permission.js';

package/build/src/decorators.d.ts

@@ -1,4 +1,6 @@
-export declare function MorphMap(param: string): <T extends new (...args: any[]) => {}>(target: T) => void;
+export declare function MorphMap(param: string): <T extends {
+    new (...args: any[]): {};
+}>(target: T) => void;
 export declare function getClassPath<T extends {
     new (...args: any[]): {};
 }>(clazz: T): string;

package/build/src/mixins/has_permissions.d.ts

@@ -1,43 +1,214 @@
 import type { NormalizeConstructor } from '@adonisjs/core/types/helpers';
+import { BaseModel } from '@adonisjs/lucid/orm';
 import { AclModel, ModelIdType } from '../types.js';
-export declare function hasPermissions(): <Model extends NormalizeConstructor<import("@adonisjs/lucid/types/model").LucidModel>>(superclass: Model) => {
+export declare function hasPermissions(): <Model extends NormalizeConstructor<typeof BaseModel>>(superclass: Model) => {
     new (...args: any[]): {
         getModelId(): ModelIdType;
+        /**
+         * returns list of roles assigned to the model
+         */
         roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+        /**
+         * Check if model has role
+         * @param role
+         */
         hasRole(role: string): Promise<boolean>;
+        /**
+         * Check if model has all roles - returns true ONLY, if model has all roles
+         * @param roles
+         */
         hasAllRoles(...roles: string[]): Promise<boolean>;
+        /**
+         * Check if model has any role - returns true if model has any of the roles
+         * @param roles
+         */
         hasAnyRole(...roles: string[]): Promise<boolean>;
+        /**
+         * Assign role to model
+         * @param role
+         */
         assignRole(role: string): Promise<boolean>;
+        /**
+         * Revoke role from model
+         * @param role
+         */
         revokeRole(role: string): Promise<boolean>;
+        /**
+         * Revoke all roles from model
+         * @param roles
+         */
         revokeAllRoles(...roles: string[]): Promise<boolean>;
+        /**
+         * returns list of permissions assigned to the model
+         * @param includeForbiddings
+         */
         permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        /**
+         * returns list of global permissions assigned to the model
+         * @param includeForbiddings
+         */
         globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        /**
+         * returns list of resource permissions assigned to the model
+         * @param includeForbiddings
+         */
         onResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        /**
+         * Returns list of direct permissions assigned to the model
+         * @param includeForbiddings
+         */
         directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        /**
+         * Returns list of direct resource permissions assigned to the model
+         * @param includeForbiddings
+         */
         directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+        /**
+         * Check if model has "contains" permission
+         * If permission is forbidden, it will return true
+         * @param permission
+         */
         containsPermission(permission: string): Promise<boolean>;
+        /**
+         * Check if model contains all permissions
+         * @param permissions
+         */
         containsAllPermissions(permissions: string[]): Promise<boolean>;
+        /**
+         * Check if model contains any permission
+         * @param permissions
+         */
         containsAnyPermission(permissions: string[]): Promise<boolean>;
+        /**
+         * Check if model contains direct permission
+         * @param permission
+         */
         containsDirectPermission(permission: string): Promise<boolean>;
+        /**
+         * Check if model contains all direct permissions
+         * @param permissions
+         */
         containsAllPermissionsDirectly(permissions: string[]): Promise<boolean>;
+        /**
+         * Check if model contains any direct permission
+         * @param permissions
+         */
         containsAnyPermissionDirectly(permissions: string[]): Promise<boolean>;
+        /**
+         * Check if model has permission
+         * @param permission
+         * @param target
+         */
         hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has all permissions
+         * @param permissions
+         * @param target
+         */
         hasAllPermissions(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has any permission
+         * @param permissions
+         * @param target
+         */
         hasAnyPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has direct permission
+         * @param permissions
+         * @param target
+         */
         hasAnyDirectPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has direct permission
+         * @param permission
+         * @param target
+         */
         hasDirectPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has all direct permissions
+         * @param permissions
+         * @param target
+         */
         hasAllPermissionsDirect(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has all permission
+         * @param permissions
+         * @param target
+         */
         canAll(permissions: string[], target?: AclModel | Function): Promise<boolean>;
         canAny(permissions: string[], target?: AclModel | Function): Promise<boolean>;
+        /**
+         * Check if model has any permission
+         * @param permission
+         * @param target
+         */
         assignDirectPermission(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        /**
+         * Allow permission for model
+         * @param permission
+         * @param target
+         */
         allow(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        /**
+         * Revoke permission from model
+         * @param permission
+         * @param target
+         */
         revokePermission(permission: string, target?: AclModel | Function): Promise<any[]>;
+        /**
+         * Revoke all permissions from model
+         * @param permissions
+         * @param target
+         */
         revokeAllPermissions(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+        /**
+         * Flush(revoke all) permissions from model
+         */
         flushPermissions(): Promise<any[]>;
+        /**
+         * Flush(revoke all) roles and permissions from model
+         */
         flush(): Promise<boolean>;
+        /**
+         * Sync Role with the given list
+         * @param roles
+         * @param detach
+         */
+        syncRoles(roles: string[], detach?: boolean): Promise<boolean>;
+        /**
+         * Sync Role with the given list without detaching existing roles
+         * @param roles
+         */
+        syncRolesWithoutDetaching(roles: string[]): Promise<boolean>;
+        /**
+         * Sync permissions with the given list
+         * @param permissions
+         * @param target
+         */
+        syncPermissions(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        /**
+         * Forbid permission for model
+         * @param permission
+         * @param target
+         */
         forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        /**
+         * Forbid all permissions for model
+         * @param permissions
+         * @param target
+         */
         forbidAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
+        /**
+         * Unforbid all permissions for model
+         * @param permissions
+         * @param target
+         */
         unforbidAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
+        /**
+         * Unforbid permission for model
+         * @param permission
+         * @param target
+         */
         unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
         $attributes: import("@adonisjs/lucid/types/model").ModelObject;
         $extras: import("@adonisjs/lucid/types/model").ModelObject;
@@ -47,59 +218,56 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<im
         };
         $columns: undefined;
         $sideloaded: import("@adonisjs/lucid/types/model").ModelObject;
-        $primaryKeyValue?: string | number | undefined;
+        $primaryKeyValue?: number | string;
         $isPersisted: boolean;
         $isNew: boolean;
         $isLocal: boolean;
         $dirty: import("@adonisjs/lucid/types/model").ModelObject;
         $isDirty: boolean;
         $isDeleted: boolean;
-        $options?: import("@adonisjs/lucid/types/model").ModelOptions | undefined;
-        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract | undefined;
-        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): void;
-        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): any;
-        useConnection(connection: string): any;
-        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/querybuilder").InsertQueryBuilderContract<unknown[]>;
-        $getQueryFor(action: "delete" | "refresh" | "update", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidRow>;
+        $options?: import("@adonisjs/lucid/types/model").ModelOptions;
+        $trx?: import("@adonisjs/lucid/types/database").TransactionClientContract;
+        $setOptionsAndTrx(options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): void;
+        useTransaction(trx: import("@adonisjs/lucid/types/database").TransactionClientContract): /*elided*/ any;
+        useConnection(connection: string): /*elided*/ any;
+        $getQueryFor(action: "insert", client: import("@adonisjs/lucid/types/database").QueryClientContract): ReturnType<import("@adonisjs/lucid/types/database").QueryClientContract["insertQuery"]>;
+        $getQueryFor(action: "update" | "delete" | "refresh", client: import("@adonisjs/lucid/types/database").QueryClientContract): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel>;
         $setAttribute(key: string, value: any): void;
         $getAttribute(key: string): any;
-        $getAttributeFromCache(key: string, callback: (value: any) => any): any;
+        $getAttributeFromCache(key: string, callback: import("@adonisjs/lucid/types/model").CacheNode["getter"]): any;
         $hasRelated(key: string): boolean;
         $setRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
         $pushRelated(key: string, result: import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null): void;
-        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | null | undefined;
-        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined): void;
+        $getRelated(key: string, defaultValue?: any): import("@adonisjs/lucid/types/querybuilder").OneOrMany<import("@adonisjs/lucid/types/model").LucidRow> | undefined | null;
+        $consumeAdapterResult(adapterResult: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject): void;
         $hydrateOriginals(): void;
-        fill(value: Partial<{}>, allowExtraProperties?: boolean | undefined): any;
-        merge(value: Partial<{}>, allowExtraProperties?: boolean | undefined): any;
-        enableForceUpdate(): any;
-        save(): Promise<any>;
-        lockForUpdate<T>(callback: (user: any) => T | Promise<T>): Promise<T>;
+        fill(value: Partial<{}>, allowExtraProperties?: boolean): /*elided*/ any;
+        merge(value: Partial<{}>, allowExtraProperties?: boolean): /*elided*/ any;
+        isDirty(fields?: undefined[] | undefined): boolean;
+        enableForceUpdate(): /*elided*/ any;
+        save(): Promise</*elided*/ any>;
+        lockForUpdate<T>(callback: (user: /*elided*/ any) => T | Promise<T>): Promise<T>;
         delete(): Promise<void>;
-        refresh(): Promise<any>;
-        load: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
-        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce<any>;
-        preload: import("@adonisjs/lucid/types/model").LucidRowPreload<any>;
-        loadAggregate: <Self extends any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
-        loadCount: <Self_1 extends any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self_1>, RelatedBuilder_1 = Self_1[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self_1[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self_1>;
-        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields | undefined, raw?: boolean | undefined): import("@adonisjs/lucid/types/model").ModelObject;
-        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        refresh(): Promise</*elided*/ any>;
+        load: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadOnce: import("@adonisjs/lucid/types/model").LucidRowPreloadOnce</*elided*/ any>;
+        preload: import("@adonisjs/lucid/types/model").LucidRowPreload</*elided*/ any>;
+        loadAggregate: <Self extends /*elided*/ any, Name extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder = Self[Name] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name]["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        loadCount: <Self extends /*elided*/ any, Name_1 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<Self>, RelatedBuilder_1 = Self[Name_1] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? Self[Name_1]["subQuery"] : never>(name: Name_1, callback?: ((builder: RelatedBuilder_1) => void) | undefined) => import("@adonisjs/lucid/types/model").LazyLoadAggregatesContract<Self>;
+        serializeAttributes(fields?: import("@adonisjs/lucid/types/model").CherryPickFields, raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeComputed(fields?: import("@adonisjs/lucid/types/model").CherryPickFields): import("@adonisjs/lucid/types/model").ModelObject;
         serializeRelations(fields: undefined, raw: true): {
             [key: string]: import("@adonisjs/lucid/types/model").LucidRow | import("@adonisjs/lucid/types/model").LucidRow[];
         };
-        serializeRelations(cherryPick: {
-            [relation: string]: import("@adonisjs/lucid/types/model").CherryPick;
-        } | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
-        serializeRelations(cherryPick?: {
-            [relation: string]: import("@adonisjs/lucid/types/model").CherryPick;
-        } | undefined, raw?: boolean | undefined): import("@adonisjs/lucid/types/model").ModelObject;
-        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(cherryPick: import("@adonisjs/lucid/types/model").CherryPick["relations"] | undefined, raw: false | undefined): import("@adonisjs/lucid/types/model").ModelObject;
+        serializeRelations(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick["relations"], raw?: boolean): import("@adonisjs/lucid/types/model").ModelObject;
+        serialize(cherryPick?: import("@adonisjs/lucid/types/model").CherryPick): import("@adonisjs/lucid/types/model").ModelObject;
         toObject(): import("@adonisjs/lucid/types/model").ModelObject;
         toJSON(): import("@adonisjs/lucid/types/model").ModelObject;
-        related<Name_2 extends undefined>(relation: Name_2): any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? any[Name_2]["client"] : never;
+        related<Name_2 extends undefined>(relation: Name_2): /*elided*/ any[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? /*elided*/ any[Name_2]["client"] : never;
     };
-    find: <T_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_1, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_1> | null>;
-    all: <T_2 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_2, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_2>[]>;
+    find: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    all: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
     namingStrategy: import("@adonisjs/lucid/types/model").NamingStrategyContract;
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
@@ -120,56 +288,57 @@ export declare function hasPermissions(): <Model extends NormalizeConstructor<im
         serializedToColumns: import("@adonisjs/lucid/types/model").ModelKeysContract;
         serializedToAttributes: import("@adonisjs/lucid/types/model").ModelKeysContract;
     };
-    $createFromAdapterResult: <T_3 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_3, result?: import("@adonisjs/lucid/types/model").ModelObject | undefined, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_3> | null;
-    $createMultipleFromAdapterResult: <T_4 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_4, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject | undefined, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => InstanceType<T_4>[];
+    $createFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, result?: import("@adonisjs/lucid/types/model").ModelObject, sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => null | InstanceType<T>;
+    $createMultipleFromAdapterResult: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, results: import("@adonisjs/lucid/types/model").ModelObject[], sideloadAttributes?: import("@adonisjs/lucid/types/model").ModelObject, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => InstanceType<T>[];
     $addColumn: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ColumnOptions>) => import("@adonisjs/lucid/types/model").ColumnOptions;
     $hasColumn: (name: string) => boolean;
     $getColumn: (name: string) => import("@adonisjs/lucid/types/model").ModelColumnOptions | undefined;
     $addComputed: (name: string, options: Partial<import("@adonisjs/lucid/types/model").ComputedOptions>) => import("@adonisjs/lucid/types/model").ComputedOptions;
     $hasComputed: (name: string) => boolean;
     $getComputed: (name: string) => import("@adonisjs/lucid/types/model").ComputedOptions | undefined;
-    $addRelation: (name: string, type: "hasOne" | "hasMany" | "belongsTo" | "manyToMany" | "hasManyThrough", relatedModel: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
+    $addRelation: (name: string, type: import("@adonisjs/lucid/types/relations").ModelRelationTypes["__opaque_type"], relatedModel: () => import("@adonisjs/lucid/types/model").LucidModel, options: import("@adonisjs/lucid/types/model").ModelRelationOptions) => void;
     $hasRelation: (name: string) => boolean;
     $getRelation: {
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Name_3 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_3): InstanceType<Model_1>[Name_3] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? InstanceType<Model_1>[Name_3]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
-        <Model_2 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_2, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Name_2 extends import("@adonisjs/lucid/types/relations").ExtractModelRelations<InstanceType<Model_1>>>(this: Model_1, name: Name_2): InstanceType<Model_1>[Name_2] extends import("@adonisjs/lucid/types/relations").ModelRelations<import("@adonisjs/lucid/types/model").LucidModel, import("@adonisjs/lucid/types/model").LucidModel> ? InstanceType<Model_1>[Name_2]["client"]["relation"] : import("@adonisjs/lucid/types/relations").RelationshipsContract;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, name: string): import("@adonisjs/lucid/types/relations").RelationshipsContract;
     };
-    $defineProperty: <Model_3 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_3>(this: Model_3, propertyName: Prop, defaultValue: Model_3[Prop], strategy: "inherit" | "define" | ((value: Model_3[Prop]) => Model_3[Prop])) => void;
+    $defineProperty: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
     boot: () => void;
     before: {
-        <Model_4 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_4, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_4, InstanceType<Model_4>>, Event_1>): void;
-        <Model_5 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_5, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_5, InstanceType<Model_5>>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_5, InstanceType<Model_5>>], "paginate">): void;
-        <Model_6 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_6, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_6>, Event_2>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_1>): void;
     };
     after: {
-        <Model_7 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_7, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_7>[], "fetch">): void;
-        <Model_8 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_8, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_8>>, "paginate">): void;
-        <Model_9 extends import("@adonisjs/lucid/types/model").LucidModel, Event_3 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_9, event: Event_3, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_9>, Event_3>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>[], "fetch">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
     };
-    create: <T_5 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_5, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_5>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_5>>;
-    createMany: <T_6 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_6, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_6>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_6>[]>;
-    findOrFail: <T_7 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_7, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_7>>;
+    create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    findOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
     findBy: {
-        <T_8 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_8, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_8> | null>;
-        <T_9 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_9, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_9> | null>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<null | InstanceType<T>>;
     };
     findByOrFail: {
-        <T_10 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_10, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_10>>;
-        <T_11 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_11, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_11>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>>;
     };
     findManyBy: {
-        <T_12 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_12, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_12>[]>;
-        <T_13 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_13, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined): Promise<InstanceType<T_13>[]>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, clause: Record<string, unknown>, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
+        <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, key: string, value: any, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions): Promise<InstanceType<T>[]>;
     };
-    first: <T_14 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_14, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_14> | null>;
-    firstOrFail: <T_15 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_15, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_15>>;
-    findMany: <T_16 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_16, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => Promise<InstanceType<T_16>[]>;
-    firstOrNew: <T_17 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_17, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_17>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_17>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_17>>;
-    firstOrCreate: <T_18 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_18, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_18>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_18>>> | undefined, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_18>>;
-    updateOrCreate: <T_19 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_19, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_19>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_19>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_19>>;
-    fetchOrNewUpMany: <T_20 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_20, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_20>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_20>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_20>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_20>[]>;
-    fetchOrCreateMany: <T_21 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_21, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_21>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_21>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_21>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_21>[]>;
-    updateOrCreateMany: <T_22 extends import("@adonisjs/lucid/types/model").LucidModel>(this: T_22, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_22>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_22>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T_22>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions | undefined) => Promise<InstanceType<T_22>[]>;
-    query: <Model_10 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_10>>(this: Model_10, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions | undefined) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_10, Result>;
-    truncate: (cascade?: boolean | undefined) => Promise<void>;
+    first: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
+    firstOrFail: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>>;
+    findMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, value: any[], options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<InstanceType<T>[]>;
+    firstOrNew: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    firstOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, savePayload?: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    updateOrCreate: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, searchPayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, updatePayload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
+    fetchOrNewUpMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
+    query: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model_1>>(this: Model_1, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1, Result>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    truncate: (cascade?: boolean) => Promise<void>;
 } & Model;

package/build/src/mixins/has_permissions.js

@@ -5,114 +5,290 @@ export function hasPermissions() {
             getModelId() {
                 throw new Error('method getModelId must be implemented in target model, which will return key for current object');
             }
+            /**
+             * returns list of roles assigned to the model
+             */
             roles() {
                 return Acl.model(this).roles();
             }
+            /**
+             * Check if model has role
+             * @param role
+             */
             hasRole(role) {
                 return Acl.model(this).hasRole(role);
             }
+            /**
+             * Check if model has all roles - returns true ONLY, if model has all roles
+             * @param roles
+             */
             hasAllRoles(...roles) {
                 return Acl.model(this).hasAllRoles(...roles);
             }
+            /**
+             * Check if model has any role - returns true if model has any of the roles
+             * @param roles
+             */
             hasAnyRole(...roles) {
                 return Acl.model(this).hasAnyRole(...roles);
             }
+            /**
+             * Assign role to model
+             * @param role
+             */
             assignRole(role) {
                 return Acl.model(this).assignRole(role);
             }
+            /**
+             * Revoke role from model
+             * @param role
+             */
             revokeRole(role) {
                 return Acl.model(this).revokeRole(role);
             }
+            /**
+             * Revoke all roles from model
+             * @param roles
+             */
             revokeAllRoles(...roles) {
                 return Acl.model(this).revokeAllRoles(...roles);
             }
             // roles related section END
             // permissions related section BEGIN
+            /**
+             * returns list of permissions assigned to the model
+             * @param includeForbiddings
+             */
             permissions(includeForbiddings = false) {
                 return Acl.model(this).permissions(includeForbiddings);
             }
+            /**
+             * returns list of global permissions assigned to the model
+             * @param includeForbiddings
+             */
             globalPermissions(includeForbiddings = false) {
                 return Acl.model(this).globalPermissions(includeForbiddings);
             }
+            /**
+             * returns list of resource permissions assigned to the model
+             * @param includeForbiddings
+             */
             async onResourcePermissions(includeForbiddings = false) {
                 return Acl.model(this).onResourcePermissions(includeForbiddings);
             }
-            async directGlobalPermissions(includeForbiddings = false) {
+            /**
+             * Returns list of direct permissions assigned to the model
+             * @param includeForbiddings
+             */
+            directGlobalPermissions(includeForbiddings = false) {
                 return Acl.model(this).directGlobalPermissions(includeForbiddings);
             }
-            async directResourcePermissions(includeForbiddings = false) {
+            /**
+             * Returns list of direct resource permissions assigned to the model
+             * @param includeForbiddings
+             */
+            directResourcePermissions(includeForbiddings = false) {
                 return Acl.model(this).directResourcePermissions(includeForbiddings);
             }
-            async containsPermission(permission) {
+            /**
+             * Check if model has "contains" permission
+             * If permission is forbidden, it will return true
+             * @param permission
+             */
+            containsPermission(permission) {
                 return Acl.model(this).containsPermission(permission);
             }
-            async containsAllPermissions(permissions) {
+            /**
+             * Check if model contains all permissions
+             * @param permissions
+             */
+            containsAllPermissions(permissions) {
                 return Acl.model(this).containsAllPermissions(permissions);
             }
-            async containsAnyPermission(permissions) {
+            /**
+             * Check if model contains any permission
+             * @param permissions
+             */
+            containsAnyPermission(permissions) {
                 return Acl.model(this).containsAnyPermission(permissions);
             }
-            async containsDirectPermission(permission) {
+            /**
+             * Check if model contains direct permission
+             * @param permission
+             */
+            containsDirectPermission(permission) {
                 return Acl.model(this).containsDirectPermission(permission);
             }
-            async containsAllPermissionsDirectly(permissions) {
+            /**
+             * Check if model contains all direct permissions
+             * @param permissions
+             */
+            containsAllPermissionsDirectly(permissions) {
                 return Acl.model(this).containsAllPermissionsDirectly(permissions);
             }
-            async containsAnyPermissionDirectly(permissions) {
+            /**
+             * Check if model contains any direct permission
+             * @param permissions
+             */
+            containsAnyPermissionDirectly(permissions) {
                 return Acl.model(this).containsAnyPermissionDirectly(permissions);
             }
-            async hasPermission(permission, target) {
+            /**
+             * Check if model has permission
+             * @param permission
+             * @param target
+             */
+            hasPermission(permission, target) {
                 return Acl.model(this).hasPermission(permission, target);
             }
-            async hasAllPermissions(permissions, target) {
+            /**
+             * Check if model has all permissions
+             * @param permissions
+             * @param target
+             */
+            hasAllPermissions(permissions, target) {
                 return Acl.model(this).hasAllPermissions(permissions, target);
             }
-            async hasAnyPermission(permissions, target) {
+            /**
+             * Check if model has any permission
+             * @param permissions
+             * @param target
+             */
+            hasAnyPermission(permissions, target) {
                 return Acl.model(this).hasAnyPermission(permissions, target);
             }
-            async hasAnyDirectPermission(permissions, target) {
+            /**
+             * Check if model has direct permission
+             * @param permissions
+             * @param target
+             */
+            hasAnyDirectPermission(permissions, target) {
                 return Acl.model(this).hasAnyDirectPermission(permissions, target);
             }
-            async hasDirectPermission(permission, target) {
+            /**
+             * Check if model has direct permission
+             * @param permission
+             * @param target
+             */
+            hasDirectPermission(permission, target) {
                 return Acl.model(this).hasDirectPermission(permission, target);
             }
-            async hasAllPermissionsDirect(permissions, target) {
+            /**
+             * Check if model has all direct permissions
+             * @param permissions
+             * @param target
+             */
+            hasAllPermissionsDirect(permissions, target) {
                 return Acl.model(this).hasAllPermissionsDirect(permissions, target);
             }
+            /**
+             * Check if model has all permission
+             * @param permissions
+             * @param target
+             */
             canAll(permissions, target) {
                 return Acl.model(this).canAll(permissions, target);
             }
             canAny(permissions, target) {
                 return Acl.model(this).canAny(permissions, target);
             }
-            async assignDirectPermission(permission, target) {
+            /**
+             * Check if model has any permission
+             * @param permission
+             * @param target
+             */
+            assignDirectPermission(permission, target) {
                 return Acl.model(this).assignDirectPermission(permission, target);
             }
+            /**
+             * Allow permission for model
+             * @param permission
+             * @param target
+             */
             allow(permission, target) {
                 return Acl.model(this).allow(permission, target);
             }
-            async revokePermission(permission, target) {
+            /**
+             * Revoke permission from model
+             * @param permission
+             * @param target
+             */
+            revokePermission(permission, target) {
                 return Acl.model(this).revokePermission(permission, target);
             }
-            async revokeAllPermissions(permissions, target) {
+            /**
+             * Revoke all permissions from model
+             * @param permissions
+             * @param target
+             */
+            revokeAllPermissions(permissions, target) {
                 return Acl.model(this).revokeAllPermissions(permissions, target);
             }
-            async flushPermissions() {
+            /**
+             * Flush(revoke all) permissions from model
+             */
+            flushPermissions() {
                 return Acl.model(this).flushPermissions();
             }
-            async flush() {
+            /**
+             * Flush(revoke all) roles and permissions from model
+             */
+            flush() {
                 return Acl.model(this).flush();
             }
-            async forbid(permission, target) {
+            /**
+             * Sync Role with the given list
+             * @param roles
+             * @param detach
+             */
+            syncRoles(roles, detach = true) {
+                return Acl.model(this).syncRoles(roles, detach);
+            }
+            /**
+             * Sync Role with the given list without detaching existing roles
+             * @param roles
+             */
+            syncRolesWithoutDetaching(roles) {
+                return Acl.model(this).syncRolesWithoutDetaching(roles);
+            }
+            /**
+             * Sync permissions with the given list
+             * @param permissions
+             * @param target
+             */
+            syncPermissions(permissions, target) {
+                return Acl.model(this).syncPermissions(permissions, target);
+            }
+            /**
+             * Forbid permission for model
+             * @param permission
+             * @param target
+             */
+            forbid(permission, target) {
                 return Acl.model(this).forbid(permission, target);
             }
-            async forbidAll(permissions, target) {
+            /**
+             * Forbid all permissions for model
+             * @param permissions
+             * @param target
+             */
+            forbidAll(permissions, target) {
                 return Acl.model(this).forbidAll(permissions, target);
             }
-            async unforbidAll(permissions, target) {
+            /**
+             * Unforbid all permissions for model
+             * @param permissions
+             * @param target
+             */
+            unforbidAll(permissions, target) {
                 return Acl.model(this).unforbidAll(permissions, target);
             }
-            async unforbid(permission, target) {
+            /**
+             * Unforbid permission for model
+             * @param permission
+             * @param target
+             */
+            unforbid(permission, target) {
                 return Acl.model(this).unforbid(permission, target);
             }
         }

package/build/src/services/{model_has_role_permissions.d.ts → models/model_has_role_permissions.d.ts}

@@ -1,8 +1,8 @@
-import { AclModel, MorphInterface, OptionsInterface } from '../types.js';
-import RolesService from './roles/roles_service.js';
-import BaseAdapter from './base_adapter.js';
-import ModelManager from '../model_manager.js';
-import PermissionService from './permissions/permissions_service.js';
+import { AclModel, MorphInterface, OptionsInterface } from '../../types.js';
+import RolesService from '../roles/roles_service.js';
+import BaseAdapter from '../base_adapter.js';
+import ModelManager from '../../model_manager.js';
+import PermissionService from '../permissions/permissions_service.js';
 export declare class ModelHasRolePermissions extends BaseAdapter {
     protected manager: ModelManager;
     protected map: MorphInterface;
@@ -11,7 +11,7 @@ export declare class ModelHasRolePermissions extends BaseAdapter {
     protected roleService: RolesService;
     protected permissionService: PermissionService;
     constructor(manager: ModelManager, map: MorphInterface, options: OptionsInterface, model: AclModel);
-    roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    roles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").RoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     hasRole(role: string): Promise<boolean>;
     hasAllRoles(...roles: string[]): Promise<boolean>;
     hasAnyRole(...roles: string[]): Promise<boolean>;
@@ -21,17 +21,35 @@ export declare class ModelHasRolePermissions extends BaseAdapter {
     revokeRole(role: string): Promise<boolean>;
     revokeAllRoles(...roles: string[]): Promise<boolean>;
     flushRoles(): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, any>;
-    permissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    globalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    onResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    directPermissions(includeForbiddings?: boolean): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    /**
+     * Sync roles with the model  (detach all roles and assign new roles)
+     * @param roles  - array of roles
+     * @param detach - if true, it will detach the existing roles
+     */
+    syncRoles(roles: string[], detach?: boolean): Promise<boolean>;
+    /**
+     * Sync roles with the model without detaching the existing ones
+     * @param roles
+     */
+    syncRolesWithoutDetaching(roles: string[]): Promise<boolean>;
+    permissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    /**
+     * returns list of global permissions assigned to the model
+     * @param includeForbiddings
+     */
+    globalPermissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    /**
+     * @param includeForbiddings
+     */
+    onResourcePermissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    directPermissions(includeForbiddings?: boolean): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     /**
      * Get permission through roles
      * @param includeForbiddings
      */
-    rolePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
-    directResourcePermissions(includeForbiddings?: boolean): Promise<import("../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    rolePermissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    directGlobalPermissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
+    directResourcePermissions(includeForbiddings?: boolean): Promise<import("../../types.js").PermissionModel<import("@adonisjs/lucid/types/model").LucidModel>[]>;
     containsPermission(permission: string): Promise<boolean>;
     contains(permission: string): Promise<boolean>;
     containsAllPermissions(permissions: string[]): Promise<boolean>;
@@ -39,7 +57,16 @@ export declare class ModelHasRolePermissions extends BaseAdapter {
     containsDirectPermission(permission: string): Promise<boolean>;
     containsAllPermissionsDirectly(permissions: string[]): Promise<boolean>;
     containsAnyPermissionDirectly(permissions: string[]): Promise<boolean>;
+    /**
+     * @param permission
+     * @param target
+     */
     hasPermission(permission: string, target?: AclModel | Function): Promise<boolean>;
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
     hasAllPermissions(permissions: string[], target?: AclModel | Function): Promise<boolean>;
     hasAnyPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
     hasAnyDirectPermission(permissions: string[], target?: AclModel | Function): Promise<boolean>;
@@ -57,6 +84,7 @@ export declare class ModelHasRolePermissions extends BaseAdapter {
     revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
     revokeAllPermissions(permissions: string[], target?: AclModel | Function): Promise<any[]>;
     flushPermissions(): Promise<any[]>;
+    syncPermissions(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     flush(): Promise<boolean>;
     forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     forbidAll(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;

package/build/src/services/{model_has_role_permissions.js → models/model_has_role_permissions.js}

@@ -1,7 +1,7 @@
-import RolesService from './roles/roles_service.js';
-import { destructTarget, formatList } from './helper.js';
-import BaseAdapter from './base_adapter.js';
-import PermissionService from './permissions/permissions_service.js';
+import RolesService from '../roles/roles_service.js';
+import { destructTarget, formatList } from '../helper.js';
+import BaseAdapter from '../base_adapter.js';
+import PermissionService from '../permissions/permissions_service.js';
 export class ModelHasRolePermissions extends BaseAdapter {
     manager;
     map;
@@ -53,14 +53,39 @@ export class ModelHasRolePermissions extends BaseAdapter {
     flushRoles() {
         return this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());
     }
+    /**
+     * Sync roles with the model  (detach all roles and assign new roles)
+     * @param roles  - array of roles
+     * @param detach - if true, it will detach the existing roles
+     */
+    async syncRoles(roles, detach = true) {
+        if (detach) {
+            await this.flushRoles();
+        }
+        return this.assignAllRoles(...roles);
+    }
+    /**
+     * Sync roles with the model without detaching the existing ones
+     * @param roles
+     */
+    syncRolesWithoutDetaching(roles) {
+        return this.syncRoles(roles, false);
+    }
     // roles related section END
     // permissions related section BEGIN
     async permissions(includeForbiddings = false) {
         return this.permissionService.all(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
+    /**
+     * returns list of global permissions assigned to the model
+     * @param includeForbiddings
+     */
     async globalPermissions(includeForbiddings = false) {
         return this.permissionService.global(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
+    /**
+     * @param includeForbiddings
+     */
     async onResourcePermissions(includeForbiddings = false) {
         return this.permissionService.onResource(this.map.getAlias(this.model), this.model.getModelId(), includeForbiddings);
     }
@@ -106,9 +131,18 @@ export class ModelHasRolePermissions extends BaseAdapter {
         const result = await this.permissionService.containsAnyDirect(this.map.getAlias(this.model), this.model.getModelId(), permissions);
         return result;
     }
+    /**
+     * @param permission
+     * @param target
+     */
     async hasPermission(permission, target) {
         return this.hasAnyPermission([permission], target);
     }
+    /**
+     *
+     * @param permissions
+     * @param target
+     */
     async hasAllPermissions(permissions, target) {
         const entity = await destructTarget(this.map, target);
         return await this.permissionService.hasAll(this.map.getAlias(this.model), this.model.getModelId(), permissions, entity.targetClass, entity.targetId);
@@ -167,6 +201,10 @@ export class ModelHasRolePermissions extends BaseAdapter {
     async flushPermissions() {
         return this.permissionService.flush(this.map.getAlias(this.model), this.model.getModelId());
     }
+    async syncPermissions(permissions, target) {
+        await this.flushPermissions();
+        return this.allowAll(permissions, target);
+    }
     async flush() {
         await this.permissionService.flush(this.map.getAlias(this.model), this.model.getModelId());
         await this.roleService.flush(this.map.getAlias(this.model), this.model.getModelId());

package/build/src/services/{model_service.d.ts → models/model_service.d.ts}

@@ -1,6 +1,6 @@
-import BaseService from './base_service.js';
+import BaseService from '../base_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';
-import { ModelIdType, MorphInterface, OptionsInterface } from '../types.js';
+import { ModelIdType, MorphInterface, OptionsInterface } from '../../types.js';
 export default class ModelService extends BaseService {
     protected options: OptionsInterface;
     private modelPermissionClassName;
@@ -11,8 +11,8 @@ export default class ModelService extends BaseService {
     private modelRoleQuery;
     private readonly modelRoleTable;
     constructor(options: OptionsInterface, modelPermissionClassName: typeof BaseModel, modelRoleClassName: typeof BaseModel, map: MorphInterface);
-    all(roleId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    all(roleId: number): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelRoleModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     allFor(modelType: string, roleId: number): Promise<any>;
-    allByPermission(permissionId: ModelIdType): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
+    allByPermission(permissionId: ModelIdType): import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<import("@adonisjs/lucid/types/model").LucidModel, import("../../types.js").ModelPermissionModel<import("@adonisjs/lucid/types/model").LucidModel>>;
     allByPermissionFor(modelType: string, permissionId: ModelIdType): Promise<any>;
 }

package/build/src/services/{model_service.js → models/model_service.js}

@@ -1,5 +1,5 @@
-import BaseService from './base_service.js';
-import { getModelPermissionModelQuery, getModelRoleModelQuery } from './query_helper.js';
+import BaseService from '../base_service.js';
+import { getModelPermissionModelQuery, getModelRoleModelQuery } from '../query_helper.js';
 export default class ModelService extends BaseService {
     options;
     modelPermissionClassName;

package/build/src/services/permissions/permission_has_model_roles.d.ts

@@ -1,5 +1,5 @@
 import { AclModel, MorphInterface, OptionsInterface, PermissionInterface } from '../../types.js';
-import ModelService from '../model_service.js';
+import ModelService from '../models/model_service.js';
 import RoleService from '../roles/roles_service.js';
 import PermissionService from './permissions_service.js';
 import { BaseModel } from '@adonisjs/lucid/orm';

package/build/src/services/permissions/permission_has_model_roles.js

@@ -1,5 +1,5 @@
 import { destructTarget } from '../helper.js';
-import ModelService from '../model_service.js';
+import ModelService from '../models/model_service.js';
 import PermissionService from './permissions_service.js';
 import { getModelPermissionModelQuery, getRoleModelQuery } from '../query_helper.js';
 import BaseAdapter from '../base_adapter.js';

package/build/src/services/roles/role_has_model_permissions.d.ts

@@ -1,4 +1,4 @@
-import ModelService from '../model_service.js';
+import ModelService from '../models/model_service.js';
 import PermissionService from '../permissions/permissions_service.js';
 import { AclModel, MorphInterface, OptionsInterface, RoleInterface } from '../../types.js';
 import BaseAdapter from '../base_adapter.js';
@@ -64,6 +64,12 @@ export declare class RoleHasModelPermissions extends BaseAdapter {
     revokeAll(permissions: string[], target?: AclModel | Function): Promise<any[]>;
     revokeAllPermissions(permissions: string[]): Promise<any[]>;
     flush(): Promise<any[]>;
+    /**
+     * Sync permissions with the given list
+     * @param permissions - list of permissions
+     * @param target
+     */
+    sync(permissions: string[], target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     forbid(permission: string, target?: AclModel | Function): Promise<import("@adonisjs/lucid/types/model").LucidRow[]>;
     unforbid(permission: string, target?: AclModel | Function): Promise<any[]>;
 }

package/build/src/services/roles/role_has_model_permissions.js

@@ -1,5 +1,5 @@
 import { destructTarget } from '../helper.js';
-import ModelService from '../model_service.js';
+import ModelService from '../models/model_service.js';
 import PermissionService from '../permissions/permissions_service.js';
 import BaseAdapter from '../base_adapter.js';
 export class RoleHasModelPermissions extends BaseAdapter {
@@ -142,6 +142,15 @@ export class RoleHasModelPermissions extends BaseAdapter {
     async flush() {
         return this.permissionService.flush(this.map.getAlias(this.role), this.role.getModelId());
     }
+    /**
+     * Sync permissions with the given list
+     * @param permissions - list of permissions
+     * @param target
+     */
+    async sync(permissions, target) {
+        await this.flush();
+        return this.giveAll(permissions, target);
+    }
     async forbid(permission, target) {
         const entity = await destructTarget(this.map, target);
         return this.permissionService.forbid(this.map.getAlias(this.role), this.role.getModelId(), permission, entity.targetClass, entity.targetId);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@holoyan/adonisjs-permissions",
   "description": "Adonisjs roles and permissions system",
-  "version": "0.8.21",
+  "version": "0.8.23",
   "engines": {
     "node": ">=18.16.0"
   },