@jantstack/adonis-authz 2.5.0-alpha.3 → 2.5.0-rc.1

package/build/src/testing/migration_contract.js

@@ -586,4 +586,3 @@ export function registerMigrationContract(harness, api) {
         }
     });
 }
-//# sourceMappingURL=migration_contract.js.map

package/build/src/testing/relations_contract.d.ts

@@ -22,6 +22,13 @@ export declare const RELATIONS_CONTRACT_OBJECT_TYPES: readonly ["document", "wor
  * editor ⊆ viewer` (includes de un nivel) y `membersOf` habilitado en `database`.
  */
 export declare function contractRelationsConfig(): RelationsConfig;
+/**
+ * **La config del contrato CON techo de anidación de grupos** (lote «antes de RC» · R1, cierre: el runner publicado no
+ * tenía ningún caso del techo y un driver de terceros no tenía juez): la MISMA config que `contractRelationsConfig` con
+ * `maxGroupDepth` (por defecto 3) y el opt-in de `database` (`database.enforceGroupDepth`). Un driver que declare
+ * `groupDepthLimit()` tiene que responder con un techo ≤ ese número (la config solo BAJA el del driver) y aplicarlo.
+ */
+export declare function contractGroupDepthRelationsConfig(maxGroupDepth?: number): RelationsConfig;
 /**
  * **La config del contrato CON deny** (plan 2.5 · lote D · D1): los MISMOS dos tipos con el mismo retículo y, además,
  * un tercero sin opt-in —para que «deny sobre un tipo sin deny ⇒ 422» y «D8: un tipo sin opt-in también honra»
@@ -102,4 +109,3 @@ export declare function registerRelationsDriverContract(harness: RelationsDriver
     registered: number;
     covered: Set<keyof RelationsDriverCapabilities>;
 };
-//# sourceMappingURL=relations_contract.d.ts.map

package/build/src/testing/relations_contract.js

@@ -25,6 +25,7 @@ import { RenewalUnsafeError } from '../errors.js';
 import { RelationsManager } from '../relations/manager.js';
 import { defineRelationsConfig, assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, cutPathAllows, decideFrom, deniedRelationOf, denyPhaseOf, storedRelationKind, relationsDown, RELATION_DENY_PREFIX, } from '../relations/define_relations_config.js';
 import { assertCheckManyObjects, distinctObjects, expandByPosition, RELATIONS_CHECK_MANY_MAX } from '../relations/check_many.js';
+import { assertEnumeratePage, assertNoListPage } from '../relations/page.js';
 import { systemClock } from '../clock.js';
 import { resolveGrantExpiry, sameInstant } from '../expiry.js';
 import { isRelUserset } from '../types.js';
@@ -59,6 +60,23 @@ export function contractRelationsConfig() {
         database: { membersOf: true },
     });
 }
+/**
+ * **La config del contrato CON techo de anidación de grupos** (lote «antes de RC» · R1, cierre: el runner publicado no
+ * tenía ningún caso del techo y un driver de terceros no tenía juez): la MISMA config que `contractRelationsConfig` con
+ * `maxGroupDepth` (por defecto 3) y el opt-in de `database` (`database.enforceGroupDepth`). Un driver que declare
+ * `groupDepthLimit()` tiene que responder con un techo ≤ ese número (la config solo BAJA el del driver) y aplicarlo.
+ */
+export function contractGroupDepthRelationsConfig(maxGroupDepth = 3) {
+    return defineRelationsConfig({
+        objectTypes: RELATIONS_CONTRACT_OBJECT_TYPES.map((type) => ({
+            type,
+            relations: [{ name: 'owner' }, { name: 'editor', includes: ['owner'] }, { name: 'viewer', includes: ['editor'] }],
+        })),
+        holderTypes: [...RELATIONS_HOLDER_TYPES],
+        database: { membersOf: true, enforceGroupDepth: true },
+        maxGroupDepth,
+    });
+}
 /**
  * **La config del contrato CON deny** (plan 2.5 · lote D · D1): los MISMOS dos tipos con el mismo retículo y, además,
  * un tercero sin opt-in —para que «deny sobre un tipo sin deny ⇒ 422» y «D8: un tipo sin opt-in también honra»
@@ -308,10 +326,12 @@ function buildRelationsDouble(options, tuples, now) {
             assertSubjectDeclared(subject);
             return resolves(subject, relation, object, scopeKeyOf(partition));
         },
-        async listObjects(subject, relation, objectType, partition, page) {
+        async listObjects(subject, relation, objectType, partition) {
             assertRelationDeclared(config, { type: objectType }, relation);
             assertSubjectDeclared(subject);
             const partitionKey = scopeKeyOf(partition);
+            // 7.4: el doble tampoco pagina (un quinto argumento ≠ undefined ⇒ 500), después de F-05 y la partición.
+            assertNoListPage('listObjects', arguments[4], 'double');
             const ids = new Set();
             for (const t of tuples) {
                 if (t.partition === partitionKey && t.objectType === objectType && active(t))
@@ -332,9 +352,10 @@ function buildRelationsDouble(options, tuples, now) {
             }
             return { objects: matches };
         },
-        async listSubjects(relation, object, partition, page) {
+        async listSubjects(relation, object, partition) {
             assertRelationDeclared(config, object, relation);
             const partitionKey = scopeKeyOf(partition);
+            assertNoListPage('listSubjects', arguments[3], 'double');
             // DIRECTOS del relation EXACTO (invariante 7): ni transitivo (eso es
             // `membersOf`) ni derivado. `usersetSubjects` decide si los usersets
             // (`group:g#member`) salen o solo los holders.
@@ -422,9 +443,11 @@ function buildRelationsDouble(options, tuples, now) {
             assertRelationDeclared(config, object, relation);
             return denyPhaseOf(config, object.type) ?? null;
         };
-        driver.listDenies = async (relation, object, partition) => {
+        driver.listDenies = async function (relation, object, partition) {
             assertRelationDeclared(config, object, relation);
-            const direct = directSubjects(scopeKeyOf(partition), object.type, object.id, deniedRelationOf(relation));
+            const key = scopeKeyOf(partition);
+            assertNoListPage('listDenies', arguments[3], 'double');
+            const direct = directSubjects(key, object.type, object.id, deniedRelationOf(relation));
             return { subjects: dedupeSubjects(direct.map((t) => t.subject)) };
         };
         driver.decideMany = async (subject, relation, objects, partition) => {
@@ -444,16 +467,19 @@ function buildRelationsDouble(options, tuples, now) {
         };
     }
     if (capabilities.membersOfNative) {
-        driver.membersOf = async (object, relation, partition) => {
+        driver.membersOf = async function (object, relation, partition) {
             assertRelationDeclared(config, object, relation);
             // Lote D: `membersOf` RESTA (corte de camino por candidato, como `database`).
             const key = scopeKeyOf(partition);
+            assertNoListPage('membersOf', arguments[3], 'double');
             return { subjects: collectMembers(object, relation, key).filter((s) => resolves(s, relation, object, key)) };
         };
     }
     if (capabilities.enumerateRelations) {
-        driver.enumerateRelations = async (partition) => {
+        driver.enumerateRelations = async (partition, page) => {
             const partitionKey = scopeKeyOf(partition);
+            // 7.4: la misma forma que los drivers reales; el doble no emite cursor (todo en una página) ⇒ after es 500.
+            assertEnumeratePage('enumerateRelations', page, 'none', 'double');
             // SIN filtrar la caducada (R-15): llega con su `expiresAt` para que el
             // destino de reconcile la cuente en `skipped`, no para que desaparezca.
             const out = tuples
@@ -703,6 +729,46 @@ export function registerRelationsDriverContract(harness, api) {
             await state.manager.relate({ object: g2, relation: 'member' }, 'viewer', doc, p);
             assert.isTrue(await state.manager.check(u, 'viewer', doc, p));
         });
+        /* ── R1 (lote «antes de RC»): el techo de anidación de grupos, si el driver lo declara ── */
+        test('R1 · groupDepthLimit (si el driver lo declara): con maxGroupDepth 3 + database.enforceGroupDepth el techo es ≤ 3 y se APLICA — la arista que deja una cadena más larga, por ARRIBA o por ABAJO, o que cierra un ciclo ⇒ 422 E_AUTHZ_GROUP_DEPTH_LIMIT sin escribir (check sigue F) y sin evento por el manager; la membresía de un holder y una relación de dominio no son anidación', async ({ assert, }) => {
+            const config = contractGroupDepthRelationsConfig(3);
+            const driver = await harness.makeDriver(config);
+            // `groupDepthLimit` es OPCIONAL en el puerto: un driver sin él no declara techo (el plan del reconcile no tiene
+            // nada que negar) y no hay gate que juzgar. Lo mismo un driver que responde `null` (sin techo con esta config).
+            const limit = typeof driver.groupDepthLimit === 'function' ? await driver.groupDepthLimit() : null;
+            if (limit === null)
+                return;
+            assert.isTrue(Number.isInteger(limit) && limit >= 1 && limit <= 3, `el techo con maxGroupDepth 3 tiene que estar en 1..3 (llegó ${String(limit)})`);
+            const events = [];
+            const manager = new RelationsManager(driver, config, { driverName: harness.name, onRelationWrite: (e) => void events.push(e) });
+            const p = partition();
+            const g = Array.from({ length: limit + 2 }, () => ({ type: 'group', id: docId() }));
+            const member = (o) => ({ object: o, relation: 'member' });
+            for (let i = 0; i < limit; i++)
+                await manager.relate(member(g[i]), 'member', g[i + 1], p);
+            const u = holder();
+            await manager.relate(u, 'member', g[0], p);
+            assert.isTrue(await manager.check(u, 'member', g[limit], p), `una cadena de ${limit} saltos (el techo) entra y resuelve`);
+            const before = events.length;
+            const refused = async (label, run) => {
+                const error = await run().then(() => null, (e) => e);
+                assert.equal(error?.status, 422, `${label}: ${error?.message ?? 'entró'}`);
+                assert.equal(error?.code, 'E_AUTHZ_GROUP_DEPTH_LIMIT', label);
+                return error;
+            };
+            await refused('por ARRIBA (la cima de la cadena dentro de otro grupo)', () => manager.relate(member(g[limit]), 'member', g[limit + 1], p));
+            assert.isFalse(await manager.check(u, 'member', g[limit + 1], p), 'la arista rechazada no se escribió');
+            const x = { type: 'group', id: docId() };
+            await refused('por ABAJO (otro grupo dentro de la base de la cadena)', () => manager.relate(member(x), 'member', g[0], p));
+            const v = holder();
+            await manager.relate(v, 'member', x, p);
+            assert.isFalse(await manager.check(v, 'member', g[0], p), 'x ⊂ g0 no se escribió');
+            await refused('el CICLO', () => manager.relate(member(g[limit]), 'member', g[0], p));
+            assert.equal(events.length, before + 1, '422 ⇒ esa escritura no ocurrió y no hay evento (invariante 13): solo el del holder v');
+            // No es anidación: la membresía de un holder y una relación de dominio sobre la cima.
+            await manager.relate(holder(), 'member', g[limit], p);
+            await manager.relate(member(g[limit]), 'viewer', { type: 'document', id: docId() }, p);
+        });
         /* ── R-05: la partición aísla ── */
         test('R-05 · partición: relate en A no concede en B', async ({ assert }) => {
             const u = holder();
@@ -750,6 +816,93 @@ export function registerRelationsDriverContract(harness, api) {
             const page = await state.manager.listObjects(u, 'viewer', 'document', p);
             assert.sameMembers(page.objects.map((o) => o.id).sort(), [d1.id, d2.id].sort());
         });
+        /* ── 7.4 (lote «antes de RC», opción 4 del juez): los listados NO paginan ── */
+        /**
+         * **P13 · «sin página ⇒ lista completa y sin cursor»** (injerto 1 del juez; auditor R1-2, tester P13). N = 150:
+         * por encima del default de 100 de `enumerate*` de `database` y del `page_size` 100 de `Read` en OpenFGA, así que
+         * un driver que pagina por dentro y devuelve la PRIMERA página (o un cursor que nadie lee) es rojo aquí. El tipo ya
+         * no tiene `cursor` (protege a quien compila); este caso protege en EJECUCIÓN frente a un driver de terceros y a un
+         * default de `limit` que alguien meta en 2.6. `listObjects` puede venir `truncated` SOLO si el driver declara
+         * `listObjectsTruncation` (y entonces lo que trae ⊆ lo escrito); los demás, el conjunto exacto.
+         */
+        test('7.4 · P13 · sin page los listados son EXHAUSTIVOS y sin cursor: N=150 (> 100 de enumerate y del page_size de Read) en listSubjects y listObjects —y listDenies con relationDenies, membersOf con membersOfNative—; listObjects truncated solo con listObjectsTruncation', async ({ assert, }) => {
+            const N = 150;
+            const p = partition();
+            const users = Array.from({ length: N }, () => holder());
+            const ids = (subjects) => subjects.map((s) => s.uuid).sort();
+            const expected = users.map((u) => u.uuid).sort();
+            const doc = { type: 'document', id: docId() };
+            for (const u of users)
+                await state.manager.relate(u, 'viewer', doc, p);
+            const subjects = await state.manager.listSubjects('viewer', doc, p);
+            assert.notProperty(subjects, 'cursor', 'listSubjects sin page no devuelve cursor');
+            assert.notEqual(subjects.truncated, true, 'listSubjects no corta (Read se agota o lanza)');
+            assert.deepEqual(ids(subjects.subjects), expected, `listSubjects devuelve los ${N}, no una página`);
+            const reader = holder();
+            const docs = Array.from({ length: N }, () => docId());
+            for (const id of docs)
+                await state.manager.relate(reader, 'viewer', { type: 'document', id }, p);
+            const objects = await state.manager.listObjects(reader, 'viewer', 'document', p);
+            assert.notProperty(objects, 'cursor', 'listObjects sin page no devuelve cursor');
+            const got = objects.objects.map((o) => o.id).sort();
+            if (objects.truncated === true) {
+                assert.isTrue(harness.capabilities.listObjectsTruncation, 'truncated sin declarar listObjectsTruncation');
+                assert.includeMembers(docs, got, 'lo que trae una lista truncada es de lo escrito');
+            }
+            else {
+                assert.deepEqual(got, [...docs].sort(), `listObjects devuelve los ${N}, no una página`);
+            }
+            if (harness.capabilities.membersOfNative) {
+                const group = { type: 'group', id: docId() };
+                for (const u of users)
+                    await state.manager.relate(u, 'member', group, p);
+                const members = await state.manager.membersOf(group, 'member', p);
+                assert.notProperty(members, 'cursor', 'membersOf sin page no devuelve cursor');
+                assert.deepEqual(ids(members.subjects), expected, `membersOf devuelve los ${N}`);
+            }
+            if (harness.capabilities.relationDenies) {
+                const { manager } = await denyManager();
+                const denied = { type: 'document', id: docId() };
+                for (const u of users)
+                    await manager.deny(u, 'viewer', denied, p);
+                const denies = await manager.listDenies('viewer', denied, p);
+                assert.notProperty(denies, 'cursor', 'listDenies sin page no devuelve cursor');
+                assert.deepEqual(ids(denies.subjects), expected, `listDenies devuelve los ${N}`);
+            }
+        });
+        /**
+         * **RC74-1 · página en los cuatro listados ⇒ 500, cero llamadas** (capa MANAGER, sobre el driver del harness). En
+         * 2.6 este caso pasa a ser la cara `whenFalse` de cada capacidad de paginación. `undefined` EXPLÍCITO entra
+         * (RC74-3). No se exige al driver en directo: obligaría a un tercero a un 500 por un parámetro que ya no está en
+         * el tipo (lo cubren la guardia y los specs de los drivers del paquete).
+         */
+        test('7.4 · RC74-1 · listObjects/listSubjects/listDenies/membersOf con page ({ limit: 1 }, null, {}) ⇒ 500 E_AUTHZ_UNSUPPORTED nombrando la operación, con CERO llamadas al driver; undefined explícito entra (RC74-3)', async ({ assert, }) => {
+            const u = holder();
+            const doc = { type: 'document', id: docId() };
+            const group = { type: 'group', id: docId() };
+            const p = partition();
+            const m = state.manager;
+            const calls = [
+                ['listObjects', (page) => m.listObjects(u, 'viewer', 'document', p, page)],
+                ['listSubjects', (page) => m.listSubjects('viewer', doc, p, page)],
+                ['listDenies', (page) => m.listDenies('viewer', doc, p, page)],
+                ['membersOf', (page) => m.membersOf(group, 'member', p, page)],
+            ];
+            for (const [operation, call] of calls) {
+                for (const page of [{ limit: 1 }, null, {}]) {
+                    const before = state.calls();
+                    const caught = await call(page).then(() => null, (e) => e);
+                    assert.isNotNull(caught, `${operation}(…, ${JSON.stringify(page)}) entró: una página que no hace nada es una lista entera que parece una página`);
+                    assert.equal(caught.status, 500, `${operation}: ${caught.message}`);
+                    assert.equal(caught.code, 'E_AUTHZ_UNSUPPORTED', `${operation}: ${caught.message}`);
+                    assert.include(caught.message, operation);
+                    assert.equal(state.calls(), before, `${operation} con page: CERO llamadas al driver`);
+                }
+            }
+            // RC74-3: el argumento `undefined` explícito es «sin página» (quien reenvía un opcional vacío no se rompe).
+            assert.isArray((await m.listObjects(u, 'viewer', 'document', p, undefined)).objects);
+            assert.isArray((await m.listSubjects('viewer', doc, p, undefined)).subjects);
+        });
         /* ── R-12: identidad mal formada ⇒ 422 ── */
         test('R-12 · partición mal formada ⇒ 422 con code', async ({ assert }) => {
             const u = holder();
@@ -1783,6 +1936,21 @@ export function registerRelationsDriverContract(harness, api) {
             for (const r of denies)
                 await m.deny(u, r, object, p);
         }
+        /* ── Estrategia 2.5.0 · firma 4 · el par `experimental` (regla D15; mismo nombre que en roles) ── */
+        // Dice lo que el consumidor tiene que saber («fuera de la garantía de la versión») y no apaga casos: el runner corre
+        // ENTERO contra un driver experimental. Se observa la declaración del driver y la copia normalizada del manager.
+        caseFor('experimental', {
+            whenTrue: () => test('experimental:true · el driver se declara EXPERIMENTAL (capabilities.experimental === true) y `relations.capabilities()` lo publica tal cual; el runner corre igual contra él', async ({ assert }) => {
+                assert.strictEqual(state.base.capabilities?.experimental, true, 'el harness declara experimental: true y el driver no: declara lo observable');
+                const published = state.manager.capabilities();
+                assert.strictEqual(published.experimental, true);
+                assert.isTrue(Object.isFrozen(published));
+            }),
+            whenFalse: () => test('experimental:false · el driver NO se declara experimental (ausente o false) y `relations.capabilities().experimental` es false, nunca undefined (D15)', async ({ assert }) => {
+                assert.notStrictEqual(state.base.capabilities?.experimental, true, 'el harness declara experimental: false y el driver declara true: declara lo observable');
+                assert.strictEqual(state.manager.capabilities().experimental, false);
+            }),
+        });
         /* ── Cierre 2 de D2 · 🟠 N1 · el par `atomicRenewal` (renovar una membresía que TRANSPORTA un deny) ── */
         /**
          * Siembra: U ∈ g con caducidad (+1 h), un allow DIRECTO de U sobre X y —si el driver deniega— el deny de `g#member`
@@ -2361,4 +2529,3 @@ export function registerRelationsDriverContract(harness, api) {
     });
     return { registered, covered };
 }
-//# sourceMappingURL=relations_contract.js.map

package/build/src/testing/relations_reconcile_contract.d.ts

@@ -30,4 +30,3 @@ export declare function registerRelationsReconcileContract(harness: RelationsRec
 }): {
     registered: number;
 };
-//# sourceMappingURL=relations_reconcile_contract.d.ts.map

package/build/src/testing/relations_reconcile_contract.js

@@ -424,4 +424,3 @@ export function registerRelationsReconcileContract(harness, api) {
     });
     return { registered };
 }
-//# sourceMappingURL=relations_reconcile_contract.js.map

package/build/src/testing/scope_outbox_contract.d.ts

@@ -108,4 +108,3 @@ export declare function registerScopeOutboxContract(harness: ScopeOutboxContract
     registered: number;
     covered: Set<keyof ScopeOutboxCapabilities>;
 };
-//# sourceMappingURL=scope_outbox_contract.d.ts.map

package/build/src/testing/scope_outbox_contract.js

@@ -752,4 +752,3 @@ export function registerScopeOutboxContract(harness, api) {
     });
     return { registered, covered };
 }
-//# sourceMappingURL=scope_outbox_contract.js.map

package/build/src/testing/scope_tree.d.ts

@@ -62,4 +62,3 @@ export declare function descendantsFrom(tree: ContractScopeTree): ScopeDescendan
  */
 export declare function memoryScopeTree(): ContractScopeTree;
 export { APP_SCOPE };
-//# sourceMappingURL=scope_tree.d.ts.map

package/build/src/testing/scope_tree.js

@@ -142,4 +142,3 @@ export function memoryScopeTree() {
     };
 }
 export { APP_SCOPE };
-//# sourceMappingURL=scope_tree.js.map

package/build/src/testing/test_clock.d.ts

@@ -12,4 +12,3 @@ export interface TestClock {
 }
 /** Un reloj de test parado en `start` (default: la hora de pared al crearlo), controlable con `set`/`advance`. */
 export declare function createTestClock(start?: Date | number | string): TestClock;
-//# sourceMappingURL=test_clock.d.ts.map

package/build/src/testing/test_clock.js

@@ -62,4 +62,3 @@ export function createTestClock(start = systemClock()) {
     clock.at = (offsetMs) => new Date(current + offsetMs);
     return clock;
 }
-//# sourceMappingURL=test_clock.js.map

package/build/src/traits/authz_scopes.d.ts

@@ -42,4 +42,3 @@ export type WithAuthzScopes<T extends Constructor> = T & AuthzScopesStatics;
  */
 export declare function withAuthzScopes<T extends Constructor | AuthzScopesOptions>(arg: T): T extends Constructor ? WithAuthzScopes<T> : <U extends Constructor>(Base: U) => WithAuthzScopes<U>;
 export {};
-//# sourceMappingURL=authz_scopes.d.ts.map

package/build/src/traits/authz_scopes.js

@@ -54,4 +54,3 @@ export function withAuthzScopes(arg) {
     const clock = options.clock ?? systemClock;
     return (Base) => mixin(Base, clock);
 }
-//# sourceMappingURL=authz_scopes.js.map

package/build/src/traits/has_uuid.d.ts

@@ -81,6 +81,11 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
         <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 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event>): void;
     };
+    before: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event_1>): 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_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;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -117,11 +122,6 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
     };
     $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_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event_1>): 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_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 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>>;
     createQuietly: <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>[]>;
@@ -148,4 +148,3 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
     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>[]>;
 } & Model;
-//# sourceMappingURL=has_uuid.d.ts.map

package/build/src/traits/has_uuid.js

@@ -35,4 +35,3 @@ export const hasUuid = (superclass) => {
     ], WithPrimaryUuidClass, "generateUuid", null);
     return WithPrimaryUuidClass;
 };
-//# sourceMappingURL=has_uuid.js.map