npm - @decaf-ts/integrations - Versions diffs - 0.3.6 → 0.3.7 - Mend

@decaf-ts/integrations 0.3.6 → 0.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (878) hide show

package/dist/integrations.cjs CHANGED Viewed

@@ -1,2 +1,1649 @@
-var e,o;e=this,o=(e,o,i,n)=>{"use strict";e.COMMIT="02ba094",e.FULL_VERSION="0.3.5-02ba094",e.PACKAGE_NAME="@decaf-ts/integrations",e.VERSION="0.3.5",e.execWithLogging=async(e,t,r,d=i.LogLevel.info)=>(r.debug("Executing: "+e),new Promise((i,s)=>{const c=o.exec(e,t),a=[],l=[];c.stdout?.on("data",e=>{a.push(e),r[d](e.trim())}),c.stderr?.on("data",e=>{l.push(e),r.debug(e.trim())}),c.on("close",e=>{0===e?(r.silly("Command completed successfully"),i({stdout:a.join("\n"),stderr:l.join("\n")})):(r.critical(`Command failed with code ${e}:\n ${l.join("\n")}`),s(new n.InternalError(`Command failed with code ${e}: ${l.join("\n")}`)))}),c.on("error",e=>{r.critical("Command execution error",e),s(e)})}))},"object"==typeof exports&&"undefined"!=typeof module?o(exports,require("child_process"),require("@decaf-ts/logging"),require("@decaf-ts/db-decorators")):"function"==typeof define&&define.amd?define(["exports","child_process","@decaf-ts/logging","@decaf-ts/db-decorators"],o):o((e="undefined"!=typeof globalThis?globalThis:e||self).integrations={},e.childProcess,e.decafTsLogging,e.decafTsDbDecorators);
-//# sourceMappingURL=integrations.cjs.map
+(function(global, factory) {
+    typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("child_process"), require("@decaf-ts/logging"), require("@decaf-ts/db-decorators"), require("@decaf-ts/core"), require("@decaf-ts/decorator-validation"), require("tslib")) : typeof define === "function" && define.amd ? define([ "exports", "child_process", "@decaf-ts/logging", "@decaf-ts/db-decorators", "@decaf-ts/core", "@decaf-ts/decorator-validation", "tslib" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self,
+    factory(global.integrations = {}, global.childProcess, global.decafTsLogging, global.decafTsDbDecorators, global.decafTsCore, global.decafTsDecoratorValidation, global.tslib));
+})(this, function(exports, child_process, logging, dbDecorators, core, decoratorValidation, tslib) {
+    "use strict";
+    async function execWithLogging(command, options, log, level = logging.LogLevel.info) {
+        log.debug(`Executing: ${command}`);
+        return new Promise((resolve, reject) => {
+            const child = child_process.exec(command, options);
+            const stdout = [];
+            const stderr = [];
+            child.stdout?.on("data", data => {
+                stdout.push(data);
+                log[level](data.trim());
+            });
+            child.stderr?.on("data", data => {
+                stderr.push(data);
+                log.debug(data.trim());
+            });
+            child.on("close", code => {
+                if (code === 0) {
+                    log.silly(`Command completed successfully`);
+                    resolve({
+                        stdout: stdout.join("\n"),
+                        stderr: stderr.join("\n")
+                    });
+                } else {
+                    log.critical(`Command failed with code ${code}:\n ${stderr.join("\n")}`);
+                    reject(new dbDecorators.InternalError(`Command failed with code ${code}: ${stderr.join("\n")}`));
+                }
+            });
+            child.on("error", err => {
+                log.critical(`Command execution error`, err);
+                reject(err);
+            });
+        });
+    }
+    exports.IsolationTier = void 0;
+    (function(IsolationTier) {
+        IsolationTier["Pooled"] = "pooled";
+        IsolationTier["Bridge"] = "bridge";
+        IsolationTier["Silo"] = "silo";
+    })(exports.IsolationTier || (exports.IsolationTier = {}));
+    exports.MembershipStatus = void 0;
+    (function(MembershipStatus) {
+        MembershipStatus["Invited"] = "invited";
+        MembershipStatus["Active"] = "active";
+        MembershipStatus["Suspended"] = "suspended";
+        MembershipStatus["Removed"] = "removed";
+    })(exports.MembershipStatus || (exports.MembershipStatus = {}));
+    exports.PrincipalKind = void 0;
+    (function(PrincipalKind) {
+        PrincipalKind["User"] = "user";
+        PrincipalKind["Group"] = "group";
+        PrincipalKind["ServiceAccount"] = "service_account";
+        PrincipalKind["Agent"] = "agent";
+        PrincipalKind["ApiKey"] = "api_key";
+    })(exports.PrincipalKind || (exports.PrincipalKind = {}));
+    exports.ScopeKind = void 0;
+    (function(ScopeKind) {
+        ScopeKind["Tenant"] = "tenant";
+        ScopeKind["OrgUnit"] = "org_unit";
+        ScopeKind["Resource"] = "resource";
+    })(exports.ScopeKind || (exports.ScopeKind = {}));
+    exports.PermissionCategory = void 0;
+    (function(PermissionCategory) {
+        PermissionCategory["Admin"] = "admin";
+        PermissionCategory["ContentRead"] = "content_read";
+        PermissionCategory["ContentWrite"] = "content_write";
+        PermissionCategory["Memory"] = "memory";
+        PermissionCategory["Graph"] = "graph";
+        PermissionCategory["Vector"] = "vector";
+        PermissionCategory["Export"] = "export";
+        PermissionCategory["Billing"] = "billing";
+        PermissionCategory["Audit"] = "audit";
+        PermissionCategory["Security"] = "security";
+        PermissionCategory["Data"] = "data";
+        PermissionCategory["Automation"] = "automation";
+    })(exports.PermissionCategory || (exports.PermissionCategory = {}));
+    exports.ResourceVisibility = void 0;
+    (function(ResourceVisibility) {
+        ResourceVisibility["Private"] = "private";
+        ResourceVisibility["ResourceAcl"] = "resource_acl";
+        ResourceVisibility["OrgUnit"] = "org_unit";
+        ResourceVisibility["OrgSubtree"] = "org_subtree";
+        ResourceVisibility["Tenant"] = "tenant";
+    })(exports.ResourceVisibility || (exports.ResourceVisibility = {}));
+    exports.StorageKind = void 0;
+    (function(StorageKind) {
+        StorageKind["Postgres"] = "postgres";
+        StorageKind["Arango"] = "arango";
+        StorageKind["Qdrant"] = "qdrant";
+        StorageKind["ObjectStorage"] = "object_storage";
+    })(exports.StorageKind || (exports.StorageKind = {}));
+    exports.StorageBindingKind = void 0;
+    (function(StorageBindingKind) {
+        StorageBindingKind["Shared"] = "shared";
+        StorageBindingKind["Dedicated"] = "dedicated";
+    })(exports.StorageBindingKind || (exports.StorageBindingKind = {}));
+    const IsolationTierOptions = Object.values(exports.IsolationTier);
+    const MembershipStatusOptions = Object.values(exports.MembershipStatus);
+    const PrincipalKindOptions = Object.values(exports.PrincipalKind);
+    const ScopeKindOptions = Object.values(exports.ScopeKind);
+    const PermissionCategoryOptions = Object.values(exports.PermissionCategory);
+    const ResourceVisibilityOptions = Object.values(exports.ResourceVisibility);
+    const StorageKindOptions = Object.values(exports.StorageKind);
+    const StorageBindingKindOptions = Object.values(exports.StorageBindingKind);
+    const REL_RESTRICT = {
+        update: core.Cascade.NONE,
+        delete: core.Cascade.NONE,
+        nullable: false
+    };
+    const REL_NULLIFY = {
+        update: core.Cascade.NONE,
+        delete: core.Cascade.NONE,
+        nullable: true
+    };
+    const REL_CASCADE_DEPENDENT = {
+        update: core.Cascade.CASCADE,
+        delete: core.Cascade.CASCADE,
+        nullable: false
+    };
+    const REL_CASCADE_INSERT_UPDATE = {
+        update: core.Cascade.CASCADE,
+        delete: core.Cascade.NONE,
+        nullable: false
+    };
+    function buildArangoContext(options) {
+        return {
+            tenantId: options.tenantId,
+            principalId: options.principalId,
+            permissionKey: options.permissionKey,
+            allowedOrgUnitIds: [ ...options.allowedOrgUnitIds ],
+            allowedResourceIds: [ ...options.allowedResourceIds ]
+        };
+    }
+    function buildQdrantFilter(options) {
+        return {
+            must: [ {
+                key: "tenant_id",
+                match: {
+                    value: options.tenantId
+                }
+            }, {
+                should: [ {
+                    key: "org_unit_id",
+                    match: {
+                        any: options.allowedOrgUnitIds
+                    }
+                }, {
+                    key: "protected_resource_id",
+                    match: {
+                        any: options.allowedResourceIds
+                    }
+                }, {
+                    key: "owner_principal_id",
+                    match: {
+                        value: options.principalId
+                    }
+                } ]
+            } ]
+        };
+    }
+    function scopeKey$1(scopeKind, scopeId) {
+        return `${scopeKind}:${scopeId}`;
+    }
+    function nowIso() {
+        return new Date;
+    }
+    function asArray(value) {
+        return value ?? [];
+    }
+    function sameTenant(rowTenant, tenantId) {
+        return relationId(rowTenant) === tenantId;
+    }
+    function relationMatch(value, target) {
+        return target ? relationId(value) === target : false;
+    }
+    function lowerSlug(value) {
+        return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "item";
+    }
+    function isTimeValid(at, startsAt, expiresAt) {
+        const instant = at ?? new Date;
+        if (startsAt && instant < startsAt) return false;
+        if (expiresAt && instant > expiresAt) return false;
+        return true;
+    }
+    function buildAccessContext(options) {
+        const permissionsByScope = {};
+        const allowedOrgUnitIdsByPermission = {};
+        for (const permission of options.permissions) {
+            const key = scopeKey$1(permission.scopeKind, permission.scopeId);
+            permissionsByScope[key] = permissionsByScope[key] ?? [];
+            permissionsByScope[key].push(permission.permissionKey);
+            if (permission.scopeKind === exports.ScopeKind.OrgUnit) {
+                allowedOrgUnitIdsByPermission[permission.permissionKey] = allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];
+                allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);
+            }
+        }
+        return {
+            tenantId: options.tenantId,
+            principalId: options.principalId,
+            permissionsByScope: permissionsByScope,
+            allowedOrgUnitIdsByPermission: allowedOrgUnitIdsByPermission,
+            resourceGrants: options.grants.map(grant => ({
+                resourceId: grant.resourceId,
+                permissionKey: grant.permissionKey
+            }))
+        };
+    }
+    class BaseModelService extends core.ModelService {
+        constructor(clazz) {
+            super(clazz);
+        }
+        newModel(clazz, data) {
+            return Object.assign(new clazz, data);
+        }
+        async create(data, ...args) {
+            return this.repo.create(Object.assign({}, data), ...args);
+        }
+        async createOne(data, ...args) {
+            return this.create(data, ...args);
+        }
+        async getById(id, ...args) {
+            return this.repo.read(id, ...args);
+        }
+        async updateOne(id, patch, ...args) {
+            const existing = await this.repo.read(id, ...args);
+            return this.repo.update(Object.assign(existing, patch), ...args);
+        }
+        async deleteById(id, ...args) {
+            await this.repo.delete(id, ...args);
+        }
+        async findOneBy(key, value, ...args) {
+            return this.repo.findOneBy(key, value, ...args);
+        }
+        async findManyBy(key, value, ...args) {
+            return this.repo.select().where({
+                [key]: value
+            }).execute(...args);
+        }
+        async listAll(...args) {
+            return this.repo.select().execute(...args);
+        }
+    }
+    function id() {
+        return crypto.randomUUID();
+    }
+    function relationId(value) {
+        return typeof value === "string" ? value : value.id;
+    }
+    class AuthorizationModel extends decoratorValidation.Model {
+        constructor(data) {
+            super(data);
+        }
+    }
+    exports.TenantMembership = class TenantMembership extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.TenantMembership.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_memberships_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.TenantMembership.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.User, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_memberships_user"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.TenantMembership.prototype, "user", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(MembershipStatusOptions), core.column(), tslib.__metadata("design:type", String) ], exports.TenantMembership.prototype, "status", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.TenantMembership.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.TenantMembership.prototype, "updatedAt", void 0);
+    exports.TenantMembership = tslib.__decorate([ core.table("tenant_memberships"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.TenantMembership);
+    exports.User = class User extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.User.prototype, "id", void 0);
+    tslib.__decorate([ core.unique(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.User.prototype, "email", void 0);
+    tslib.__decorate([ core.unique(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.User.prototype, "phone", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.User.prototype, "displayName", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.TenantMembership, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.User.prototype, "tenantMemberships", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnitMembership, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.User.prototype, "orgUnitMemberships", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.User.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.User.prototype, "updatedAt", void 0);
+    exports.User = tslib.__decorate([ core.table("users"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.User);
+    exports.OrgUnitMembership = class OrgUnitMembership extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.OrgUnitMembership.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_memberships_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitMembership.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_memberships_org_unit"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitMembership.prototype, "orgUnit", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.User, REL_RESTRICT, false, undefined, "fk_org_memberships_user"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitMembership.prototype, "user", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(MembershipStatusOptions), core.column(), tslib.__metadata("design:type", String) ], exports.OrgUnitMembership.prototype, "status", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnitMembership.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnitMembership.prototype, "updatedAt", void 0);
+    exports.OrgUnitMembership = tslib.__decorate([ core.table("org_unit_memberships"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.OrgUnitMembership);
+    exports.OrgUnitClosure = class OrgUnitClosure extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.OrgUnitClosure.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitClosure.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_ancestor"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitClosure.prototype, "ancestor", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_descendant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitClosure.prototype, "descendant", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(Number), core.column(), tslib.__metadata("design:type", Number) ], exports.OrgUnitClosure.prototype, "depth", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnitClosure.prototype, "createdAt", void 0);
+    exports.OrgUnitClosure = tslib.__decorate([ core.table("org_unit_closure"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.OrgUnitClosure);
+    exports.Permission = class Permission extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.Permission.prototype, "id", void 0);
+    tslib.__decorate([ core.unique(), decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Permission.prototype, "key", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(PermissionCategoryOptions), core.column(), tslib.__metadata("design:type", String) ], exports.Permission.prototype, "category", void 0);
+    tslib.__decorate([ decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Permission.prototype, "description", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.RolePermission, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Permission.prototype, "rolePermissions", void 0);
+    exports.Permission = tslib.__decorate([ core.table("permissions"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.Permission);
+    exports.RolePermission = class RolePermission extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.RolePermission.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Role, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_permissions_role"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.RolePermission.prototype, "role", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Permission, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_permissions_permission"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.RolePermission.prototype, "permission", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.RolePermission.prototype, "createdAt", void 0);
+    exports.RolePermission = tslib.__decorate([ core.table("role_permissions"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.RolePermission);
+    exports.Role = class Role extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.Role.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_NULLIFY, false, undefined, "fk_roles_tenant"), tslib.__metadata("design:type", Object) ], exports.Role.prototype, "tenant", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Role.prototype, "key", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Role.prototype, "name", void 0);
+    tslib.__decorate([ decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Role.prototype, "description", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.Role.prototype, "metadata", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.RolePermission, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Role.prototype, "rolePermissions", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.RoleAssignment, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Role.prototype, "assignments", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.Role.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.Role.prototype, "updatedAt", void 0);
+    exports.Role = tslib.__decorate([ core.table("roles"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.Role);
+    exports.RoleAssignment = class RoleAssignment extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.RoleAssignment.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_assignments_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.RoleAssignment.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_assignments_principal"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.RoleAssignment.prototype, "principal", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Role, REL_RESTRICT, false, undefined, "fk_role_assignments_role"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.RoleAssignment.prototype, "role", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(ScopeKindOptions), core.column(), tslib.__metadata("design:type", String) ], exports.RoleAssignment.prototype, "scopeKind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.RoleAssignment.prototype, "scopeId", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(Boolean), core.column(), tslib.__metadata("design:type", Boolean) ], exports.RoleAssignment.prototype, "inheritDown", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.RoleAssignment.prototype, "startsAt", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.RoleAssignment.prototype, "expiresAt", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.RoleAssignment.prototype, "conditions", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.RoleAssignment.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.RoleAssignment.prototype, "updatedAt", void 0);
+    exports.RoleAssignment = tslib.__decorate([ core.table("role_assignments"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.RoleAssignment);
+    exports.ResourceGrant = class ResourceGrant extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.ResourceGrant.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.ResourceGrant.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.ProtectedResource, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_resource"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.ResourceGrant.prototype, "resource", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_principal"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.ResourceGrant.prototype, "principal", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.ResourceGrant.prototype, "permissionKey", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.ResourceGrant.prototype, "startsAt", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.ResourceGrant.prototype, "expiresAt", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.ResourceGrant.prototype, "conditions", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_RESTRICT, false, undefined, "fk_resource_grants_created_by"), tslib.__metadata("design:type", Object) ], exports.ResourceGrant.prototype, "createdBy", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.ResourceGrant.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.ResourceGrant.prototype, "updatedAt", void 0);
+    exports.ResourceGrant = tslib.__decorate([ core.table("resource_grants"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.ResourceGrant);
+    exports.Principal = class Principal extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.Principal.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_RESTRICT, false, undefined, "fk_principals_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.Principal.prototype, "tenant", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(PrincipalKindOptions), core.column(), tslib.__metadata("design:type", String) ], exports.Principal.prototype, "kind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Principal.prototype, "subjectId", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.RoleAssignment, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Principal.prototype, "roleAssignments", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.ResourceGrant, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Principal.prototype, "resourceGrants", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.Principal.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.Principal.prototype, "updatedAt", void 0);
+    exports.Principal = tslib.__decorate([ core.table("principals"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.Principal);
+    exports.ProtectedResource = class ProtectedResource extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.ProtectedResource.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_RESTRICT, false, undefined, "fk_protected_resources_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.ProtectedResource.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_RESTRICT, false, undefined, "fk_protected_resources_org_unit"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.ProtectedResource.prototype, "orgUnit", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.ProtectedResource.prototype, "resourceType", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.ProtectedResource.prototype, "resourceId", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(ResourceVisibilityOptions), core.column(), tslib.__metadata("design:type", String) ], exports.ProtectedResource.prototype, "visibility", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_NULLIFY, false, undefined, "fk_protected_resources_owner"), tslib.__metadata("design:type", Object) ], exports.ProtectedResource.prototype, "owner", void 0);
+    tslib.__decorate([ decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.ProtectedResource.prototype, "sensitivity", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.ProtectedResource.prototype, "metadata", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.ResourceGrant, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.ProtectedResource.prototype, "grants", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.ProtectedResource.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.ProtectedResource.prototype, "updatedAt", void 0);
+    exports.ProtectedResource = tslib.__decorate([ core.table("protected_resources"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.ProtectedResource);
+    exports.InheritanceBlock = class InheritanceBlock extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.InheritanceBlock.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_inheritance_blocks_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.InheritanceBlock.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_inheritance_blocks_org_unit"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.InheritanceBlock.prototype, "orgUnit", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_NULLIFY, false, undefined, "fk_inheritance_blocks_blocked_ancestor"), tslib.__metadata("design:type", Object) ], exports.InheritanceBlock.prototype, "blockedFromAncestor", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(PermissionCategoryOptions), core.column(), tslib.__metadata("design:type", String) ], exports.InheritanceBlock.prototype, "permissionCategory", void 0);
+    tslib.__decorate([ decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.InheritanceBlock.prototype, "reason", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.InheritanceBlock.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.InheritanceBlock.prototype, "updatedAt", void 0);
+    exports.InheritanceBlock = tslib.__decorate([ core.table("inheritance_blocks"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.InheritanceBlock);
+    exports.OrgUnit = class OrgUnit extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.OrgUnit.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_RESTRICT, false, undefined, "fk_org_units_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnit.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_RESTRICT, false, undefined, "fk_org_units_parent"), tslib.__metadata("design:type", Object) ], exports.OrgUnit.prototype, "parent", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnit, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "children", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.OrgUnit.prototype, "name", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.OrgUnit.prototype, "path", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.OrgUnit.prototype, "metadata", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnitMembership, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "memberships", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.ProtectedResource, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "resources", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.InheritanceBlock, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "inheritanceBlocks", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnitClosure, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "ancestorLinks", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnitClosure, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.OrgUnit.prototype, "descendantLinks", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnit.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnit.prototype, "updatedAt", void 0);
+    exports.OrgUnit = tslib.__decorate([ core.table("org_units"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.OrgUnit);
+    exports.StorageBinding = class StorageBinding extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.StorageBinding.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_storage_bindings_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.StorageBinding.prototype, "tenant", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(StorageKindOptions), core.column(), tslib.__metadata("design:type", String) ], exports.StorageBinding.prototype, "storageKind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(StorageBindingKindOptions), core.column(), tslib.__metadata("design:type", String) ], exports.StorageBinding.prototype, "bindingKind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.StorageBinding.prototype, "bindingKey", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.StorageBinding.prototype, "region", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.StorageBinding.prototype, "config", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.StorageBinding.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.StorageBinding.prototype, "updatedAt", void 0);
+    exports.StorageBinding = tslib.__decorate([ core.table("storage_bindings"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.StorageBinding);
+    exports.Tenant = class Tenant extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.Tenant.prototype, "id", void 0);
+    tslib.__decorate([ core.unique(), decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Tenant.prototype, "slug", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Tenant.prototype, "name", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(IsolationTierOptions), core.column(), tslib.__metadata("design:type", String) ], exports.Tenant.prototype, "isolationTier", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.OrgUnit, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Tenant.prototype, "orgUnits", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.TenantMembership, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Tenant.prototype, "memberships", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.Principal, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Tenant.prototype, "principals", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.StorageBinding, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Tenant.prototype, "storageBindings", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.Tenant.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.Tenant.prototype, "updatedAt", void 0);
+    exports.Tenant = tslib.__decorate([ core.table("tenants"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.Tenant);
+    exports.TenantProfile = class TenantProfile extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.TenantProfile.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_profiles_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.TenantProfile.prototype, "tenant", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.TenantProfile.prototype, "profileKey", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.TenantProfile.prototype, "metadata", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.TenantProfile.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.TenantProfile.prototype, "updatedAt", void 0);
+    exports.TenantProfile = tslib.__decorate([ core.table("tenant_profiles"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.TenantProfile);
+    exports.OrgUnitProfile = class OrgUnitProfile extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.OrgUnitProfile.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_unit_profiles_org_unit"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.OrgUnitProfile.prototype, "orgUnit", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.OrgUnitProfile.prototype, "profileKey", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.OrgUnitProfile.prototype, "metadata", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnitProfile.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.OrgUnitProfile.prototype, "updatedAt", void 0);
+    exports.OrgUnitProfile = tslib.__decorate([ core.table("org_unit_profiles"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.OrgUnitProfile);
+    exports.GroupMembership = class GroupMembership extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.GroupMembership.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.GroupMembership.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Group, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_group"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.GroupMembership.prototype, "group", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_principal"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.GroupMembership.prototype, "principal", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.GroupMembership.prototype, "metadata", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.GroupMembership.prototype, "createdAt", void 0);
+    exports.GroupMembership = tslib.__decorate([ core.table("group_memberships"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.GroupMembership);
+    exports.Group = class Group extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.Group.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_RESTRICT, false, undefined, "fk_groups_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.Group.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.OrgUnit, REL_NULLIFY, false, undefined, "fk_groups_org_unit"), tslib.__metadata("design:type", Object) ], exports.Group.prototype, "orgUnit", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.Group.prototype, "name", void 0);
+    tslib.__decorate([ decoratorValidation.type(Object), core.column(), tslib.__metadata("design:type", Object) ], exports.Group.prototype, "metadata", void 0);
+    tslib.__decorate([ core.oneToMany(() => exports.GroupMembership, REL_RESTRICT, false), tslib.__metadata("design:type", Array) ], exports.Group.prototype, "members", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.Group.prototype, "createdAt", void 0);
+    tslib.__decorate([ core.updatedAt(), tslib.__metadata("design:type", Date) ], exports.Group.prototype, "updatedAt", void 0);
+    exports.Group = tslib.__decorate([ core.table("groups"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.Group);
+    exports.EffectivePermission = class EffectivePermission extends AuthorizationModel {
+        constructor(data) {
+            super(data);
+        }
+    };
+    tslib.__decorate([ core.pk({
+        type: String
+    }), core.uuid(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "id", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_effective_permissions_tenant"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.EffectivePermission.prototype, "tenant", void 0);
+    tslib.__decorate([ core.manyToOne(() => exports.Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_effective_permissions_principal"), decoratorValidation.required(), tslib.__metadata("design:type", Object) ], exports.EffectivePermission.prototype, "principal", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "permissionKey", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), decoratorValidation.option(ScopeKindOptions), core.column(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "scopeKind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "scopeId", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "sourceKind", void 0);
+    tslib.__decorate([ decoratorValidation.required(), decoratorValidation.type(String), core.column(), tslib.__metadata("design:type", String) ], exports.EffectivePermission.prototype, "sourceId", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.EffectivePermission.prototype, "startsAt", void 0);
+    tslib.__decorate([ core.column(), tslib.__metadata("design:type", Date) ], exports.EffectivePermission.prototype, "expiresAt", void 0);
+    tslib.__decorate([ core.createdAt(), tslib.__metadata("design:type", Date) ], exports.EffectivePermission.prototype, "createdAt", void 0);
+    exports.EffectivePermission = tslib.__decorate([ core.table("effective_permissions"), decoratorValidation.model(), tslib.__metadata("design:paramtypes", [ Object ]) ], exports.EffectivePermission);
+    class TenantProfileService extends BaseModelService {
+        constructor() {
+            super(exports.TenantProfile);
+        }
+        async createProfile(tenantId, profileKey, metadata, ...args) {
+            return this.create({
+                tenant: tenantId,
+                profileKey: profileKey,
+                metadata: metadata
+            }, ...args);
+        }
+        async listForTenant(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(profile => sameTenant(profile.tenant, tenantId));
+        }
+        async deleteForTenant(tenantId, ...args) {
+            for (const row of await this.listForTenant(tenantId, ...args)) {
+                await this.deleteById(row.id, ...args);
+            }
+        }
+    }
+    class OrgUnitProfileService extends BaseModelService {
+        constructor() {
+            super(exports.OrgUnitProfile);
+        }
+        async createProfile(orgUnitId, profileKey, metadata, ...args) {
+            return this.create({
+                orgUnit: orgUnitId,
+                profileKey: profileKey,
+                metadata: metadata
+            }, ...args);
+        }
+        async listForOrgUnit(orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(profile => relationMatch(profile.orgUnit, orgUnitId));
+        }
+    }
+    class OrgUnitClosureService extends BaseModelService {
+        constructor() {
+            super(exports.OrgUnitClosure);
+        }
+        async listAncestors(tenantId, orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(row => sameTenant(row.tenant, tenantId) && relationMatch(row.descendant, orgUnitId)).sort((left, right) => left.depth - right.depth);
+        }
+        async listDescendants(tenantId, orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(row => sameTenant(row.tenant, tenantId) && relationMatch(row.ancestor, orgUnitId)).sort((left, right) => left.depth - right.depth);
+        }
+        async isAncestorOf(tenantId, ancestorOrgUnitId, descendantOrgUnitId, ...args) {
+            return (await this.listAncestors(tenantId, descendantOrgUnitId, ...args)).some(row => relationMatch(row.ancestor, ancestorOrgUnitId));
+        }
+        async createSelfLink(tenantId, orgUnitId, ...args) {
+            return this.create({
+                tenant: tenantId,
+                ancestor: orgUnitId,
+                descendant: orgUnitId,
+                depth: 0
+            }, ...args);
+        }
+        async insertAncestorLinksForNewChild(tenantId, parentOrgUnitId, childOrgUnitId, ...args) {
+            const ancestorLinks = await this.listAncestors(tenantId, parentOrgUnitId, ...args);
+            for (const link of ancestorLinks) {
+                await this.create({
+                    tenant: tenantId,
+                    ancestor: link.ancestor,
+                    descendant: childOrgUnitId,
+                    depth: link.depth + 1
+                }, ...args);
+            }
+        }
+        async deleteLinksForSubtree(tenantId, orgUnitId, ...args) {
+            const subtree = await this.listDescendants(tenantId, orgUnitId, ...args);
+            const descendantIds = new Set([ orgUnitId, ...subtree.map(row => relationId(row.descendant)) ]);
+            const ancestorIds = new Set([ orgUnitId, ...subtree.map(row => relationId(row.ancestor)) ]);
+            const rows = (await this.listAll(...args)).filter(row => sameTenant(row.tenant, tenantId) && (descendantIds.has(relationId(row.descendant)) || ancestorIds.has(relationId(row.ancestor))));
+            for (const row of rows) {
+                await this.deleteById(row.id, ...args);
+            }
+        }
+    }
+    class InheritanceBlockService extends BaseModelService {
+        constructor() {
+            super(exports.InheritanceBlock);
+        }
+        async blockCategory(tenantId, orgUnitId, permissionCategory, blockedFromAncestorId, reason, ...args) {
+            return this.create({
+                tenant: tenantId,
+                orgUnit: orgUnitId,
+                blockedFromAncestor: blockedFromAncestorId,
+                permissionCategory: permissionCategory,
+                reason: reason
+            }, ...args);
+        }
+        async unblockCategory(blockId, ...args) {
+            await this.deleteById(blockId, ...args);
+        }
+        async listForOrgUnit(tenantId, orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(block => sameTenant(block.tenant, tenantId) && relationMatch(block.orgUnit, orgUnitId));
+        }
+        async categoryBlockedForAncestor(tenantId, orgUnitId, ancestorOrgUnitId, category, ...args) {
+            return (await this.listForOrgUnit(tenantId, orgUnitId, ...args)).some(block => block.permissionCategory === category && (!block.blockedFromAncestor || relationMatch(block.blockedFromAncestor, ancestorOrgUnitId)));
+        }
+    }
+    class TenantService extends BaseModelService {
+        constructor() {
+            super(exports.Tenant);
+        }
+        async createTenant(input, ...args) {
+            return this.create({
+                slug: input.slug,
+                name: input.name,
+                isolationTier: input.isolationTier ?? exports.IsolationTier.Pooled
+            }, ...args);
+        }
+        async getBySlug(slug, ...args) {
+            return this.findOneBy("slug", slug, ...args);
+        }
+        async renameTenant(tenantId, name, ...args) {
+            return this.updateOne(tenantId, {
+                name: name
+            }, ...args);
+        }
+        async changeSlug(tenantId, slug, ...args) {
+            return this.updateOne(tenantId, {
+                slug: slug
+            }, ...args);
+        }
+        async setIsolationTier(tenantId, isolationTier, ...args) {
+            return this.updateOne(tenantId, {
+                isolationTier: isolationTier
+            }, ...args);
+        }
+        async deleteTenantControlled(tenantId, ...args) {
+            await this.deleteById(tenantId, ...args);
+        }
+    }
+    async function deleteRowsById$1(service, rows, ...args) {
+        for (const row of rows) {
+            await service.deleteById(row.id, ...args);
+        }
+    }
+    class OrgUnitService extends BaseModelService {
+        constructor() {
+            super(exports.OrgUnit);
+        }
+        orgUnitPath(parentPath, name) {
+            const segment = lowerSlug(name);
+            return parentPath ? `${parentPath.replace(/\/+$/, "")}/${segment}` : `/${segment}`;
+        }
+        async createProfileIfNeeded(orgUnitId, profileKey, profileMetadata, ...args) {
+            if (!profileKey) return;
+            await (new OrgUnitProfileService).createProfile(orgUnitId, profileKey, profileMetadata, ...args);
+        }
+        async createRoot(tenantId, name, metadata, profileKey, profileMetadata, ...args) {
+            const orgUnit = await this.create({
+                tenant: tenantId,
+                name: name,
+                path: this.orgUnitPath(undefined, name),
+                metadata: metadata
+            }, ...args);
+            await this.createProfileIfNeeded(orgUnit.id, profileKey, profileMetadata, ...args);
+            await (new OrgUnitClosureService).createSelfLink(tenantId, orgUnit.id, ...args);
+            return orgUnit;
+        }
+        async createChild(input, ...args) {
+            const parent = input.parentOrgUnitId ? await this.getById(input.parentOrgUnitId, ...args) : undefined;
+            const orgUnit = await this.create({
+                tenant: input.tenantId,
+                parent: parent?.id ?? input.parentOrgUnitId,
+                name: input.name,
+                path: this.orgUnitPath(parent?.path, input.name),
+                metadata: input.metadata
+            }, ...args);
+            await this.createProfileIfNeeded(orgUnit.id, input.profileKey, input.profileMetadata, ...args);
+            const closureService = new OrgUnitClosureService;
+            await closureService.createSelfLink(input.tenantId, orgUnit.id, ...args);
+            if (input.parentOrgUnitId) {
+                await closureService.insertAncestorLinksForNewChild(input.tenantId, input.parentOrgUnitId, orgUnit.id, ...args);
+            }
+            return orgUnit;
+        }
+        async listChildren(parentOrgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(orgUnit => relationMatch(orgUnit.parent, parentOrgUnitId));
+        }
+        async listTenantOrgUnits(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(orgUnit => sameTenant(orgUnit.tenant, tenantId));
+        }
+        async listDescendantOrgUnits(tenantId, orgUnitId, includeSelf = false, ...args) {
+            const descendants = await (new OrgUnitClosureService).listDescendants(tenantId, orgUnitId, ...args);
+            const ids = new Set(descendants.map(row => relationId(row.descendant)));
+            if (includeSelf) ids.add(orgUnitId);
+            return (await this.listTenantOrgUnits(tenantId, ...args)).filter(orgUnit => ids.has(orgUnit.id));
+        }
+        async listAncestorOrgUnits(tenantId, orgUnitId, includeSelf = false, ...args) {
+            const ancestors = await (new OrgUnitClosureService).listAncestors(tenantId, orgUnitId, ...args);
+            const ids = new Set(ancestors.map(row => relationId(row.ancestor)));
+            if (includeSelf) ids.add(orgUnitId);
+            return (await this.listTenantOrgUnits(tenantId, ...args)).filter(orgUnit => ids.has(orgUnit.id));
+        }
+        async renameOrgUnit(orgUnitId, name, ...args) {
+            const existing = await this.getById(orgUnitId, ...args);
+            return this.updateOne(orgUnitId, {
+                name: name,
+                path: this.orgUnitPath(existing.path.includes("/") ? existing.path.replace(/\/[^/]+$/, "") : undefined, name)
+            }, ...args);
+        }
+        async moveOrgUnit(tenantId, orgUnitId, newParentOrgUnitId, ...args) {
+            const newParent = await this.getById(newParentOrgUnitId, ...args);
+            const existing = await this.getById(orgUnitId, ...args);
+            const updated = await this.updateOne(orgUnitId, {
+                parent: newParent.id,
+                path: this.orgUnitPath(newParent.path, existing.name)
+            }, ...args);
+            await this.rebuildTenantClosure(tenantId, ...args);
+            return updated;
+        }
+        async rebuildTenantClosure(tenantId, ...args) {
+            const closureService = new OrgUnitClosureService;
+            const existingLinks = await closureService.listAll(...args);
+            await deleteRowsById$1(closureService, existingLinks.filter(row => sameTenant(row.tenant, tenantId)), ...args);
+            const orgUnits = (await this.listTenantOrgUnits(tenantId, ...args)).sort((left, right) => {
+                const leftDepth = left.path.split("/").filter(Boolean).length;
+                const rightDepth = right.path.split("/").filter(Boolean).length;
+                return leftDepth - rightDepth;
+            });
+            for (const orgUnit of orgUnits) {
+                await closureService.createSelfLink(tenantId, orgUnit.id, ...args);
+                if (orgUnit.parent) {
+                    await closureService.insertAncestorLinksForNewChild(tenantId, relationId(orgUnit.parent), orgUnit.id, ...args);
+                }
+            }
+        }
+        async deleteOrgUnitTree(tenantId, orgUnitId, ...args) {
+            const closureService = new OrgUnitClosureService;
+            const descendants = await this.listDescendantOrgUnits(tenantId, orgUnitId, true, ...args);
+            const descendantIds = new Set(descendants.map(orgUnit => orgUnit.id));
+            const orgUnits = (await this.listTenantOrgUnits(tenantId, ...args)).filter(orgUnit => descendantIds.has(orgUnit.id));
+            await deleteRowsById$1(this, orgUnits, ...args);
+            await closureService.deleteLinksForSubtree(tenantId, orgUnitId, ...args);
+        }
+    }
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, Object, String, Object, Object ]), tslib.__metadata("design:returntype", Promise) ], OrgUnitService.prototype, "createRoot", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ Object, Object ]), tslib.__metadata("design:returntype", Promise) ], OrgUnitService.prototype, "createChild", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], OrgUnitService.prototype, "moveOrgUnit", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, Object ]), tslib.__metadata("design:returntype", Promise) ], OrgUnitService.prototype, "rebuildTenantClosure", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], OrgUnitService.prototype, "deleteOrgUnitTree", null);
+    class UserService extends BaseModelService {
+        constructor() {
+            super(exports.User);
+        }
+        async createUser(input, ...args) {
+            return this.create({
+                email: input.email,
+                phone: input.phone,
+                displayName: input.displayName
+            }, ...args);
+        }
+        async getByEmail(email, ...args) {
+            return (await this.listAll(...args)).find(user => user.email === email);
+        }
+        async updateDisplayName(userId, displayName, ...args) {
+            return this.updateOne(userId, {
+                displayName: displayName
+            }, ...args);
+        }
+        async updateEmail(userId, email, ...args) {
+            return this.updateOne(userId, {
+                email: email
+            }, ...args);
+        }
+        async updatePhone(userId, phone, ...args) {
+            return this.updateOne(userId, {
+                phone: phone
+            }, ...args);
+        }
+    }
+    class PrincipalService extends BaseModelService {
+        constructor() {
+            super(exports.Principal);
+        }
+        async createPrincipal(tenantId, kind, subjectId, ...args) {
+            return this.create({
+                tenant: tenantId,
+                kind: kind,
+                subjectId: subjectId
+            }, ...args);
+        }
+        async getForSubject(tenantId, kind, subjectId, ...args) {
+            return (await this.listAll(...args)).find(principal => sameTenant(principal.tenant, tenantId) && principal.kind === kind && principal.subjectId === subjectId);
+        }
+        async getOrCreateForSubject(tenantId, kind, subjectId, ...args) {
+            return await this.getForSubject(tenantId, kind, subjectId, ...args) ?? await this.createPrincipal(tenantId, kind, subjectId, ...args);
+        }
+        async getUserPrincipal(tenantId, userId, ...args) {
+            return this.getOrCreateForSubject(tenantId, exports.PrincipalKind.User, userId, ...args);
+        }
+        async getGroupPrincipal(tenantId, groupId, ...args) {
+            return this.getOrCreateForSubject(tenantId, exports.PrincipalKind.Group, groupId, ...args);
+        }
+    }
+    class TenantMembershipService extends BaseModelService {
+        constructor() {
+            super(exports.TenantMembership);
+        }
+        async addUserToTenant(tenantId, userId, status = exports.MembershipStatus.Active, ...args) {
+            return this.create({
+                tenant: tenantId,
+                user: userId,
+                status: status
+            }, ...args);
+        }
+        async setStatus(membershipId, status, ...args) {
+            return this.updateOne(membershipId, {
+                status: status
+            }, ...args);
+        }
+        async listUserTenants(userId, ...args) {
+            return (await this.listAll(...args)).filter(membership => relationMatch(membership.user, userId));
+        }
+        async listTenantUsers(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(membership => sameTenant(membership.tenant, tenantId));
+        }
+        async removeUserFromTenant(membershipId, ...args) {
+            await this.deleteById(membershipId, ...args);
+        }
+    }
+    class OrgUnitMembershipService extends BaseModelService {
+        constructor() {
+            super(exports.OrgUnitMembership);
+        }
+        async addUserToOrgUnit(tenantId, orgUnitId, userId, status = exports.MembershipStatus.Active, ...args) {
+            return this.create({
+                tenant: tenantId,
+                orgUnit: orgUnitId,
+                user: userId,
+                status: status
+            }, ...args);
+        }
+        async setStatus(membershipId, status, ...args) {
+            return this.updateOne(membershipId, {
+                status: status
+            }, ...args);
+        }
+        async listUserOrgUnits(userId, ...args) {
+            return (await this.listAll(...args)).filter(membership => relationMatch(membership.user, userId));
+        }
+        async listOrgUnitUsers(orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(membership => relationMatch(membership.orgUnit, orgUnitId));
+        }
+        async removeUserFromOrgUnit(membershipId, ...args) {
+            await this.deleteById(membershipId, ...args);
+        }
+    }
+    class GroupService extends BaseModelService {
+        constructor() {
+            super(exports.Group);
+        }
+        async createGroup(tenantId, name, orgUnitId, metadata, ...args) {
+            return this.create({
+                tenant: tenantId,
+                orgUnit: orgUnitId,
+                name: name,
+                metadata: metadata
+            }, ...args);
+        }
+        async renameGroup(groupId, name, ...args) {
+            return this.updateOne(groupId, {
+                name: name
+            }, ...args);
+        }
+        async moveGroupToOrgUnit(groupId, orgUnitId, ...args) {
+            return this.updateOne(groupId, {
+                orgUnit: orgUnitId
+            }, ...args);
+        }
+        async listTenantGroups(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(group => sameTenant(group.tenant, tenantId));
+        }
+    }
+    class GroupMembershipService extends BaseModelService {
+        constructor() {
+            super(exports.GroupMembership);
+        }
+        async addPrincipalToGroup(tenantId, groupId, principalId, metadata, ...args) {
+            return this.create({
+                tenant: tenantId,
+                group: groupId,
+                principal: principalId,
+                metadata: metadata
+            }, ...args);
+        }
+        async listGroupMembers(groupId, ...args) {
+            return (await this.listAll(...args)).filter(membership => relationMatch(membership.group, groupId));
+        }
+        async listPrincipalGroups(principalId, ...args) {
+            return (await this.listAll(...args)).filter(membership => relationMatch(membership.principal, principalId));
+        }
+        async removePrincipalFromGroup(membershipId, ...args) {
+            await this.deleteById(membershipId, ...args);
+        }
+        async resolveGroupPrincipalIdsForPrincipal(principalId, ...args) {
+            const principalService = new PrincipalService;
+            const memberships = await this.listPrincipalGroups(principalId, ...args);
+            const principals = await Promise.all(memberships.map(async membership => {
+                const tenantId = relationId(membership.tenant);
+                const groupId = relationId(membership.group);
+                const principal = await principalService.getGroupPrincipal(tenantId, groupId, ...args);
+                return principal.id;
+            }));
+            return principals;
+        }
+    }
+    class PermissionService extends BaseModelService {
+        constructor() {
+            super(exports.Permission);
+        }
+        async createPermission(input, ...args) {
+            return this.create({
+                key: input.key,
+                category: input.category,
+                description: input.description
+            }, ...args);
+        }
+        async getByKey(key, ...args) {
+            return (await this.listAll(...args)).find(permission => permission.key === key);
+        }
+        async listByCategory(category, ...args) {
+            return (await this.listAll(...args)).filter(permission => permission.category === category);
+        }
+        async updateDescription(permissionId, description, ...args) {
+            return this.updateOne(permissionId, {
+                description: description
+            }, ...args);
+        }
+    }
+    class RoleService extends BaseModelService {
+        constructor() {
+            super(exports.Role);
+        }
+        async createRole(input, ...args) {
+            return this.create({
+                tenant: input.tenantId,
+                key: input.key,
+                name: input.name,
+                description: input.description,
+                metadata: input.metadata
+            }, ...args);
+        }
+        async getSystemRoleByKey(key, ...args) {
+            const role = (await this.listAll(...args)).find(candidate => !candidate.tenant && candidate.key === key);
+            if (!role) {
+                throw new Error(`Role "${key}" not found`);
+            }
+            return role;
+        }
+        async getTenantRoleByKey(tenantId, key, ...args) {
+            const role = (await this.listAll(...args)).find(candidate => sameTenant(candidate.tenant, tenantId) && candidate.key === key);
+            if (!role) {
+                throw new Error(`Role "${key}" not found for tenant ${tenantId}`);
+            }
+            return role;
+        }
+        async renameRole(roleId, name, ...args) {
+            return this.updateOne(roleId, {
+                name: name
+            }, ...args);
+        }
+        async updateRoleMetadata(roleId, metadata, ...args) {
+            return this.updateOne(roleId, {
+                metadata: metadata
+            }, ...args);
+        }
+        async listTenantRoles(tenantId, includeSystem = false, ...args) {
+            return (await this.listAll(...args)).filter(role => includeSystem ? !role.tenant || sameTenant(role.tenant, tenantId) : sameTenant(role.tenant, tenantId));
+        }
+    }
+    async function deleteRowsById(service, rows, ...args) {
+        for (const row of rows) {
+            await service.deleteById(row.id, ...args);
+        }
+    }
+    class RolePermissionService extends BaseModelService {
+        constructor() {
+            super(exports.RolePermission);
+        }
+        async addPermissionToRole(roleId, permissionId, ...args) {
+            return this.create({
+                role: roleId,
+                permission: permissionId
+            }, ...args);
+        }
+        async addPermissionKeyToRole(roleId, permissionKey, ...args) {
+            const permission = await (new PermissionService).getByKey(permissionKey, ...args);
+            return this.addPermissionToRole(roleId, permission.id, ...args);
+        }
+        async removePermissionFromRole(rolePermissionId, ...args) {
+            await this.deleteById(rolePermissionId, ...args);
+        }
+        async listRolePermissions(roleId, ...args) {
+            return (await this.listAll(...args)).filter(rolePermission => relationMatch(rolePermission.role, roleId));
+        }
+        async listPermissionRoles(permissionId, ...args) {
+            return (await this.listAll(...args)).filter(rolePermission => relationMatch(rolePermission.permission, permissionId));
+        }
+        async replaceRolePermissions(roleId, permissionIds, ...args) {
+            const existing = await this.listRolePermissions(roleId, ...args);
+            await deleteRowsById(this, existing, ...args);
+            return Promise.all(permissionIds.map(permissionId => this.addPermissionToRole(roleId, permissionId, ...args)));
+        }
+        async createRoleWithPermissions(input, permissionKeys, ...args) {
+            const role = await (new RoleService).createRole(input, ...args);
+            for (const permissionKey of permissionKeys) {
+                await this.addPermissionKeyToRole(role.id, permissionKey, ...args);
+            }
+            return role;
+        }
+    }
+    class RoleAssignmentService extends BaseModelService {
+        constructor() {
+            super(exports.RoleAssignment);
+        }
+        async assignRole(input, ...args) {
+            return this.create({
+                tenant: input.tenantId,
+                principal: input.principalId,
+                role: input.roleId,
+                scopeKind: input.scopeKind,
+                scopeId: input.scopeId,
+                inheritDown: input.inheritDown ?? false,
+                startsAt: input.startsAt,
+                expiresAt: input.expiresAt,
+                conditions: input.conditions
+            }, ...args);
+        }
+        async revokeAssignment(assignmentId, ...args) {
+            await this.deleteById(assignmentId, ...args);
+        }
+        async listPrincipalAssignments(tenantId, principalId, ...args) {
+            return (await this.listAll(...args)).filter(assignment => sameTenant(assignment.tenant, tenantId) && relationMatch(assignment.principal, principalId));
+        }
+        async listRoleAssignments(roleId, ...args) {
+            return (await this.listAll(...args)).filter(assignment => relationMatch(assignment.role, roleId));
+        }
+        async listTenantAssignments(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(assignment => sameTenant(assignment.tenant, tenantId));
+        }
+        async updateAssignmentWindow(assignmentId, startsAt, expiresAt, ...args) {
+            return this.updateOne(assignmentId, {
+                startsAt: startsAt,
+                expiresAt: expiresAt
+            }, ...args);
+        }
+    }
+    class EffectivePermissionService extends BaseModelService {
+        constructor() {
+            super(exports.EffectivePermission);
+        }
+        async listForPrincipal(tenantId, principalId, ...args) {
+            return (await this.listAll(...args)).filter(permission => sameTenant(permission.tenant, tenantId) && relationMatch(permission.principal, principalId));
+        }
+        async listForScope(tenantId, scopeKind, scopeId, ...args) {
+            return (await this.listAll(...args)).filter(permission => sameTenant(permission.tenant, tenantId) && permission.scopeKind === scopeKind && permission.scopeId === scopeId);
+        }
+        async hasPermission(tenantId, principalId, permissionKey, scopeKind, scopeId, at, ...args) {
+            return (await this.listForPrincipal(tenantId, principalId, ...args)).some(permission => permission.permissionKey === permissionKey && permission.scopeKind === scopeKind && permission.scopeId === scopeId && (!permission.startsAt || !at || permission.startsAt <= at) && (!permission.expiresAt || !at || permission.expiresAt >= at));
+        }
+        async deleteForPrincipal(tenantId, principalId, ...args) {
+            for (const row of await this.listForPrincipal(tenantId, principalId, ...args)) {
+                await this.deleteById(row.id, ...args);
+            }
+        }
+        async deleteForTenant(tenantId, ...args) {
+            for (const row of (await this.listAll(...args)).filter(permission => sameTenant(permission.tenant, tenantId))) {
+                await this.deleteById(row.id, ...args);
+            }
+        }
+        async rebuildForPrincipal(tenantId, principalId, ...args) {
+            await this.deleteForPrincipal(tenantId, principalId, ...args);
+            const roleAssignmentService = new RoleAssignmentService;
+            const rolePermissionService = new RolePermissionService;
+            const permissionService = new PermissionService;
+            const groupMembershipService = new GroupMembershipService;
+            const principalService = new PrincipalService;
+            const orgUnitClosureService = new OrgUnitClosureService;
+            const inheritanceBlockService = new InheritanceBlockService;
+            const materialized = [];
+            const sourceAssignments = await roleAssignmentService.listPrincipalAssignments(tenantId, principalId, ...args);
+            const groupMemberships = await groupMembershipService.listPrincipalGroups(principalId, ...args);
+            const groupAssignments = (await Promise.all(groupMemberships.map(async membership => {
+                const groupPrincipal = await principalService.getGroupPrincipal(relationId(membership.tenant), relationId(membership.group), ...args);
+                return roleAssignmentService.listPrincipalAssignments(tenantId, groupPrincipal.id, ...args);
+            }))).flat();
+            const assignments = [ ...sourceAssignments, ...groupAssignments ];
+            for (const assignment of assignments) {
+                const rolePermissions = await rolePermissionService.listRolePermissions(relationId(assignment.role), ...args);
+                const permissions = await Promise.all(rolePermissions.map(async rolePermission => permissionService.findOneBy("id", relationId(rolePermission.permission), ...args)));
+                for (const permission of permissions) {
+                    if (!permission) continue;
+                    const scopeKind = assignment.scopeKind;
+                    const scopeId = assignment.scopeId;
+                    const scopes = [];
+                    if (scopeKind === exports.ScopeKind.Tenant) {
+                        scopes.push({
+                            scopeKind: scopeKind,
+                            scopeId: tenantId
+                        });
+                    } else if (scopeKind === exports.ScopeKind.Resource) {
+                        scopes.push({
+                            scopeKind: scopeKind,
+                            scopeId: scopeId
+                        });
+                    } else if (scopeKind === exports.ScopeKind.OrgUnit && !assignment.inheritDown) {
+                        scopes.push({
+                            scopeKind: scopeKind,
+                            scopeId: scopeId
+                        });
+                    } else if (scopeKind === exports.ScopeKind.OrgUnit && assignment.inheritDown) {
+                        const descendants = await orgUnitClosureService.listDescendants(tenantId, scopeId, ...args);
+                        scopes.push(...descendants.map(row => ({
+                            scopeKind: scopeKind,
+                            scopeId: relationId(row.descendant)
+                        })));
+                    }
+                    for (const scoped of scopes) {
+                        if (scopeKind === exports.ScopeKind.OrgUnit && assignment.inheritDown && scoped.scopeId !== scopeId && await inheritanceBlockService.categoryBlockedForAncestor(tenantId, scoped.scopeId, scopeId, permission.category, ...args)) {
+                            continue;
+                        }
+                        materialized.push({
+                            id: "",
+                            tenantId: tenantId,
+                            principalId: principalId,
+                            permissionKey: permission.key,
+                            scopeKind: scoped.scopeKind,
+                            scopeId: scoped.scopeId,
+                            sourceKind: "role_assignment",
+                            sourceId: assignment.id,
+                            startsAt: assignment.startsAt,
+                            expiresAt: assignment.expiresAt
+                        });
+                    }
+                }
+            }
+            const created = await Promise.all(materialized.map(permission => this.create({
+                tenant: permission.tenantId,
+                principal: permission.principalId,
+                permissionKey: permission.permissionKey,
+                scopeKind: permission.scopeKind,
+                scopeId: permission.scopeId,
+                sourceKind: permission.sourceKind,
+                sourceId: permission.sourceId,
+                startsAt: permission.startsAt,
+                expiresAt: permission.expiresAt
+            }, ...args)));
+            return created;
+        }
+        async rebuildForTenant(tenantId, ...args) {
+            const principals = (await (new PrincipalService).listAll(...args)).filter(principal => sameTenant(principal.tenant, tenantId));
+            for (const principal of principals) {
+                await this.rebuildForPrincipal(tenantId, principal.id, ...args);
+            }
+        }
+    }
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], EffectivePermissionService.prototype, "rebuildForPrincipal", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, Object ]), tslib.__metadata("design:returntype", Promise) ], EffectivePermissionService.prototype, "rebuildForTenant", null);
+    class ProtectedResourceService extends BaseModelService {
+        constructor() {
+            super(exports.ProtectedResource);
+        }
+        async registerResource(input, ...args) {
+            return this.create({
+                tenant: input.tenantId,
+                orgUnit: input.orgUnitId,
+                resourceType: input.resourceType,
+                resourceId: input.resourceId,
+                visibility: input.visibility,
+                owner: input.ownerPrincipalId,
+                sensitivity: input.sensitivity,
+                metadata: input.metadata
+            }, ...args);
+        }
+        async getByDomainResource(tenantId, resourceType, resourceId, ...args) {
+            return (await this.listAll(...args)).find(resource => sameTenant(resource.tenant, tenantId) && resource.resourceType === resourceType && resource.resourceId === resourceId);
+        }
+        async moveResourceToOrgUnit(protectedResourceId, orgUnitId, ...args) {
+            return this.updateOne(protectedResourceId, {
+                orgUnit: orgUnitId
+            }, ...args);
+        }
+        async setVisibility(protectedResourceId, visibility, ...args) {
+            return this.updateOne(protectedResourceId, {
+                visibility: visibility
+            }, ...args);
+        }
+        async transferOwnership(protectedResourceId, ownerPrincipalId, ...args) {
+            return this.updateOne(protectedResourceId, {
+                owner: ownerPrincipalId
+            }, ...args);
+        }
+        async listOrgUnitResources(orgUnitId, ...args) {
+            return (await this.listAll(...args)).filter(resource => relationMatch(resource.orgUnit, orgUnitId));
+        }
+        async listTenantResources(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(resource => sameTenant(resource.tenant, tenantId));
+        }
+    }
+    class ResourceGrantService extends BaseModelService {
+        constructor() {
+            super(exports.ResourceGrant);
+        }
+        async grantResource(input, ...args) {
+            return this.create({
+                tenant: input.tenantId,
+                resource: input.resourceId,
+                principal: input.principalId,
+                permissionKey: input.permissionKey,
+                startsAt: input.startsAt,
+                expiresAt: input.expiresAt,
+                conditions: input.conditions,
+                createdBy: input.createdByPrincipalId
+            }, ...args);
+        }
+        async revokeGrant(grantId, ...args) {
+            await this.deleteById(grantId, ...args);
+        }
+        async listResourceGrants(protectedResourceId, ...args) {
+            return (await this.listAll(...args)).filter(grant => relationMatch(grant.resource, protectedResourceId));
+        }
+        async listPrincipalGrants(tenantId, principalId, ...args) {
+            return (await this.listAll(...args)).filter(grant => sameTenant(grant.tenant, tenantId) && relationMatch(grant.principal, principalId));
+        }
+        async hasGrant(tenantId, principalId, protectedResourceId, permissionKey, at, ...args) {
+            return (await this.listPrincipalGrants(tenantId, principalId, ...args)).some(grant => relationMatch(grant.resource, protectedResourceId) && grant.permissionKey === permissionKey && (!grant.startsAt || !at || grant.startsAt <= at) && (!grant.expiresAt || !at || grant.expiresAt >= at));
+        }
+        async deleteAllForResource(protectedResourceId, ...args) {
+            for (const row of await this.listResourceGrants(protectedResourceId, ...args)) {
+                await this.deleteById(row.id, ...args);
+            }
+        }
+    }
+    class ResourceLifecycleService {
+        async unregisterResource(protectedResourceId, ...args) {
+            await (new ResourceGrantService).deleteAllForResource(protectedResourceId, ...args);
+            await (new ProtectedResourceService).deleteById(protectedResourceId, ...args);
+        }
+        async resolveResourceScope(protectedResourceId, ...args) {
+            const resource = await (new ProtectedResourceService).getById(protectedResourceId, ...args);
+            return {
+                tenantId: relationId(resource.tenant),
+                orgUnitId: relationId(resource.orgUnit),
+                visibility: resource.visibility,
+                ownerPrincipalId: resource.owner ? relationId(resource.owner) : undefined
+            };
+        }
+    }
+    class StorageBindingService extends BaseModelService {
+        constructor() {
+            super(exports.StorageBinding);
+        }
+        async createBinding(input, ...args) {
+            return this.create({
+                tenant: input.tenantId,
+                storageKind: input.storageKind,
+                bindingKind: input.bindingKind,
+                bindingKey: input.bindingKey,
+                region: input.region,
+                config: input.config
+            }, ...args);
+        }
+        async listTenantBindings(tenantId, ...args) {
+            return (await this.listAll(...args)).filter(binding => relationId(binding.tenant) === tenantId);
+        }
+        async getBinding(tenantId, storageKind, ...args) {
+            return (await this.listTenantBindings(tenantId, ...args)).find(binding => binding.storageKind === storageKind);
+        }
+        async setBindingConfig(bindingId, config, ...args) {
+            return this.updateOne(bindingId, {
+                config: config
+            }, ...args);
+        }
+        async promoteToDedicated(bindingId, bindingKey, region, config, ...args) {
+            return this.updateOne(bindingId, {
+                bindingKind: exports.StorageBindingKind.Dedicated,
+                bindingKey: bindingKey,
+                region: region,
+                config: config
+            }, ...args);
+        }
+        async setShared(bindingId, bindingKey, region, config, ...args) {
+            return this.updateOne(bindingId, {
+                bindingKind: exports.StorageBindingKind.Shared,
+                bindingKey: bindingKey,
+                region: region,
+                config: config
+            }, ...args);
+        }
+    }
+    class BootstrapService {
+        constructor() {
+            this.tenantService = new TenantService;
+            this.tenantProfileService = new TenantProfileService;
+            this.orgUnitService = new OrgUnitService;
+            this.orgUnitProfileService = new OrgUnitProfileService;
+            this.userService = new UserService;
+            this.membershipService = new TenantMembershipService;
+            this.principalService = new PrincipalService;
+            this.permissionService = new PermissionService;
+            this.roleService = new RoleService;
+            this.rolePermissionService = new RolePermissionService;
+            this.roleAssignmentService = new RoleAssignmentService;
+            this.effectivePermissionService = new EffectivePermissionService;
+        }
+        async bootstrapTenantFromTemplate(template, ...args) {
+            const tenant = await this.tenantService.createTenant(template.tenant, ...args);
+            if (template.tenant.profileKey) {
+                await this.tenantProfileService.createProfile(tenant.id, template.tenant.profileKey, template.tenant.profileMetadata, ...args);
+            }
+            const createOrgTree = async (parentId, orgUnit) => {
+                const created = parentId === undefined ? await this.orgUnitService.createRoot(tenant.id, orgUnit.name, orgUnit.metadata, orgUnit.profileKey, orgUnit.metadata, ...args) : await this.orgUnitService.createChild({
+                    tenantId: tenant.id,
+                    parentOrgUnitId: parentId,
+                    name: orgUnit.name,
+                    metadata: orgUnit.metadata,
+                    profileKey: orgUnit.profileKey,
+                    profileMetadata: orgUnit.metadata
+                }, ...args);
+                for (const child of orgUnit.children ?? []) {
+                    await createOrgTree(created.id, child);
+                }
+                return created;
+            };
+            const rootOrgUnit = await createOrgTree(undefined, template.rootOrgUnit);
+            const owner = await this.userService.createUser(template.ownerUser, ...args);
+            await this.membershipService.addUserToTenant(tenant.id, owner.id, exports.MembershipStatus.Active, ...args);
+            const ownerPrincipal = await this.principalService.getUserPrincipal(tenant.id, owner.id, ...args);
+            for (const permission of template.permissions) {
+                await this.permissionService.createPermission(permission, ...args);
+            }
+            for (const role of template.roles) {
+                const createdRole = await this.roleService.createRole({
+                    tenantId: tenant.id,
+                    key: role.key,
+                    name: role.name,
+                    description: role.description
+                }, ...args);
+                for (const permissionKey of role.permissionKeys) {
+                    await this.rolePermissionService.addPermissionKeyToRole(createdRole.id, permissionKey, ...args);
+                }
+            }
+            const ownerRole = await this.roleService.getTenantRoleByKey(tenant.id, template.ownerRoleKey, ...args);
+            await this.roleAssignmentService.assignRole({
+                tenantId: tenant.id,
+                principalId: ownerPrincipal.id,
+                roleId: ownerRole.id,
+                scopeKind: exports.ScopeKind.OrgUnit,
+                scopeId: rootOrgUnit.id,
+                inheritDown: true
+            }, ...args);
+            await this.effectivePermissionService.rebuildForPrincipal(tenant.id, ownerPrincipal.id, ...args);
+            return {
+                tenantId: tenant.id,
+                rootOrgUnitId: rootOrgUnit.id,
+                ownerUserId: owner.id,
+                ownerPrincipalId: ownerPrincipal.id
+            };
+        }
+    }
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ Object, Object ]), tslib.__metadata("design:returntype", Promise) ], BootstrapService.prototype, "bootstrapTenantFromTemplate", null);
+    class SystemManagementService {
+        constructor() {
+            this.membershipService = new TenantMembershipService;
+            this.orgMembershipService = new OrgUnitMembershipService;
+            this.principalService = new PrincipalService;
+            this.roleService = new RoleService;
+            this.roleAssignmentService = new RoleAssignmentService;
+            this.effectivePermissionService = new EffectivePermissionService;
+        }
+        async onboardUserToTenantAndOrgUnit(tenantId, userId, orgUnitId, roleKey, ...args) {
+            await this.membershipService.addUserToTenant(tenantId, userId, exports.MembershipStatus.Active, ...args);
+            await this.orgMembershipService.addUserToOrgUnit(tenantId, orgUnitId, userId, exports.MembershipStatus.Active, ...args);
+            const principal = await this.principalService.getUserPrincipal(tenantId, userId, ...args);
+            const role = await this.roleService.getTenantRoleByKey(tenantId, roleKey, ...args);
+            await this.roleAssignmentService.assignRole({
+                tenantId: tenantId,
+                principalId: principal.id,
+                roleId: role.id,
+                scopeKind: exports.ScopeKind.OrgUnit,
+                scopeId: orgUnitId,
+                inheritDown: true
+            }, ...args);
+            await this.effectivePermissionService.rebuildForPrincipal(tenantId, principal.id, ...args);
+            return {
+                principalId: principal.id
+            };
+        }
+        async changeUserOrgRole(tenantId, principalId, orgUnitId, roleKey, inheritDown, ...args) {
+            const role = await this.roleService.getTenantRoleByKey(tenantId, roleKey, ...args);
+            const currentAssignments = await this.roleAssignmentService.listPrincipalAssignments(tenantId, principalId, ...args);
+            for (const assignment of currentAssignments.filter(row => row.scopeKind === exports.ScopeKind.OrgUnit && row.scopeId === orgUnitId)) {
+                await this.roleAssignmentService.revokeAssignment(assignment.id, ...args);
+            }
+            await this.roleAssignmentService.assignRole({
+                tenantId: tenantId,
+                principalId: principalId,
+                roleId: role.id,
+                scopeKind: exports.ScopeKind.OrgUnit,
+                scopeId: orgUnitId,
+                inheritDown: inheritDown
+            }, ...args);
+            await this.effectivePermissionService.rebuildForPrincipal(tenantId, principalId, ...args);
+        }
+        async suspendUserInTenant(tenantMembershipId, tenantId, principalId, ...args) {
+            await this.membershipService.setStatus(tenantMembershipId, exports.MembershipStatus.Suspended, ...args);
+            await this.effectivePermissionService.deleteForPrincipal(tenantId, principalId, ...args);
+        }
+        async reactivateUserInTenant(tenantMembershipId, tenantId, principalId, ...args) {
+            await this.membershipService.setStatus(tenantMembershipId, exports.MembershipStatus.Active, ...args);
+            await this.effectivePermissionService.rebuildForPrincipal(tenantId, principalId, ...args);
+        }
+    }
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], SystemManagementService.prototype, "onboardUserToTenantAndOrgUnit", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, String, String, Boolean, Object ]), tslib.__metadata("design:returntype", Promise) ], SystemManagementService.prototype, "changeUserOrgRole", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], SystemManagementService.prototype, "suspendUserInTenant", null);
+    tslib.__decorate([ core.transactional(), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [ String, String, String, Object ]), tslib.__metadata("design:returntype", Promise) ], SystemManagementService.prototype, "reactivateUserInTenant", null);
+    function scopeKey(scopeKind, scopeId) {
+        return `${scopeKind}:${scopeId}`;
+    }
+    class AuthzService {
+        constructor(dataSources = {}) {
+            this.dataSources = dataSources;
+        }
+        async canAccess(input, ...args) {
+            const at = input.at ?? new Date;
+            if (input.scopeKind && input.scopeId) {
+                const permissions = await (this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, input.scopeKind, input.scopeId));
+                return asArray(permissions).some(permission => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt));
+            }
+            if (!input.resourceProtectedId) return false;
+            const resource = await (this.dataSources.loadResource?.(input.tenantId, input.resourceProtectedId));
+            if (!resource) return false;
+            if (resource.tenantId !== input.tenantId) return false;
+            if (resource.ownerPrincipalId === input.principalId) return true;
+            const grants = asArray(await (this.dataSources.listResourceGrants?.(input.tenantId, input.resourceProtectedId))).filter(grant => grant.principalId === input.principalId && grant.permissionKey === input.permissionKey && isTimeValid(at, grant.startsAt, grant.expiresAt));
+            if (grants.length > 0) return true;
+            const visibility = resource.visibility;
+            if (visibility === exports.ResourceVisibility.Private || visibility === exports.ResourceVisibility.ResourceAcl) {
+                return false;
+            }
+            if (visibility === exports.ResourceVisibility.OrgUnit || visibility === exports.ResourceVisibility.OrgSubtree) {
+                const effectivePermissions = asArray(await (this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, exports.ScopeKind.OrgUnit, resource.orgUnitId)));
+                return effectivePermissions.some(permission => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt));
+            }
+            if (visibility === exports.ResourceVisibility.Tenant) {
+                const effectivePermissions = asArray(await (this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, exports.ScopeKind.Tenant, input.tenantId)));
+                return effectivePermissions.some(permission => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt));
+            }
+            return false;
+        }
+        async requireAccess(input, ...args) {
+            if (!await this.canAccess(input, ...args)) {
+                throw new core.AuthorizationError(`Access denied for ${input.permissionKey} on ${input.resourceProtectedId ?? scopeKey(input.scopeKind ?? exports.ScopeKind.Resource, input.scopeId ?? "")}`);
+            }
+        }
+        async buildAccessContext(tenantId, principalId, ...args) {
+            const permissions = asArray(await (this.dataSources.listEffectivePermissions?.(tenantId, principalId)));
+            const grants = asArray(await (this.dataSources.listPrincipalGrants?.(tenantId, principalId)));
+            return buildAccessContext({
+                tenantId: tenantId,
+                principalId: principalId,
+                permissions: permissions,
+                grants: grants
+            });
+        }
+        async buildArangoContext(tenantId, principalId, permissionKey, ...args) {
+            const access = await this.buildAccessContext(tenantId, principalId, ...args);
+            const allowedOrgUnitIds = access.allowedOrgUnitIdsByPermission[permissionKey] ?? [];
+            const allowedResourceIds = access.resourceGrants.filter(grant => grant.permissionKey === permissionKey).map(grant => grant.resourceId);
+            return buildArangoContext({
+                tenantId: tenantId,
+                principalId: principalId,
+                permissionKey: permissionKey,
+                allowedOrgUnitIds: allowedOrgUnitIds,
+                allowedResourceIds: allowedResourceIds
+            });
+        }
+        async buildQdrantFilter(tenantId, principalId, permissionKey, ...args) {
+            const access = await this.buildAccessContext(tenantId, principalId, ...args);
+            const allowedOrgUnitIds = access.allowedOrgUnitIdsByPermission[permissionKey] ?? [];
+            const allowedResourceIds = access.resourceGrants.filter(grant => grant.permissionKey === permissionKey).map(grant => grant.resourceId);
+            return buildQdrantFilter({
+                tenantId: tenantId,
+                principalId: principalId,
+                permissionKey: permissionKey,
+                allowedOrgUnitIds: allowedOrgUnitIds,
+                allowedResourceIds: allowedResourceIds
+            });
+        }
+    }
+    const VERSION = "0.3.6";
+    const COMMIT = "c132eea";
+    const FULL_VERSION = "0.3.6-c132eea";
+    const PACKAGE_NAME = "@decaf-ts/integrations";
+    Object.defineProperty(exports, "AuthorizationError", {
+        enumerable: true,
+        get: function() {
+            return core.AuthorizationError;
+        }
+    });
+    Object.defineProperty(exports, "transactional", {
+        enumerable: true,
+        get: function() {
+            return core.transactional;
+        }
+    });
+    exports.AuthorizationModel = AuthorizationModel;
+    exports.AuthzService = AuthzService;
+    exports.BaseModelService = BaseModelService;
+    exports.BootstrapService = BootstrapService;
+    exports.COMMIT = COMMIT;
+    exports.EffectivePermissionService = EffectivePermissionService;
+    exports.FULL_VERSION = FULL_VERSION;
+    exports.GroupMembershipService = GroupMembershipService;
+    exports.GroupService = GroupService;
+    exports.InheritanceBlockService = InheritanceBlockService;
+    exports.IsolationTierOptions = IsolationTierOptions;
+    exports.MembershipStatusOptions = MembershipStatusOptions;
+    exports.OrgUnitClosureService = OrgUnitClosureService;
+    exports.OrgUnitMembershipService = OrgUnitMembershipService;
+    exports.OrgUnitProfileService = OrgUnitProfileService;
+    exports.OrgUnitService = OrgUnitService;
+    exports.PACKAGE_NAME = PACKAGE_NAME;
+    exports.PermissionCategoryOptions = PermissionCategoryOptions;
+    exports.PermissionService = PermissionService;
+    exports.PrincipalKindOptions = PrincipalKindOptions;
+    exports.PrincipalService = PrincipalService;
+    exports.ProtectedResourceService = ProtectedResourceService;
+    exports.REL_CASCADE_DEPENDENT = REL_CASCADE_DEPENDENT;
+    exports.REL_CASCADE_INSERT_UPDATE = REL_CASCADE_INSERT_UPDATE;
+    exports.REL_NULLIFY = REL_NULLIFY;
+    exports.REL_RESTRICT = REL_RESTRICT;
+    exports.ResourceGrantService = ResourceGrantService;
+    exports.ResourceLifecycleService = ResourceLifecycleService;
+    exports.ResourceVisibilityOptions = ResourceVisibilityOptions;
+    exports.RoleAssignmentService = RoleAssignmentService;
+    exports.RolePermissionService = RolePermissionService;
+    exports.RoleService = RoleService;
+    exports.ScopeKindOptions = ScopeKindOptions;
+    exports.StorageBindingKindOptions = StorageBindingKindOptions;
+    exports.StorageBindingService = StorageBindingService;
+    exports.StorageKindOptions = StorageKindOptions;
+    exports.SystemManagementService = SystemManagementService;
+    exports.TenantMembershipService = TenantMembershipService;
+    exports.TenantProfileService = TenantProfileService;
+    exports.TenantService = TenantService;
+    exports.UserService = UserService;
+    exports.VERSION = VERSION;
+    exports.asArray = asArray;
+    exports.buildAccessContext = buildAccessContext;
+    exports.buildArangoContext = buildArangoContext;
+    exports.buildQdrantFilter = buildQdrantFilter;
+    exports.execWithLogging = execWithLogging;
+    exports.id = id;
+    exports.isTimeValid = isTimeValid;
+    exports.lowerSlug = lowerSlug;
+    exports.nowIso = nowIso;
+    exports.relationId = relationId;
+    exports.relationMatch = relationMatch;
+    exports.sameTenant = sameTenant;
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"integrations.cjs","sources":["../src/utils.ts","../src/namespaces/types.ts","../src/namespaces/utils.ts","../src/namespaces/models/authorization-model.ts","../src/namespaces/models/tenant-membership.model.ts","../src/namespaces/models/user.model.ts","../src/namespaces/models/org-unit-membership.model.ts","../src/namespaces/models/org-unit-closure.model.ts","../src/namespaces/models/permission.model.ts","../src/namespaces/models/role-permission.model.ts","../src/namespaces/models/role.model.ts","../src/namespaces/models/role-assignment.model.ts","../src/namespaces/models/resource-grant.model.ts","../src/namespaces/models/principal.model.ts","../src/namespaces/models/protected-resource.model.ts","../src/namespaces/models/inheritance-block.model.ts","../src/namespaces/models/org-unit.model.ts","../src/namespaces/models/storage-binding.model.ts","../src/namespaces/models/tenant.model.ts","../src/namespaces/models/tenant-profile.model.ts","../src/namespaces/models/org-unit-profile.model.ts","../src/namespaces/models/group-membership.model.ts","../src/namespaces/models/group.model.ts","../src/namespaces/models/effective-permission.model.ts","../src/namespaces/services/tenant-profile.service.ts","../src/namespaces/services/org-unit-profile.service.ts","../src/namespaces/services/org-unit-closure.service.ts","../src/namespaces/services/inheritance-block.service.ts","../src/namespaces/services/tenant.service.ts","../src/namespaces/services/org-unit.service.ts","../src/namespaces/services/user.service.ts","../src/namespaces/services/principal.service.ts","../src/namespaces/services/tenant-membership.service.ts","../src/namespaces/services/org-unit-membership.service.ts","../src/namespaces/services/group.service.ts","../src/namespaces/services/group-membership.service.ts","../src/namespaces/services/permission.service.ts","../src/namespaces/services/role.service.ts","../src/namespaces/services/role-permission.service.ts","../src/namespaces/services/role-assignment.service.ts","../src/namespaces/services/effective-permission.service.ts","../src/namespaces/services/protected-resource.service.ts","../src/namespaces/services/resource-grant.service.ts","../src/namespaces/services/resource-lifecycle.service.ts","../src/namespaces/services/storage-binding.service.ts","../src/namespaces/services/bootstrap.service.ts","../src/namespaces/services/system-management.service.ts","../src/namespaces/services/authz.service.ts","../src/index.ts"],"sourcesContent":["/**\n * @module integrations/utils\n * @summary Shared integration utilities.\n * @description Utility helpers used across the integrations package.\n */\nimport { exec } from \"child_process\";\nimport { Logger, LogLevel } from \"@decaf-ts/logging\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\nexport async function execWithLogging(\n  command: string,\n  options: { cwd: string },\n  log: Logger,\n  level: LogLevel = LogLevel.info\n): Promise<{ stdout: string; stderr: string }> {\n  log.debug(`Executing: ${command}`);\n\n  return new Promise((resolve, reject) => {\n    const child = exec(command, options);\n\n    const stdout: string[] = [];\n    const stderr: string[] = [];\n\n    child.stdout?.on(\"data\", (data: string) => {\n      stdout.push(data);\n      log[level](data.trim());\n    });\n\n    child.stderr?.on(\"data\", (data: string) => {\n      stderr.push(data);\n      log.debug(data.trim());\n    });\n\n    child.on(\"close\", (code: number) => {\n      if (code === 0) {\n        log.silly(`Command completed successfully`);\n        resolve({ stdout: stdout.join(\"\\n\"), stderr: stderr.join(\"\\n\") });\n      } else {\n        log.critical(\n          `Command failed with code ${code}:\\n ${stderr.join(\"\\n\")}`\n        );\n        reject(\n          new InternalError(\n            `Command failed with code ${code}: ${stderr.join(\"\\n\")}`\n          )\n        );\n      }\n    });\n\n    child.on(\"error\", (err: Error) => {\n      log.critical(`Command execution error`, err);\n      reject(err);\n    });\n  });\n}\n","export enum IsolationTier {\n  Pooled = \"pooled\",\n  Bridge = \"bridge\",\n  Silo = \"silo\",\n}\n\nexport enum MembershipStatus {\n  Invited = \"invited\",\n  Active = \"active\",\n  Suspended = \"suspended\",\n  Removed = \"removed\",\n}\n\nexport enum PrincipalKind {\n  User = \"user\",\n  Group = \"group\",\n  ServiceAccount = \"service_account\",\n  Agent = \"agent\",\n  ApiKey = \"api_key\",\n}\n\nexport enum ScopeKind {\n  Tenant = \"tenant\",\n  OrgUnit = \"org_unit\",\n  Resource = \"resource\",\n}\n\nexport enum PermissionCategory {\n  Admin = \"admin\",\n  ContentRead = \"content_read\",\n  ContentWrite = \"content_write\",\n  Memory = \"memory\",\n  Graph = \"graph\",\n  Vector = \"vector\",\n  Export = \"export\",\n  Billing = \"billing\",\n  Audit = \"audit\",\n  Security = \"security\",\n  Data = \"data\",\n  Automation = \"automation\",\n}\n\nexport enum ResourceVisibility {\n  Private = \"private\",\n  ResourceAcl = \"resource_acl\",\n  OrgUnit = \"org_unit\",\n  OrgSubtree = \"org_subtree\",\n  Tenant = \"tenant\",\n}\n\nexport enum StorageKind {\n  Postgres = \"postgres\",\n  Arango = \"arango\",\n  Qdrant = \"qdrant\",\n  ObjectStorage = \"object_storage\",\n}\n\nexport enum StorageBindingKind {\n  Shared = \"shared\",\n  Dedicated = \"dedicated\",\n}\n\nexport const IsolationTierOptions = Object.values(IsolationTier);\nexport const MembershipStatusOptions = Object.values(MembershipStatus);\nexport const PrincipalKindOptions = Object.values(PrincipalKind);\nexport const ScopeKindOptions = Object.values(ScopeKind);\nexport const PermissionCategoryOptions = Object.values(PermissionCategory);\nexport const ResourceVisibilityOptions = Object.values(ResourceVisibility);\nexport const StorageKindOptions = Object.values(StorageKind);\nexport const StorageBindingKindOptions = Object.values(StorageBindingKind);\n\nexport type TxArgs = any[];\n\nexport interface CreateTenantInput {\n  slug: string;\n  name: string;\n  isolationTier?: IsolationTier;\n  profileKey?: string;\n  profileMetadata?: Record<string, unknown>;\n}\n\nexport interface CreateUserInput {\n  email?: string;\n  phone?: string;\n  displayName: string;\n}\n\nexport interface CreateOrgUnitInput {\n  tenantId: string;\n  parentOrgUnitId?: string;\n  name: string;\n  metadata?: Record<string, unknown>;\n  profileKey?: string;\n  profileMetadata?: Record<string, unknown>;\n}\n\nexport interface CreateRoleInput {\n  tenantId?: string;\n  key: string;\n  name: string;\n  description?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface CreatePermissionInput {\n  key: string;\n  category: PermissionCategory;\n  description?: string;\n}\n\nexport interface AssignRoleInput {\n  tenantId: string;\n  principalId: string;\n  roleId: string;\n  scopeKind: ScopeKind;\n  scopeId: string;\n  inheritDown?: boolean;\n  startsAt?: Date;\n  expiresAt?: Date;\n  conditions?: Record<string, unknown>;\n}\n\nexport interface RegisterResourceInput {\n  tenantId: string;\n  orgUnitId: string;\n  resourceType: string;\n  resourceId: string;\n  visibility: ResourceVisibility;\n  ownerPrincipalId?: string;\n  sensitivity?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface GrantResourceInput {\n  tenantId: string;\n  resourceId: string;\n  principalId: string;\n  permissionKey: string;\n  startsAt?: Date;\n  expiresAt?: Date;\n  conditions?: Record<string, unknown>;\n  createdByPrincipalId?: string;\n}\n\nexport interface CanAccessInput {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  resourceProtectedId?: string;\n  scopeKind?: ScopeKind;\n  scopeId?: string;\n  at?: Date;\n}\n\nexport interface AccessContext {\n  tenantId: string;\n  principalId: string;\n  permissionsByScope: Record<string, string[]>;\n  allowedOrgUnitIdsByPermission: Record<string, string[]>;\n  resourceGrants: Array<{ resourceId: string; permissionKey: string }>;\n}\n\nexport interface ArangoAuthContext {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}\n\nexport interface QdrantAuthFilter {\n  must: Array<Record<string, unknown>>;\n  must_not?: Array<Record<string, unknown>>;\n}\n\nexport interface CreateStorageBindingInput {\n  tenantId: string;\n  storageKind: StorageKind;\n  bindingKind: StorageBindingKind;\n  bindingKey: string;\n  region: string;\n  config?: Record<string, unknown>;\n}\n\nexport interface BootstrapPermission {\n  key: string;\n  category: PermissionCategory;\n  description?: string;\n}\n\nexport interface BootstrapRole {\n  key: string;\n  name: string;\n  description?: string;\n  permissionKeys: string[];\n}\n\nexport interface BootstrapOrgUnit {\n  name: string;\n  profileKey?: string;\n  metadata?: Record<string, unknown>;\n  children?: BootstrapOrgUnit[];\n}\n\nexport interface BootstrapTemplate {\n  tenant: CreateTenantInput;\n  rootOrgUnit: BootstrapOrgUnit;\n  permissions: BootstrapPermission[];\n  roles: BootstrapRole[];\n  ownerUser: CreateUserInput;\n  ownerRoleKey: string;\n}\n\nexport interface ResourceSnapshot {\n  id: string;\n  tenantId: string;\n  orgUnitId: string;\n  resourceType: string;\n  resourceId: string;\n  visibility: ResourceVisibility;\n  ownerPrincipalId?: string;\n  sensitivity?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface GrantSnapshot {\n  id: string;\n  tenantId: string;\n  resourceId: string;\n  principalId: string;\n  permissionKey: string;\n  startsAt?: Date;\n  expiresAt?: Date;\n  conditions?: Record<string, unknown>;\n  createdByPrincipalId?: string;\n}\n\nexport interface EffectivePermissionSnapshot {\n  id: string;\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  scopeKind: ScopeKind;\n  scopeId: string;\n  sourceKind: string;\n  sourceId: string;\n  startsAt?: Date;\n  expiresAt?: Date;\n}\n\nexport interface AuthzDataSources {\n  loadResource?: (tenantId: string, protectedResourceId: string) => Promise<ResourceSnapshot | undefined>;\n  listResourceGrants?: (tenantId: string, protectedResourceId: string) => Promise<GrantSnapshot[]>;\n  listPrincipalGrants?: (tenantId: string, principalId: string) => Promise<GrantSnapshot[]>;\n  listEffectivePermissions?: (\n    tenantId: string,\n    principalId: string\n  ) => Promise<EffectivePermissionSnapshot[]>;\n  listEffectivePermissionsForScope?: (\n    tenantId: string,\n    scopeKind: ScopeKind,\n    scopeId: string\n  ) => Promise<EffectivePermissionSnapshot[]>;\n}\n","import { AuthorizationError, Cascade, ModelService, Repository } from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  AccessContext,\n  ArangoAuthContext,\n  EffectivePermissionSnapshot,\n  GrantSnapshot,\n  QdrantAuthFilter,\n  ResourceVisibility,\n  ScopeKind,\n} from \"./types\";\n\nexport const REL_RESTRICT = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport const REL_NULLIFY = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: true,\n} as const;\n\nexport const REL_CASCADE_DEPENDENT = {\n  update: Cascade.CASCADE,\n  delete: Cascade.CASCADE,\n  nullable: false,\n} as const;\n\nexport const REL_CASCADE_INSERT_UPDATE = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport function buildArangoContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): ArangoAuthContext {\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionKey: options.permissionKey,\n    allowedOrgUnitIds: [...options.allowedOrgUnitIds],\n    allowedResourceIds: [...options.allowedResourceIds],\n  };\n}\n\nexport function buildQdrantFilter(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): QdrantAuthFilter {\n  return {\n    must: [\n      {\n        key: \"tenant_id\",\n        match: { value: options.tenantId },\n      },\n      {\n        should: [\n          { key: \"org_unit_id\", match: { any: options.allowedOrgUnitIds } },\n          { key: \"protected_resource_id\", match: { any: options.allowedResourceIds } },\n          { key: \"owner_principal_id\", match: { value: options.principalId } },\n        ],\n      },\n    ],\n  };\n}\n\nfunction scopeKey(scopeKind: ScopeKind, scopeId: string): string {\n  return `${scopeKind}:${scopeId}`;\n}\n\nexport function nowIso(): Date {\n  return new Date();\n}\n\nexport function asArray<T>(value: T[] | undefined): T[] {\n  return value ?? [];\n}\n\nexport function sameTenant(rowTenant: unknown, tenantId: string): boolean {\n  return relationId(rowTenant as { id: string } | string) === tenantId;\n}\n\nexport function relationMatch(value: unknown, target: string | undefined): boolean {\n  return target ? relationId(value as { id: string } | string) === target : false;\n}\n\nexport function lowerSlug(value: string): string {\n  return (\n    value\n      .trim()\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, \"-\")\n      .replace(/^-+|-+$/g, \"\") || \"item\"\n  );\n}\n\nexport function isTimeValid(at: Date | undefined, startsAt?: Date, expiresAt?: Date): boolean {\n  const instant = at ?? new Date();\n  if (startsAt && instant < startsAt) return false;\n  if (expiresAt && instant > expiresAt) return false;\n  return true;\n}\n\nexport function buildAccessContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissions: EffectivePermissionSnapshot[];\n  grants: GrantSnapshot[];\n}): AccessContext {\n  const permissionsByScope: Record<string, string[]> = {};\n  const allowedOrgUnitIdsByPermission: Record<string, string[]> = {};\n\n  for (const permission of options.permissions) {\n    const key = scopeKey(permission.scopeKind, permission.scopeId);\n    permissionsByScope[key] = permissionsByScope[key] ?? [];\n    permissionsByScope[key].push(permission.permissionKey);\n    if (permission.scopeKind === ScopeKind.OrgUnit) {\n      allowedOrgUnitIdsByPermission[permission.permissionKey] =\n        allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];\n      allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);\n    }\n  }\n\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionsByScope,\n    allowedOrgUnitIdsByPermission,\n      resourceGrants: options.grants.map((grant) => ({\n        resourceId: grant.resourceId,\n        permissionKey: grant.permissionKey,\n      })),\n  };\n}\n\nexport abstract class BaseModelService<M extends Model<boolean> & { id: string }> extends ModelService<\n  M,\n  Repository<M, any>\n> {\n  protected constructor(clazz: new () => M) {\n    super(clazz);\n  }\n\n  protected newModel<T>(clazz: new () => T, data: Partial<T>): T {\n    return Object.assign(new clazz() as object, data as object) as T;\n  }\n\n  async create(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.repo.create(Object.assign({} as M, data as object), ...args);\n  }\n\n  async createOne(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.create(data, ...args);\n  }\n\n  async getById(id: string, ...args: any[]): Promise<M> {\n    return this.repo.read(id, ...args);\n  }\n\n  async updateOne(id: string, patch: Partial<M>, ...args: any[]): Promise<M> {\n    const existing = await this.repo.read(id, ...args);\n    return this.repo.update(Object.assign(existing, patch), ...args);\n  }\n\n  async deleteById(id: string, ...args: any[]): Promise<void> {\n    await this.repo.delete(id, ...args);\n  }\n\n  async findOneBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M> {\n    return this.repo.findOneBy(key, value, ...args);\n  }\n\n  async findManyBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M[]> {\n    return this.repo.select().where({ [key]: value } as any).execute(...args);\n  }\n\n  async listAll(...args: any[]): Promise<M[]> {\n    return this.repo.select().execute(...args);\n  }\n}\n\nexport function id(): string {\n  return crypto.randomUUID();\n}\n\nexport function relationId(value: string | { id: string }): string {\n  return typeof value === \"string\" ? value : value.id;\n}\n\nexport { AuthorizationError, transactional } from \"@decaf-ts/core\";\n","import { Model } from \"@decaf-ts/decorator-validation\";\n\nexport abstract class AuthorizationModel extends Model {\n  constructor(data?: unknown) {\n    super(data as never);\n  }\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { MembershipStatus, MembershipStatusOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { User } from \"./user.model\";\n\n@table(\"tenant_memberships\")\n@model()\nexport class TenantMembership extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_tenant_memberships_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => User, REL_CASCADE_DEPENDENT, false, undefined, \"fk_tenant_memberships_user\")\n  @required()\n  user!: User | string;\n  @required() @typeOf(String) @option(MembershipStatusOptions) @column() status!: MembershipStatus;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import {\n  column,\n  createdAt,\n  oneToMany,\n  pk,\n  table,\n  unique,\n  updatedAt,\n  uuid,\n} from \"@decaf-ts/core\";\nimport { model, required, type } from \"@decaf-ts/decorator-validation\";\nimport { REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { TenantMembership } from \"./tenant-membership.model\";\nimport { OrgUnitMembership } from \"./org-unit-membership.model\";\n\n@table(\"users\")\n@model()\nexport class User extends AuthorizationModel {\n  @pk({ type: String })\n  @uuid()\n  id!: string;\n\n  @unique()\n  @type(String)\n  @column()\n  email?: string;\n\n  @unique()\n  @type(String)\n  @column()\n  phone?: string;\n\n  @required()\n  @type(String)\n  @column()\n  displayName!: string;\n\n  @oneToMany(() => TenantMembership, REL_RESTRICT, false)\n  tenantMemberships?: TenantMembership[] | string[];\n\n  @oneToMany(() => OrgUnitMembership, REL_RESTRICT, false)\n  orgUnitMemberships?: OrgUnitMembership[] | string[];\n\n  @createdAt()\n  createdAt!: Date;\n\n  @updatedAt()\n  updatedAt!: Date;\n\n  constructor(data?: unknown) {\n    super(data);\n  }\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { MembershipStatus, MembershipStatusOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT, REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnit } from \"./org-unit.model\";\nimport { User } from \"./user.model\";\n\n@table(\"org_unit_memberships\")\n@model()\nexport class OrgUnitMembership extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_memberships_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_memberships_org_unit\")\n  @required()\n  orgUnit!: OrgUnit | string;\n  @manyToOne(() => User, REL_RESTRICT, false, undefined, \"fk_org_memberships_user\")\n  @required()\n  user!: User | string;\n  @required() @typeOf(String) @option(MembershipStatusOptions) @column() status!: MembershipStatus;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnit } from \"./org-unit.model\";\n\n@table(\"org_unit_closure\")\n@model()\nexport class OrgUnitClosure extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_closure_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_closure_ancestor\")\n  @required()\n  ancestor!: OrgUnit | string;\n  @manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_closure_descendant\")\n  @required()\n  descendant!: OrgUnit | string;\n  @required() @typeOf(Number) @column() depth!: number;\n  @createdAt() createdAt!: Date;\n}\n","import { column, oneToMany, pk, table, unique, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { PermissionCategory, PermissionCategoryOptions } from \"../types\";\nimport { REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { RolePermission } from \"./role-permission.model\";\n\n@table(\"permissions\")\n@model()\nexport class Permission extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @unique() @required() @typeOf(String) @column() key!: string;\n  @required() @typeOf(String) @option(PermissionCategoryOptions) @column() category!: PermissionCategory;\n  @typeOf(String) @column() description?: string;\n  @oneToMany(() => RolePermission, REL_RESTRICT, false) rolePermissions?: RolePermission[] | string[];\n}\n","import { createdAt, manyToOne, pk, table, uuid } from \"@decaf-ts/core\";\nimport { model, required } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Role } from \"./role.model\";\nimport { Permission } from \"./permission.model\";\n\n@table(\"role_permissions\")\n@model()\nexport class RolePermission extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Role, REL_CASCADE_DEPENDENT, false, undefined, \"fk_role_permissions_role\")\n  @required()\n  role!: Role | string;\n  @manyToOne(() => Permission, REL_CASCADE_DEPENDENT, false, undefined, \"fk_role_permissions_permission\")\n  @required()\n  permission!: Permission | string;\n  @createdAt() createdAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_NULLIFY, REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { RolePermission } from \"./role-permission.model\";\nimport { RoleAssignment } from \"./role-assignment.model\";\n\n@table(\"roles\")\n@model()\nexport class Role extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_NULLIFY, false, undefined, \"fk_roles_tenant\")\n  tenant?: Tenant | string;\n  @required() @typeOf(String) @column() key!: string;\n  @required() @typeOf(String) @column() name!: string;\n  @typeOf(String) @column() description?: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @oneToMany(() => RolePermission, REL_RESTRICT, false) rolePermissions?: RolePermission[] | string[];\n  @oneToMany(() => RoleAssignment, REL_RESTRICT, false) assignments?: RoleAssignment[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { ScopeKind, ScopeKindOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT, REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { Principal } from \"./principal.model\";\nimport { Role } from \"./role.model\";\n\n@table(\"role_assignments\")\n@model()\nexport class RoleAssignment extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_role_assignments_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, \"fk_role_assignments_principal\")\n  @required()\n  principal!: Principal | string;\n  @manyToOne(() => Role, REL_RESTRICT, false, undefined, \"fk_role_assignments_role\")\n  @required()\n  role!: Role | string;\n  @required() @typeOf(String) @option(ScopeKindOptions) @column() scopeKind!: ScopeKind;\n  @required() @typeOf(String) @column() scopeId!: string;\n  @required() @typeOf(Boolean) @column() inheritDown!: boolean;\n  @column() startsAt?: Date;\n  @column() expiresAt?: Date;\n  @typeOf(Object) @column() conditions?: Record<string, unknown>;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT, REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { Principal } from \"./principal.model\";\nimport { ProtectedResource } from \"./protected-resource.model\";\n\n@table(\"resource_grants\")\n@model()\nexport class ResourceGrant extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_resource_grants_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => ProtectedResource, REL_CASCADE_DEPENDENT, false, undefined, \"fk_resource_grants_resource\")\n  @required()\n  resource!: ProtectedResource | string;\n  @manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, \"fk_resource_grants_principal\")\n  @required()\n  principal!: Principal | string;\n  @required() @typeOf(String) @column() permissionKey!: string;\n  @column() startsAt?: Date;\n  @column() expiresAt?: Date;\n  @typeOf(Object) @column() conditions?: Record<string, unknown>;\n  @manyToOne(() => Principal, REL_RESTRICT, false, undefined, \"fk_resource_grants_created_by\")\n  createdBy?: Principal | string;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { PrincipalKind, PrincipalKindOptions } from \"../types\";\nimport { REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { RoleAssignment } from \"./role-assignment.model\";\nimport { ResourceGrant } from \"./resource-grant.model\";\n\n@table(\"principals\")\n@model()\nexport class Principal extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_RESTRICT, false, undefined, \"fk_principals_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @required() @typeOf(String) @option(PrincipalKindOptions) @column() kind!: PrincipalKind;\n  @required() @typeOf(String) @column() subjectId!: string;\n  @oneToMany(() => RoleAssignment, REL_RESTRICT, false) roleAssignments?: RoleAssignment[] | string[];\n  @oneToMany(() => ResourceGrant, REL_RESTRICT, false) resourceGrants?: ResourceGrant[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_NULLIFY, REL_RESTRICT } from \"../utils\";\nimport { ResourceVisibility, ResourceVisibilityOptions } from \"../types\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnit } from \"./org-unit.model\";\nimport { Principal } from \"./principal.model\";\nimport { ResourceGrant } from \"./resource-grant.model\";\n\n@table(\"protected_resources\")\n@model()\nexport class ProtectedResource extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_RESTRICT, false, undefined, \"fk_protected_resources_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_RESTRICT, false, undefined, \"fk_protected_resources_org_unit\")\n  @required()\n  orgUnit!: OrgUnit | string;\n  @required() @typeOf(String) @column() resourceType!: string;\n  @required() @typeOf(String) @column() resourceId!: string;\n  @required() @typeOf(String) @option(ResourceVisibilityOptions) @column() visibility!: ResourceVisibility;\n  @manyToOne(() => Principal, REL_NULLIFY, false, undefined, \"fk_protected_resources_owner\")\n  owner?: Principal | string;\n  @typeOf(String) @column() sensitivity?: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @oneToMany(() => ResourceGrant, REL_RESTRICT, false) grants?: ResourceGrant[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { PermissionCategory, PermissionCategoryOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT, REL_NULLIFY } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnit } from \"./org-unit.model\";\n\n@table(\"inheritance_blocks\")\n@model()\nexport class InheritanceBlock extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_inheritance_blocks_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, \"fk_inheritance_blocks_org_unit\")\n  @required()\n  orgUnit!: OrgUnit | string;\n  @manyToOne(() => OrgUnit, REL_NULLIFY, false, undefined, \"fk_inheritance_blocks_blocked_ancestor\")\n  blockedFromAncestor?: OrgUnit | string;\n  @required() @typeOf(String) @option(PermissionCategoryOptions) @column() permissionCategory!: PermissionCategory;\n  @typeOf(String) @column() reason?: string;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnitMembership } from \"./org-unit-membership.model\";\nimport { OrgUnitClosure } from \"./org-unit-closure.model\";\nimport { ProtectedResource } from \"./protected-resource.model\";\nimport { InheritanceBlock } from \"./inheritance-block.model\";\n\n@table(\"org_units\")\n@model()\nexport class OrgUnit extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_RESTRICT, false, undefined, \"fk_org_units_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_RESTRICT, false, undefined, \"fk_org_units_parent\")\n  parent?: OrgUnit | string;\n  @oneToMany(() => OrgUnit, REL_RESTRICT, false) children?: OrgUnit[] | string[];\n  @required() @typeOf(String) @column() name!: string;\n  @required() @typeOf(String) @column() path!: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @oneToMany(() => OrgUnitMembership, REL_RESTRICT, false) memberships?: OrgUnitMembership[] | string[];\n  @oneToMany(() => ProtectedResource, REL_RESTRICT, false) resources?: ProtectedResource[] | string[];\n  @oneToMany(() => InheritanceBlock, REL_RESTRICT, false) inheritanceBlocks?: InheritanceBlock[] | string[];\n  @oneToMany(() => OrgUnitClosure, REL_RESTRICT, false) ancestorLinks?: OrgUnitClosure[] | string[];\n  @oneToMany(() => OrgUnitClosure, REL_RESTRICT, false) descendantLinks?: OrgUnitClosure[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { StorageBindingKind, StorageBindingKindOptions, StorageKind, StorageKindOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\n\n@table(\"storage_bindings\")\n@model()\nexport class StorageBinding extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_storage_bindings_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @required() @typeOf(String) @option(StorageKindOptions) @column() storageKind!: StorageKind;\n  @required() @typeOf(String) @option(StorageBindingKindOptions) @column() bindingKind!: StorageBindingKind;\n  @required() @typeOf(String) @column() bindingKey!: string;\n  @required() @typeOf(String) @column() region!: string;\n  @typeOf(Object) @column() config?: Record<string, unknown>;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, unique, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { IsolationTier, IsolationTierOptions } from \"../types\";\nimport { REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { OrgUnit } from \"./org-unit.model\";\nimport { TenantMembership } from \"./tenant-membership.model\";\nimport { Principal } from \"./principal.model\";\nimport { StorageBinding } from \"./storage-binding.model\";\n\n@table(\"tenants\")\n@model()\nexport class Tenant extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @unique() @required() @typeOf(String) @column() slug!: string;\n  @required() @typeOf(String) @column() name!: string;\n  @required() @typeOf(String) @option(IsolationTierOptions) @column() isolationTier!: IsolationTier;\n  @oneToMany(() => OrgUnit, REL_RESTRICT, false) orgUnits?: OrgUnit[] | string[];\n  @oneToMany(() => TenantMembership, REL_RESTRICT, false) memberships?: TenantMembership[] | string[];\n  @oneToMany(() => Principal, REL_RESTRICT, false) principals?: Principal[] | string[];\n  @oneToMany(() => StorageBinding, REL_RESTRICT, false) storageBindings?: StorageBinding[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\n\n@table(\"tenant_profiles\")\n@model()\nexport class TenantProfile extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_tenant_profiles_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @required() @typeOf(String) @column() profileKey!: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { OrgUnit } from \"./org-unit.model\";\n\n@table(\"org_unit_profiles\")\n@model()\nexport class OrgUnitProfile extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, \"fk_org_unit_profiles_org_unit\")\n  @required()\n  orgUnit!: OrgUnit | string;\n  @required() @typeOf(String) @column() profileKey!: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { Group } from \"./group.model\";\nimport { Principal } from \"./principal.model\";\n\n@table(\"group_memberships\")\n@model()\nexport class GroupMembership extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_group_memberships_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => Group, REL_CASCADE_DEPENDENT, false, undefined, \"fk_group_memberships_group\")\n  @required()\n  group!: Group | string;\n  @manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, \"fk_group_memberships_principal\")\n  @required()\n  principal!: Principal | string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @createdAt() createdAt!: Date;\n}\n","import { column, createdAt, manyToOne, oneToMany, pk, table, updatedAt, uuid } from \"@decaf-ts/core\";\nimport { model, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { REL_NULLIFY, REL_RESTRICT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { OrgUnit } from \"./org-unit.model\";\nimport { GroupMembership } from \"./group-membership.model\";\n\n@table(\"groups\")\n@model()\nexport class Group extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_RESTRICT, false, undefined, \"fk_groups_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => OrgUnit, REL_NULLIFY, false, undefined, \"fk_groups_org_unit\")\n  orgUnit?: OrgUnit | string;\n  @required() @typeOf(String) @column() name!: string;\n  @typeOf(Object) @column() metadata?: Record<string, unknown>;\n  @oneToMany(() => GroupMembership, REL_RESTRICT, false) members?: GroupMembership[] | string[];\n  @createdAt() createdAt!: Date;\n  @updatedAt() updatedAt!: Date;\n}\n","import { column, createdAt, manyToOne, pk, table, uuid } from \"@decaf-ts/core\";\nimport { model, option, required, type as typeOf } from \"@decaf-ts/decorator-validation\";\nimport { ScopeKind, ScopeKindOptions } from \"../types\";\nimport { REL_CASCADE_DEPENDENT } from \"../utils\";\nimport { AuthorizationModel } from \"./authorization-model\";\nimport { Tenant } from \"./tenant.model\";\nimport { Principal } from \"./principal.model\";\n\n@table(\"effective_permissions\")\n@model()\nexport class EffectivePermission extends AuthorizationModel {\n  constructor(data?: unknown) {\n    super(data);\n  }\n\n  @pk({ type: String }) @uuid() id!: string;\n  @manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, \"fk_effective_permissions_tenant\")\n  @required()\n  tenant!: Tenant | string;\n  @manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, \"fk_effective_permissions_principal\")\n  @required()\n  principal!: Principal | string;\n  @required() @typeOf(String) @column() permissionKey!: string;\n  @required() @typeOf(String) @option(ScopeKindOptions) @column() scopeKind!: ScopeKind;\n  @required() @typeOf(String) @column() scopeId!: string;\n  @required() @typeOf(String) @column() sourceKind!: string;\n  @required() @typeOf(String) @column() sourceId!: string;\n  @column() startsAt?: Date;\n  @column() expiresAt?: Date;\n  @createdAt() createdAt!: Date;\n}\n","import { BaseModelService, id, relationId, sameTenant } from \"../utils\";\nimport { TenantProfile } from \"../models/tenant-profile.model\";\n\nexport class TenantProfileService extends BaseModelService<TenantProfile> {\n  constructor() {\n    super(TenantProfile);\n  }\n\n  async createProfile(\n    tenantId: string,\n    profileKey: string,\n    metadata?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<TenantProfile> {\n    return this.create(\n      {\n        tenant: tenantId,\n        profileKey,\n        metadata,\n      },\n      ...args\n    );\n  }\n\n  async listForTenant(tenantId: string, ...args: any[]): Promise<TenantProfile[]> {\n    return (await this.listAll(...args)).filter((profile) => sameTenant(profile.tenant, tenantId));\n  }\n\n  async deleteForTenant(tenantId: string, ...args: any[]): Promise<void> {\n    for (const row of await this.listForTenant(tenantId, ...args)) {\n      await this.deleteById(row.id, ...args);\n    }\n  }\n}\n","import { BaseModelService, id, relationMatch } from \"../utils\";\nimport { OrgUnitProfile } from \"../models/org-unit-profile.model\";\n\nexport class OrgUnitProfileService extends BaseModelService<OrgUnitProfile> {\n  constructor() {\n    super(OrgUnitProfile);\n  }\n\n  async createProfile(\n    orgUnitId: string,\n    profileKey: string,\n    metadata?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<OrgUnitProfile> {\n    return this.create(\n      {\n        orgUnit: orgUnitId,\n        profileKey,\n        metadata,\n      },\n      ...args\n    );\n  }\n\n  async listForOrgUnit(orgUnitId: string, ...args: any[]): Promise<OrgUnitProfile[]> {\n    return (await this.listAll(...args)).filter((profile) => relationMatch(profile.orgUnit, orgUnitId));\n  }\n}\n","import { BaseModelService, id, relationId, relationMatch, sameTenant } from \"../utils\";\nimport { OrgUnitClosure } from \"../models/org-unit-closure.model\";\n\nexport class OrgUnitClosureService extends BaseModelService<OrgUnitClosure> {\n  constructor() {\n    super(OrgUnitClosure);\n  }\n\n  async listAncestors(tenantId: string, orgUnitId: string, ...args: any[]): Promise<OrgUnitClosure[]> {\n    return (await this.listAll(...args))\n      .filter((row) => sameTenant(row.tenant, tenantId) && relationMatch(row.descendant, orgUnitId))\n      .sort((left, right) => left.depth - right.depth);\n  }\n\n  async listDescendants(tenantId: string, orgUnitId: string, ...args: any[]): Promise<OrgUnitClosure[]> {\n    return (await this.listAll(...args))\n      .filter((row) => sameTenant(row.tenant, tenantId) && relationMatch(row.ancestor, orgUnitId))\n      .sort((left, right) => left.depth - right.depth);\n  }\n\n  async isAncestorOf(\n    tenantId: string,\n    ancestorOrgUnitId: string,\n    descendantOrgUnitId: string,\n    ...args: any[]\n  ): Promise<boolean> {\n    return (await this.listAncestors(tenantId, descendantOrgUnitId, ...args)).some((row) =>\n      relationMatch(row.ancestor, ancestorOrgUnitId)\n    );\n  }\n\n  async createSelfLink(tenantId: string, orgUnitId: string, ...args: any[]): Promise<OrgUnitClosure> {\n    return this.create(\n      {\n        tenant: tenantId,\n        ancestor: orgUnitId,\n        descendant: orgUnitId,\n        depth: 0,\n      },\n      ...args\n    );\n  }\n\n  async insertAncestorLinksForNewChild(\n    tenantId: string,\n    parentOrgUnitId: string,\n    childOrgUnitId: string,\n    ...args: any[]\n  ): Promise<void> {\n    const ancestorLinks = await this.listAncestors(tenantId, parentOrgUnitId, ...args);\n    for (const link of ancestorLinks) {\n      await this.create(\n        {\n          tenant: tenantId,\n          ancestor: link.ancestor,\n          descendant: childOrgUnitId,\n          depth: link.depth + 1,\n        },\n        ...args\n      );\n    }\n  }\n\n  async deleteLinksForSubtree(tenantId: string, orgUnitId: string, ...args: any[]): Promise<void> {\n    const subtree = await this.listDescendants(tenantId, orgUnitId, ...args);\n    const descendantIds = new Set([orgUnitId, ...subtree.map((row) => relationId(row.descendant))]);\n    const ancestorIds = new Set([orgUnitId, ...subtree.map((row) => relationId(row.ancestor))]);\n    const rows = (await this.listAll(...args)).filter(\n      (row) =>\n        sameTenant(row.tenant, tenantId) &&\n        (descendantIds.has(relationId(row.descendant)) || ancestorIds.has(relationId(row.ancestor)))\n    );\n    for (const row of rows) {\n      await this.deleteById(row.id, ...args);\n    }\n  }\n}\n","import { BaseModelService, id, relationMatch, sameTenant } from \"../utils\";\nimport { PermissionCategory } from \"../types\";\nimport { InheritanceBlock } from \"../models/inheritance-block.model\";\n\nexport class InheritanceBlockService extends BaseModelService<InheritanceBlock> {\n  constructor() {\n    super(InheritanceBlock);\n  }\n\n  async blockCategory(\n    tenantId: string,\n    orgUnitId: string,\n    permissionCategory: PermissionCategory,\n    blockedFromAncestorId?: string,\n    reason?: string,\n    ...args: any[]\n  ): Promise<InheritanceBlock> {\n    return this.create(\n      {\n        tenant: tenantId,\n        orgUnit: orgUnitId,\n        blockedFromAncestor: blockedFromAncestorId,\n        permissionCategory,\n        reason,\n      },\n      ...args\n    );\n  }\n\n  async unblockCategory(blockId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(blockId, ...args);\n  }\n\n  async listForOrgUnit(tenantId: string, orgUnitId: string, ...args: any[]): Promise<InheritanceBlock[]> {\n    return (await this.listAll(...args)).filter(\n      (block) => sameTenant(block.tenant, tenantId) && relationMatch(block.orgUnit, orgUnitId)\n    );\n  }\n\n  async categoryBlockedForAncestor(\n    tenantId: string,\n    orgUnitId: string,\n    ancestorOrgUnitId: string,\n    category: PermissionCategory,\n    ...args: any[]\n  ): Promise<boolean> {\n    return (await this.listForOrgUnit(tenantId, orgUnitId, ...args)).some(\n      (block) =>\n        block.permissionCategory === category &&\n        (!block.blockedFromAncestor || relationMatch(block.blockedFromAncestor, ancestorOrgUnitId))\n    );\n  }\n}\n","import { BaseModelService } from \"../utils\";\nimport { IsolationTier, CreateTenantInput } from \"../types\";\nimport { Tenant } from \"../models/tenant.model\";\n\nexport class TenantService extends BaseModelService<Tenant> {\n  constructor() {\n    super(Tenant);\n  }\n\n  async createTenant(input: CreateTenantInput, ...args: any[]): Promise<Tenant> {\n    return this.create(\n      {\n        slug: input.slug,\n        name: input.name,\n        isolationTier: input.isolationTier ?? IsolationTier.Pooled,\n      },\n      ...args\n    );\n  }\n\n  async getBySlug(slug: string, ...args: any[]): Promise<Tenant> {\n    return this.findOneBy(\"slug\", slug as never, ...args);\n  }\n\n  async renameTenant(tenantId: string, name: string, ...args: any[]): Promise<Tenant> {\n    return this.updateOne(tenantId, { name }, ...args);\n  }\n\n  async changeSlug(tenantId: string, slug: string, ...args: any[]): Promise<Tenant> {\n    return this.updateOne(tenantId, { slug }, ...args);\n  }\n\n  async setIsolationTier(\n    tenantId: string,\n    isolationTier: IsolationTier,\n    ...args: any[]\n  ): Promise<Tenant> {\n    return this.updateOne(tenantId, { isolationTier }, ...args);\n  }\n\n  async deleteTenantControlled(tenantId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(tenantId, ...args);\n  }\n}\n","import { BaseModelService, lowerSlug, relationId, relationMatch, sameTenant } from \"../utils\";\nimport type { CreateOrgUnitInput } from \"../types\";\nimport { OrgUnit } from \"../models/org-unit.model\";\nimport { OrgUnitProfileService } from \"./org-unit-profile.service\";\nimport { OrgUnitClosureService } from \"./org-unit-closure.service\";\nimport { transactional } from \"../utils\";\n\nasync function deleteRowsById(\n  service: BaseModelService<any>,\n  rows: Array<{ id: string }>,\n  ...args: any[]\n): Promise<void> {\n  for (const row of rows) {\n    await service.deleteById(row.id, ...args);\n  }\n}\n\nexport class OrgUnitService extends BaseModelService<OrgUnit> {\n  constructor() {\n    super(OrgUnit);\n  }\n\n  private orgUnitPath(parentPath: string | undefined, name: string): string {\n    const segment = lowerSlug(name);\n    return parentPath ? `${parentPath.replace(/\\/+$/, \"\")}/${segment}` : `/${segment}`;\n  }\n\n  private async createProfileIfNeeded(\n    orgUnitId: string,\n    profileKey: string | undefined,\n    profileMetadata: Record<string, unknown> | undefined,\n    ...args: any[]\n  ): Promise<void> {\n    if (!profileKey) return;\n    await new OrgUnitProfileService().createProfile(orgUnitId, profileKey, profileMetadata, ...args);\n  }\n\n  @transactional()\n  async createRoot(\n    tenantId: string,\n    name: string,\n    metadata?: Record<string, unknown>,\n    profileKey?: string,\n    profileMetadata?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<OrgUnit> {\n    const orgUnit = await this.create(\n      {\n        tenant: tenantId,\n        name,\n        path: this.orgUnitPath(undefined, name),\n        metadata,\n      },\n      ...args\n    );\n    await this.createProfileIfNeeded(orgUnit.id, profileKey, profileMetadata, ...args);\n    await new OrgUnitClosureService().createSelfLink(tenantId, orgUnit.id, ...args);\n    return orgUnit;\n  }\n\n  @transactional()\n  async createChild(input: CreateOrgUnitInput, ...args: any[]): Promise<OrgUnit> {\n    const parent = input.parentOrgUnitId ? await this.getById(input.parentOrgUnitId, ...args) : undefined;\n    const orgUnit = await this.create(\n      {\n        tenant: input.tenantId,\n        parent: parent?.id ?? input.parentOrgUnitId,\n        name: input.name,\n        path: this.orgUnitPath(parent?.path, input.name),\n        metadata: input.metadata,\n      },\n      ...args\n    );\n    await this.createProfileIfNeeded(orgUnit.id, input.profileKey, input.profileMetadata, ...args);\n    const closureService = new OrgUnitClosureService();\n    await closureService.createSelfLink(input.tenantId, orgUnit.id, ...args);\n    if (input.parentOrgUnitId) {\n      await closureService.insertAncestorLinksForNewChild(\n        input.tenantId,\n        input.parentOrgUnitId,\n        orgUnit.id,\n        ...args\n      );\n    }\n    return orgUnit;\n  }\n\n  async listChildren(parentOrgUnitId: string, ...args: any[]): Promise<OrgUnit[]> {\n    return (await this.listAll(...args)).filter((orgUnit) => relationMatch(orgUnit.parent, parentOrgUnitId));\n  }\n\n  async listTenantOrgUnits(tenantId: string, ...args: any[]): Promise<OrgUnit[]> {\n    return (await this.listAll(...args)).filter((orgUnit) => sameTenant(orgUnit.tenant, tenantId));\n  }\n\n  async listDescendantOrgUnits(\n    tenantId: string,\n    orgUnitId: string,\n    includeSelf = false,\n    ...args: any[]\n  ): Promise<OrgUnit[]> {\n    const descendants = await new OrgUnitClosureService().listDescendants(tenantId, orgUnitId, ...args);\n    const ids = new Set(descendants.map((row) => relationId(row.descendant)));\n    if (includeSelf) ids.add(orgUnitId);\n    return (await this.listTenantOrgUnits(tenantId, ...args)).filter((orgUnit) => ids.has(orgUnit.id));\n  }\n\n  async listAncestorOrgUnits(\n    tenantId: string,\n    orgUnitId: string,\n    includeSelf = false,\n    ...args: any[]\n  ): Promise<OrgUnit[]> {\n    const ancestors = await new OrgUnitClosureService().listAncestors(tenantId, orgUnitId, ...args);\n    const ids = new Set(ancestors.map((row) => relationId(row.ancestor)));\n    if (includeSelf) ids.add(orgUnitId);\n    return (await this.listTenantOrgUnits(tenantId, ...args)).filter((orgUnit) => ids.has(orgUnit.id));\n  }\n\n  async renameOrgUnit(orgUnitId: string, name: string, ...args: any[]): Promise<OrgUnit> {\n    const existing = await this.getById(orgUnitId, ...args);\n    return this.updateOne(\n      orgUnitId,\n      { name, path: this.orgUnitPath(existing.path.includes(\"/\") ? existing.path.replace(/\\/[^/]+$/, \"\") : undefined, name) },\n      ...args\n    );\n  }\n\n  @transactional()\n  async moveOrgUnit(\n    tenantId: string,\n    orgUnitId: string,\n    newParentOrgUnitId: string,\n    ...args: any[]\n  ): Promise<OrgUnit> {\n    const newParent = await this.getById(newParentOrgUnitId, ...args);\n    const existing = await this.getById(orgUnitId, ...args);\n    const updated = await this.updateOne(\n      orgUnitId,\n      {\n        parent: newParent.id,\n        path: this.orgUnitPath(newParent.path, existing.name),\n      },\n      ...args\n    );\n    await this.rebuildTenantClosure(tenantId, ...args);\n    return updated;\n  }\n\n  @transactional()\n  async rebuildTenantClosure(tenantId: string, ...args: any[]): Promise<void> {\n    const closureService = new OrgUnitClosureService();\n    const existingLinks = await closureService.listAll(...args);\n    await deleteRowsById(\n      closureService,\n      existingLinks.filter((row) => sameTenant(row.tenant, tenantId)),\n      ...args\n    );\n\n    const orgUnits = (await this.listTenantOrgUnits(tenantId, ...args)).sort((left, right) => {\n      const leftDepth = left.path.split(\"/\").filter(Boolean).length;\n      const rightDepth = right.path.split(\"/\").filter(Boolean).length;\n      return leftDepth - rightDepth;\n    });\n\n    for (const orgUnit of orgUnits) {\n      await closureService.createSelfLink(tenantId, orgUnit.id, ...args);\n      if (orgUnit.parent) {\n        await closureService.insertAncestorLinksForNewChild(\n          tenantId,\n          relationId(orgUnit.parent),\n          orgUnit.id,\n          ...args\n        );\n      }\n    }\n  }\n\n  @transactional()\n  async deleteOrgUnitTree(tenantId: string, orgUnitId: string, ...args: any[]): Promise<void> {\n    const closureService = new OrgUnitClosureService();\n    const descendants = await this.listDescendantOrgUnits(tenantId, orgUnitId, true, ...args);\n    const descendantIds = new Set(descendants.map((orgUnit) => orgUnit.id));\n    const orgUnits = (await this.listTenantOrgUnits(tenantId, ...args)).filter((orgUnit) =>\n      descendantIds.has(orgUnit.id)\n    );\n    await deleteRowsById(this, orgUnits, ...args);\n    await closureService.deleteLinksForSubtree(tenantId, orgUnitId, ...args);\n  }\n}\n","import { BaseModelService } from \"../utils\";\nimport { CreateUserInput } from \"../types\";\nimport { User } from \"../models/user.model\";\n\nexport class UserService extends BaseModelService<User> {\n  constructor() {\n    super(User);\n  }\n\n  async createUser(input: CreateUserInput, ...args: any[]): Promise<User> {\n    return this.create(\n      {\n        email: input.email,\n        phone: input.phone,\n        displayName: input.displayName,\n      },\n      ...args\n    );\n  }\n\n  async getByEmail(email: string, ...args: any[]): Promise<User> {\n    return (await this.listAll(...args)).find((user) => user.email === email) as User;\n  }\n\n  async updateDisplayName(userId: string, displayName: string, ...args: any[]): Promise<User> {\n    return this.updateOne(userId, { displayName }, ...args);\n  }\n\n  async updateEmail(userId: string, email: string | undefined, ...args: any[]): Promise<User> {\n    return this.updateOne(userId, { email }, ...args);\n  }\n\n  async updatePhone(userId: string, phone: string | undefined, ...args: any[]): Promise<User> {\n    return this.updateOne(userId, { phone }, ...args);\n  }\n}\n","import { BaseModelService, sameTenant } from \"../utils\";\nimport { PrincipalKind } from \"../types\";\nimport { Principal } from \"../models/principal.model\";\n\nexport class PrincipalService extends BaseModelService<Principal> {\n  constructor() {\n    super(Principal);\n  }\n\n  async createPrincipal(\n    tenantId: string,\n    kind: PrincipalKind,\n    subjectId: string,\n    ...args: any[]\n  ): Promise<Principal> {\n    return this.create(\n      {\n        tenant: tenantId,\n        kind,\n        subjectId,\n      },\n      ...args\n    );\n  }\n\n  async getForSubject(\n    tenantId: string,\n    kind: PrincipalKind,\n    subjectId: string,\n    ...args: any[]\n  ): Promise<Principal | undefined> {\n    return (await this.listAll(...args)).find(\n      (principal) =>\n        sameTenant(principal.tenant, tenantId) &&\n        principal.kind === kind &&\n        principal.subjectId === subjectId\n    );\n  }\n\n  async getOrCreateForSubject(\n    tenantId: string,\n    kind: PrincipalKind,\n    subjectId: string,\n    ...args: any[]\n  ): Promise<Principal> {\n    return (await this.getForSubject(tenantId, kind, subjectId, ...args)) ?? (await this.createPrincipal(tenantId, kind, subjectId, ...args));\n  }\n\n  async getUserPrincipal(tenantId: string, userId: string, ...args: any[]): Promise<Principal> {\n    return this.getOrCreateForSubject(tenantId, PrincipalKind.User, userId, ...args);\n  }\n\n  async getGroupPrincipal(tenantId: string, groupId: string, ...args: any[]): Promise<Principal> {\n    return this.getOrCreateForSubject(tenantId, PrincipalKind.Group, groupId, ...args);\n  }\n}\n","import { BaseModelService, relationMatch, sameTenant } from \"../utils\";\nimport { MembershipStatus } from \"../types\";\nimport { TenantMembership } from \"../models/tenant-membership.model\";\n\nexport class TenantMembershipService extends BaseModelService<TenantMembership> {\n  constructor() {\n    super(TenantMembership);\n  }\n\n  async addUserToTenant(\n    tenantId: string,\n    userId: string,\n    status: MembershipStatus = MembershipStatus.Active,\n    ...args: any[]\n  ): Promise<TenantMembership> {\n    return this.create(\n      {\n        tenant: tenantId,\n        user: userId,\n        status,\n      },\n      ...args\n    );\n  }\n\n  async setStatus(membershipId: string, status: MembershipStatus, ...args: any[]): Promise<TenantMembership> {\n    return this.updateOne(membershipId, { status }, ...args);\n  }\n\n  async listUserTenants(userId: string, ...args: any[]): Promise<TenantMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => relationMatch(membership.user, userId));\n  }\n\n  async listTenantUsers(tenantId: string, ...args: any[]): Promise<TenantMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => sameTenant(membership.tenant, tenantId));\n  }\n\n  async removeUserFromTenant(membershipId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(membershipId, ...args);\n  }\n}\n","import { BaseModelService, relationMatch } from \"../utils\";\nimport { MembershipStatus } from \"../types\";\nimport { OrgUnitMembership } from \"../models/org-unit-membership.model\";\n\nexport class OrgUnitMembershipService extends BaseModelService<OrgUnitMembership> {\n  constructor() {\n    super(OrgUnitMembership);\n  }\n\n  async addUserToOrgUnit(\n    tenantId: string,\n    orgUnitId: string,\n    userId: string,\n    status: MembershipStatus = MembershipStatus.Active,\n    ...args: any[]\n  ): Promise<OrgUnitMembership> {\n    return this.create(\n      {\n        tenant: tenantId,\n        orgUnit: orgUnitId,\n        user: userId,\n        status,\n      },\n      ...args\n    );\n  }\n\n  async setStatus(membershipId: string, status: MembershipStatus, ...args: any[]): Promise<OrgUnitMembership> {\n    return this.updateOne(membershipId, { status }, ...args);\n  }\n\n  async listUserOrgUnits(userId: string, ...args: any[]): Promise<OrgUnitMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => relationMatch(membership.user, userId));\n  }\n\n  async listOrgUnitUsers(orgUnitId: string, ...args: any[]): Promise<OrgUnitMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => relationMatch(membership.orgUnit, orgUnitId));\n  }\n\n  async removeUserFromOrgUnit(membershipId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(membershipId, ...args);\n  }\n}\n","import { BaseModelService, sameTenant } from \"../utils\";\nimport { Group } from \"../models/group.model\";\n\nexport class GroupService extends BaseModelService<Group> {\n  constructor() {\n    super(Group);\n  }\n\n  async createGroup(\n    tenantId: string,\n    name: string,\n    orgUnitId?: string,\n    metadata?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<Group> {\n    return this.create(\n      {\n        tenant: tenantId,\n        orgUnit: orgUnitId,\n        name,\n        metadata,\n      },\n      ...args\n    );\n  }\n\n  async renameGroup(groupId: string, name: string, ...args: any[]): Promise<Group> {\n    return this.updateOne(groupId, { name }, ...args);\n  }\n\n  async moveGroupToOrgUnit(groupId: string, orgUnitId: string | undefined, ...args: any[]): Promise<Group> {\n    return this.updateOne(groupId, { orgUnit: orgUnitId }, ...args);\n  }\n\n  async listTenantGroups(tenantId: string, ...args: any[]): Promise<Group[]> {\n    return (await this.listAll(...args)).filter((group) => sameTenant(group.tenant, tenantId));\n  }\n}\n","import { BaseModelService, relationId, relationMatch } from \"../utils\";\nimport { GroupMembership } from \"../models/group-membership.model\";\nimport { PrincipalService } from \"./principal.service\";\n\nexport class GroupMembershipService extends BaseModelService<GroupMembership> {\n  constructor() {\n    super(GroupMembership);\n  }\n\n  async addPrincipalToGroup(\n    tenantId: string,\n    groupId: string,\n    principalId: string,\n    metadata?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<GroupMembership> {\n    return this.create(\n      {\n        tenant: tenantId,\n        group: groupId,\n        principal: principalId,\n        metadata,\n      },\n      ...args\n    );\n  }\n\n  async listGroupMembers(groupId: string, ...args: any[]): Promise<GroupMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => relationMatch(membership.group, groupId));\n  }\n\n  async listPrincipalGroups(principalId: string, ...args: any[]): Promise<GroupMembership[]> {\n    return (await this.listAll(...args)).filter((membership) => relationMatch(membership.principal, principalId));\n  }\n\n  async removePrincipalFromGroup(membershipId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(membershipId, ...args);\n  }\n\n  async resolveGroupPrincipalIdsForPrincipal(principalId: string, ...args: any[]): Promise<string[]> {\n    const principalService = new PrincipalService();\n    const memberships = await this.listPrincipalGroups(principalId, ...args);\n    const principals = await Promise.all(\n      memberships.map(async (membership) => {\n        const tenantId = relationId(membership.tenant);\n        const groupId = relationId(membership.group);\n        const principal = await principalService.getGroupPrincipal(tenantId, groupId, ...args);\n        return principal.id;\n      })\n    );\n    return principals;\n  }\n}\n","import { BaseModelService } from \"../utils\";\nimport { PermissionCategory, CreatePermissionInput } from \"../types\";\nimport { Permission } from \"../models/permission.model\";\n\nexport class PermissionService extends BaseModelService<Permission> {\n  constructor() {\n    super(Permission);\n  }\n\n  async createPermission(input: CreatePermissionInput, ...args: any[]): Promise<Permission> {\n    return this.create(\n      {\n        key: input.key,\n        category: input.category,\n        description: input.description,\n      },\n      ...args\n    );\n  }\n\n  async getByKey(key: string, ...args: any[]): Promise<Permission> {\n    return (await this.listAll(...args)).find((permission) => permission.key === key) as Permission;\n  }\n\n  async listByCategory(category: PermissionCategory, ...args: any[]): Promise<Permission[]> {\n    return (await this.listAll(...args)).filter((permission) => permission.category === category);\n  }\n\n  async updateDescription(permissionId: string, description: string | undefined, ...args: any[]): Promise<Permission> {\n    return this.updateOne(permissionId, { description }, ...args);\n  }\n}\n","import { BaseModelService, sameTenant } from \"../utils\";\nimport { CreateRoleInput } from \"../types\";\nimport { Role } from \"../models/role.model\";\n\nexport class RoleService extends BaseModelService<Role> {\n  constructor() {\n    super(Role);\n  }\n\n  async createRole(input: CreateRoleInput, ...args: any[]): Promise<Role> {\n    return this.create(\n      {\n        tenant: input.tenantId,\n        key: input.key,\n        name: input.name,\n        description: input.description,\n        metadata: input.metadata,\n      },\n      ...args\n    );\n  }\n\n  async getSystemRoleByKey(key: string, ...args: any[]): Promise<Role> {\n    const role = (await this.listAll(...args)).find((candidate) => !candidate.tenant && candidate.key === key);\n    if (!role) {\n      throw new Error(`Role \"${key}\" not found`);\n    }\n    return role;\n  }\n\n  async getTenantRoleByKey(tenantId: string, key: string, ...args: any[]): Promise<Role> {\n    const role = (await this.listAll(...args)).find(\n      (candidate) => sameTenant(candidate.tenant, tenantId) && candidate.key === key\n    );\n    if (!role) {\n      throw new Error(`Role \"${key}\" not found for tenant ${tenantId}`);\n    }\n    return role;\n  }\n\n  async renameRole(roleId: string, name: string, ...args: any[]): Promise<Role> {\n    return this.updateOne(roleId, { name }, ...args);\n  }\n\n  async updateRoleMetadata(\n    roleId: string,\n    metadata: Record<string, unknown> | undefined,\n    ...args: any[]\n  ): Promise<Role> {\n    return this.updateOne(roleId, { metadata }, ...args);\n  }\n\n  async listTenantRoles(tenantId: string, includeSystem = false, ...args: any[]): Promise<Role[]> {\n    return (await this.listAll(...args)).filter((role) =>\n      includeSystem ? !role.tenant || sameTenant(role.tenant, tenantId) : sameTenant(role.tenant, tenantId)\n    );\n  }\n}\n","import { BaseModelService, relationMatch } from \"../utils\";\nimport { RolePermission } from \"../models/role-permission.model\";\nimport { PermissionService } from \"./permission.service\";\nimport { RoleService } from \"./role.service\";\n\nasync function deleteRowsById(\n  service: BaseModelService<any>,\n  rows: Array<{ id: string }>,\n  ...args: any[]\n): Promise<void> {\n  for (const row of rows) {\n    await service.deleteById(row.id, ...args);\n  }\n}\n\nexport class RolePermissionService extends BaseModelService<RolePermission> {\n  constructor() {\n    super(RolePermission);\n  }\n\n  async addPermissionToRole(roleId: string, permissionId: string, ...args: any[]): Promise<RolePermission> {\n    return this.create(\n      {\n        role: roleId,\n        permission: permissionId,\n      },\n      ...args\n    );\n  }\n\n  async addPermissionKeyToRole(roleId: string, permissionKey: string, ...args: any[]): Promise<RolePermission> {\n    const permission = await new PermissionService().getByKey(permissionKey, ...args);\n    return this.addPermissionToRole(roleId, permission.id, ...args);\n  }\n\n  async removePermissionFromRole(rolePermissionId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(rolePermissionId, ...args);\n  }\n\n  async listRolePermissions(roleId: string, ...args: any[]): Promise<RolePermission[]> {\n    return (await this.listAll(...args)).filter((rolePermission) => relationMatch(rolePermission.role, roleId));\n  }\n\n  async listPermissionRoles(permissionId: string, ...args: any[]): Promise<RolePermission[]> {\n    return (await this.listAll(...args)).filter((rolePermission) => relationMatch(rolePermission.permission, permissionId));\n  }\n\n  async replaceRolePermissions(roleId: string, permissionIds: string[], ...args: any[]): Promise<RolePermission[]> {\n    const existing = await this.listRolePermissions(roleId, ...args);\n    await deleteRowsById(this, existing, ...args);\n    return Promise.all(permissionIds.map((permissionId) => this.addPermissionToRole(roleId, permissionId, ...args)));\n  }\n\n  async createRoleWithPermissions(\n    input: import(\"../types\").CreateRoleInput,\n    permissionKeys: string[],\n    ...args: any[]\n  ): Promise<import(\"../models/role.model\").Role> {\n    const role = await new RoleService().createRole(input, ...args);\n    for (const permissionKey of permissionKeys) {\n      await this.addPermissionKeyToRole(role.id, permissionKey, ...args);\n    }\n    return role;\n  }\n}\n","import { BaseModelService, relationMatch, sameTenant } from \"../utils\";\nimport { AssignRoleInput, ScopeKind } from \"../types\";\nimport { RoleAssignment } from \"../models/role-assignment.model\";\n\nexport class RoleAssignmentService extends BaseModelService<RoleAssignment> {\n  constructor() {\n    super(RoleAssignment);\n  }\n\n  async assignRole(input: AssignRoleInput, ...args: any[]): Promise<RoleAssignment> {\n    return this.create(\n      {\n        tenant: input.tenantId,\n        principal: input.principalId,\n        role: input.roleId,\n        scopeKind: input.scopeKind,\n        scopeId: input.scopeId,\n        inheritDown: input.inheritDown ?? false,\n        startsAt: input.startsAt,\n        expiresAt: input.expiresAt,\n        conditions: input.conditions,\n      },\n      ...args\n    );\n  }\n\n  async revokeAssignment(assignmentId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(assignmentId, ...args);\n  }\n\n  async listPrincipalAssignments(tenantId: string, principalId: string, ...args: any[]): Promise<RoleAssignment[]> {\n    return (await this.listAll(...args)).filter(\n      (assignment) => sameTenant(assignment.tenant, tenantId) && relationMatch(assignment.principal, principalId)\n    );\n  }\n\n  async listRoleAssignments(roleId: string, ...args: any[]): Promise<RoleAssignment[]> {\n    return (await this.listAll(...args)).filter((assignment) => relationMatch(assignment.role, roleId));\n  }\n\n  async listTenantAssignments(tenantId: string, ...args: any[]): Promise<RoleAssignment[]> {\n    return (await this.listAll(...args)).filter((assignment) => sameTenant(assignment.tenant, tenantId));\n  }\n\n  async updateAssignmentWindow(\n    assignmentId: string,\n    startsAt: Date | undefined,\n    expiresAt: Date | undefined,\n    ...args: any[]\n  ): Promise<RoleAssignment> {\n    return this.updateOne(assignmentId, { startsAt, expiresAt }, ...args);\n  }\n}\n","import { BaseModelService, relationId, relationMatch, sameTenant, transactional } from \"../utils\";\nimport { EffectivePermissionSnapshot, ScopeKind } from \"../types\";\nimport { EffectivePermission } from \"../models/effective-permission.model\";\nimport { RoleAssignmentService } from \"./role-assignment.service\";\nimport { RolePermissionService } from \"./role-permission.service\";\nimport { PermissionService } from \"./permission.service\";\nimport { GroupMembershipService } from \"./group-membership.service\";\nimport { PrincipalService } from \"./principal.service\";\nimport { OrgUnitClosureService } from \"./org-unit-closure.service\";\nimport { InheritanceBlockService } from \"./inheritance-block.service\";\n\nexport class EffectivePermissionService extends BaseModelService<EffectivePermission> {\n  constructor() {\n    super(EffectivePermission);\n  }\n\n  async listForPrincipal(tenantId: string, principalId: string, ...args: any[]): Promise<EffectivePermission[]> {\n    return (await this.listAll(...args)).filter(\n      (permission) => sameTenant(permission.tenant, tenantId) && relationMatch(permission.principal, principalId)\n    );\n  }\n\n  async listForScope(\n    tenantId: string,\n    scopeKind: ScopeKind,\n    scopeId: string,\n    ...args: any[]\n  ): Promise<EffectivePermission[]> {\n    return (await this.listAll(...args)).filter(\n      (permission) => sameTenant(permission.tenant, tenantId) && permission.scopeKind === scopeKind && permission.scopeId === scopeId\n    );\n  }\n\n  async hasPermission(\n    tenantId: string,\n    principalId: string,\n    permissionKey: string,\n    scopeKind: ScopeKind,\n    scopeId: string,\n    at?: Date,\n    ...args: any[]\n  ): Promise<boolean> {\n    return (await this.listForPrincipal(tenantId, principalId, ...args)).some(\n      (permission) =>\n        permission.permissionKey === permissionKey &&\n        permission.scopeKind === scopeKind &&\n        permission.scopeId === scopeId &&\n        (!permission.startsAt || !at || permission.startsAt <= at) &&\n        (!permission.expiresAt || !at || permission.expiresAt >= at)\n    );\n  }\n\n  async deleteForPrincipal(tenantId: string, principalId: string, ...args: any[]): Promise<void> {\n    for (const row of await this.listForPrincipal(tenantId, principalId, ...args)) {\n      await this.deleteById(row.id, ...args);\n    }\n  }\n\n  async deleteForTenant(tenantId: string, ...args: any[]): Promise<void> {\n    for (const row of (await this.listAll(...args)).filter((permission) => sameTenant(permission.tenant, tenantId))) {\n      await this.deleteById(row.id, ...args);\n    }\n  }\n\n  @transactional()\n  async rebuildForPrincipal(tenantId: string, principalId: string, ...args: any[]): Promise<EffectivePermission[]> {\n    await this.deleteForPrincipal(tenantId, principalId, ...args);\n\n    const roleAssignmentService = new RoleAssignmentService();\n    const rolePermissionService = new RolePermissionService();\n    const permissionService = new PermissionService();\n    const groupMembershipService = new GroupMembershipService();\n    const principalService = new PrincipalService();\n    const orgUnitClosureService = new OrgUnitClosureService();\n    const inheritanceBlockService = new InheritanceBlockService();\n\n    const materialized: EffectivePermissionSnapshot[] = [];\n    const sourceAssignments = await roleAssignmentService.listPrincipalAssignments(tenantId, principalId, ...args);\n    const groupMemberships = await groupMembershipService.listPrincipalGroups(principalId, ...args);\n    const groupAssignments = (\n      await Promise.all(\n        groupMemberships.map(async (membership) => {\n          const groupPrincipal = await principalService.getGroupPrincipal(relationId(membership.tenant), relationId(membership.group), ...args);\n          return roleAssignmentService.listPrincipalAssignments(tenantId, groupPrincipal.id, ...args);\n        })\n      )\n    ).flat();\n\n    const assignments = [...sourceAssignments, ...groupAssignments];\n    for (const assignment of assignments) {\n      const rolePermissions = await rolePermissionService.listRolePermissions(relationId(assignment.role), ...args);\n      const permissions = await Promise.all(\n        rolePermissions.map(async (rolePermission) =>\n          permissionService.findOneBy(\"id\", relationId(rolePermission.permission) as never, ...args)\n        )\n      );\n      for (const permission of permissions) {\n        if (!permission) continue;\n        const scopeKind = assignment.scopeKind;\n        const scopeId = assignment.scopeId;\n        const scopes: Array<{ scopeKind: ScopeKind; scopeId: string }> = [];\n        if (scopeKind === ScopeKind.Tenant) {\n          scopes.push({ scopeKind, scopeId: tenantId });\n        } else if (scopeKind === ScopeKind.Resource) {\n          scopes.push({ scopeKind, scopeId });\n        } else if (scopeKind === ScopeKind.OrgUnit && !assignment.inheritDown) {\n          scopes.push({ scopeKind, scopeId });\n        } else if (scopeKind === ScopeKind.OrgUnit && assignment.inheritDown) {\n          const descendants = await orgUnitClosureService.listDescendants(tenantId, scopeId, ...args);\n          scopes.push(...descendants.map((row) => ({ scopeKind, scopeId: relationId(row.descendant) })));\n        }\n\n        for (const scoped of scopes) {\n          if (\n            scopeKind === ScopeKind.OrgUnit &&\n            assignment.inheritDown &&\n            scoped.scopeId !== scopeId &&\n            (await inheritanceBlockService.categoryBlockedForAncestor(\n              tenantId,\n              scoped.scopeId,\n              scopeId,\n              permission.category,\n              ...args\n            ))\n          ) {\n            continue;\n          }\n          materialized.push({\n            id: \"\",\n            tenantId,\n            principalId,\n            permissionKey: permission.key,\n            scopeKind: scoped.scopeKind,\n            scopeId: scoped.scopeId,\n            sourceKind: \"role_assignment\",\n            sourceId: assignment.id,\n            startsAt: assignment.startsAt,\n            expiresAt: assignment.expiresAt,\n          });\n        }\n      }\n    }\n\n    const created = await Promise.all(\n      materialized.map((permission) =>\n        this.create(\n          {\n            tenant: permission.tenantId,\n            principal: permission.principalId,\n            permissionKey: permission.permissionKey,\n            scopeKind: permission.scopeKind,\n            scopeId: permission.scopeId,\n            sourceKind: permission.sourceKind,\n            sourceId: permission.sourceId,\n            startsAt: permission.startsAt,\n            expiresAt: permission.expiresAt,\n          },\n          ...args\n        )\n      )\n    );\n    return created;\n  }\n\n  @transactional()\n  async rebuildForTenant(tenantId: string, ...args: any[]): Promise<void> {\n    const principals = (await new PrincipalService().listAll(...args)).filter((principal) => sameTenant(principal.tenant, tenantId));\n    for (const principal of principals) {\n      await this.rebuildForPrincipal(tenantId, principal.id, ...args);\n    }\n  }\n}\n","import { BaseModelService, relationMatch, sameTenant } from \"../utils\";\nimport { RegisterResourceInput, ResourceVisibility } from \"../types\";\nimport { ProtectedResource } from \"../models/protected-resource.model\";\n\nexport class ProtectedResourceService extends BaseModelService<ProtectedResource> {\n  constructor() {\n    super(ProtectedResource);\n  }\n\n  async registerResource(input: RegisterResourceInput, ...args: any[]): Promise<ProtectedResource> {\n    return this.create(\n      {\n        tenant: input.tenantId,\n        orgUnit: input.orgUnitId,\n        resourceType: input.resourceType,\n        resourceId: input.resourceId,\n        visibility: input.visibility,\n        owner: input.ownerPrincipalId,\n        sensitivity: input.sensitivity,\n        metadata: input.metadata,\n      },\n      ...args\n    );\n  }\n\n  async getByDomainResource(tenantId: string, resourceType: string, resourceId: string, ...args: any[]): Promise<ProtectedResource | undefined> {\n    return (await this.listAll(...args)).find(\n      (resource) => sameTenant(resource.tenant, tenantId) && resource.resourceType === resourceType && resource.resourceId === resourceId\n    );\n  }\n\n  async moveResourceToOrgUnit(protectedResourceId: string, orgUnitId: string, ...args: any[]): Promise<ProtectedResource> {\n    return this.updateOne(protectedResourceId, { orgUnit: orgUnitId }, ...args);\n  }\n\n  async setVisibility(protectedResourceId: string, visibility: ResourceVisibility, ...args: any[]): Promise<ProtectedResource> {\n    return this.updateOne(protectedResourceId, { visibility }, ...args);\n  }\n\n  async transferOwnership(protectedResourceId: string, ownerPrincipalId: string | undefined, ...args: any[]): Promise<ProtectedResource> {\n    return this.updateOne(protectedResourceId, { owner: ownerPrincipalId }, ...args);\n  }\n\n  async listOrgUnitResources(orgUnitId: string, ...args: any[]): Promise<ProtectedResource[]> {\n    return (await this.listAll(...args)).filter((resource) => relationMatch(resource.orgUnit, orgUnitId));\n  }\n\n  async listTenantResources(tenantId: string, ...args: any[]): Promise<ProtectedResource[]> {\n    return (await this.listAll(...args)).filter((resource) => sameTenant(resource.tenant, tenantId));\n  }\n}\n","import { BaseModelService, relationMatch, sameTenant } from \"../utils\";\nimport { GrantResourceInput } from \"../types\";\nimport { ResourceGrant } from \"../models/resource-grant.model\";\n\nexport class ResourceGrantService extends BaseModelService<ResourceGrant> {\n  constructor() {\n    super(ResourceGrant);\n  }\n\n  async grantResource(input: GrantResourceInput, ...args: any[]): Promise<ResourceGrant> {\n    return this.create(\n      {\n        tenant: input.tenantId,\n        resource: input.resourceId,\n        principal: input.principalId,\n        permissionKey: input.permissionKey,\n        startsAt: input.startsAt,\n        expiresAt: input.expiresAt,\n        conditions: input.conditions,\n        createdBy: input.createdByPrincipalId,\n      },\n      ...args\n    );\n  }\n\n  async revokeGrant(grantId: string, ...args: any[]): Promise<void> {\n    await this.deleteById(grantId, ...args);\n  }\n\n  async listResourceGrants(protectedResourceId: string, ...args: any[]): Promise<ResourceGrant[]> {\n    return (await this.listAll(...args)).filter((grant) => relationMatch(grant.resource, protectedResourceId));\n  }\n\n  async listPrincipalGrants(tenantId: string, principalId: string, ...args: any[]): Promise<ResourceGrant[]> {\n    return (await this.listAll(...args)).filter(\n      (grant) => sameTenant(grant.tenant, tenantId) && relationMatch(grant.principal, principalId)\n    );\n  }\n\n  async hasGrant(\n    tenantId: string,\n    principalId: string,\n    protectedResourceId: string,\n    permissionKey: string,\n    at?: Date,\n    ...args: any[]\n  ): Promise<boolean> {\n    return (await this.listPrincipalGrants(tenantId, principalId, ...args)).some(\n      (grant) =>\n        relationMatch(grant.resource, protectedResourceId) &&\n        grant.permissionKey === permissionKey &&\n        (!grant.startsAt || !at || grant.startsAt <= at) &&\n        (!grant.expiresAt || !at || grant.expiresAt >= at)\n    );\n  }\n\n  async deleteAllForResource(protectedResourceId: string, ...args: any[]): Promise<void> {\n    for (const row of await this.listResourceGrants(protectedResourceId, ...args)) {\n      await this.deleteById(row.id, ...args);\n    }\n  }\n}\n","import { ProtectedResourceService } from \"./protected-resource.service\";\nimport { ResourceGrantService } from \"./resource-grant.service\";\nimport { relationId } from \"../utils\";\nimport { ResourceVisibility } from \"../types\";\n\nexport class ResourceLifecycleService {\n  async unregisterResource(protectedResourceId: string, ...args: any[]): Promise<void> {\n    await new ResourceGrantService().deleteAllForResource(protectedResourceId, ...args);\n    await new ProtectedResourceService().deleteById(protectedResourceId, ...args);\n  }\n\n  async resolveResourceScope(\n    protectedResourceId: string,\n    ...args: any[]\n  ): Promise<{\n    tenantId: string;\n    orgUnitId: string;\n    visibility: ResourceVisibility;\n    ownerPrincipalId?: string;\n  }> {\n    const resource = await new ProtectedResourceService().getById(protectedResourceId, ...args);\n    return {\n      tenantId: relationId(resource.tenant),\n      orgUnitId: relationId(resource.orgUnit),\n      visibility: resource.visibility,\n      ownerPrincipalId: resource.owner ? relationId(resource.owner) : undefined,\n    };\n  }\n}\n","import { BaseModelService, relationId } from \"../utils\";\nimport { CreateStorageBindingInput, StorageBindingKind, StorageKind } from \"../types\";\nimport { StorageBinding } from \"../models/storage-binding.model\";\n\nexport class StorageBindingService extends BaseModelService<StorageBinding> {\n  constructor() {\n    super(StorageBinding);\n  }\n\n  async createBinding(input: CreateStorageBindingInput, ...args: any[]): Promise<StorageBinding> {\n    return this.create(\n      {\n        tenant: input.tenantId,\n        storageKind: input.storageKind,\n        bindingKind: input.bindingKind,\n        bindingKey: input.bindingKey,\n        region: input.region,\n        config: input.config,\n      },\n      ...args\n    );\n  }\n\n  async listTenantBindings(tenantId: string, ...args: any[]): Promise<StorageBinding[]> {\n    return (await this.listAll(...args)).filter((binding) => relationId(binding.tenant) === tenantId);\n  }\n\n  async getBinding(tenantId: string, storageKind: StorageKind, ...args: any[]): Promise<StorageBinding | undefined> {\n    return (await this.listTenantBindings(tenantId, ...args)).find((binding) => binding.storageKind === storageKind);\n  }\n\n  async setBindingConfig(\n    bindingId: string,\n    config: Record<string, unknown> | undefined,\n    ...args: any[]\n  ): Promise<StorageBinding> {\n    return this.updateOne(bindingId, { config }, ...args);\n  }\n\n  async promoteToDedicated(\n    bindingId: string,\n    bindingKey: string,\n    region: string,\n    config?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<StorageBinding> {\n    return this.updateOne(bindingId, { bindingKind: StorageBindingKind.Dedicated, bindingKey, region, config }, ...args);\n  }\n\n  async setShared(\n    bindingId: string,\n    bindingKey: string,\n    region: string,\n    config?: Record<string, unknown>,\n    ...args: any[]\n  ): Promise<StorageBinding> {\n    return this.updateOne(bindingId, { bindingKind: StorageBindingKind.Shared, bindingKey, region, config }, ...args);\n  }\n}\n","import { transactional } from \"../utils\";\nimport type {\n  BootstrapOrgUnit,\n  BootstrapTemplate,\n} from \"../types\";\nimport { MembershipStatus, ScopeKind } from \"../types\";\nimport { TenantService } from \"./tenant.service\";\nimport { TenantProfileService } from \"./tenant-profile.service\";\nimport { OrgUnitService } from \"./org-unit.service\";\nimport { OrgUnitProfileService } from \"./org-unit-profile.service\";\nimport { UserService } from \"./user.service\";\nimport { TenantMembershipService } from \"./tenant-membership.service\";\nimport { PrincipalService } from \"./principal.service\";\nimport { PermissionService } from \"./permission.service\";\nimport { RoleService } from \"./role.service\";\nimport { RolePermissionService } from \"./role-permission.service\";\nimport { RoleAssignmentService } from \"./role-assignment.service\";\nimport { EffectivePermissionService } from \"./effective-permission.service\";\nimport { relationId } from \"../utils\";\n\nexport class BootstrapService {\n  private tenantService = new TenantService();\n  private tenantProfileService = new TenantProfileService();\n  private orgUnitService = new OrgUnitService();\n  private orgUnitProfileService = new OrgUnitProfileService();\n  private userService = new UserService();\n  private membershipService = new TenantMembershipService();\n  private principalService = new PrincipalService();\n  private permissionService = new PermissionService();\n  private roleService = new RoleService();\n  private rolePermissionService = new RolePermissionService();\n  private roleAssignmentService = new RoleAssignmentService();\n  private effectivePermissionService = new EffectivePermissionService();\n\n  @transactional()\n  async bootstrapTenantFromTemplate(\n    template: BootstrapTemplate,\n    ...args: any[]\n  ): Promise<{ tenantId: string; rootOrgUnitId: string; ownerUserId: string; ownerPrincipalId: string }> {\n    const tenant = await this.tenantService.createTenant(template.tenant, ...args);\n    if (template.tenant.profileKey) {\n      await this.tenantProfileService.createProfile(tenant.id, template.tenant.profileKey, template.tenant.profileMetadata, ...args);\n    }\n\n    const createOrgTree = async (parentId: string | undefined, orgUnit: BootstrapOrgUnit) => {\n      const created =\n        parentId === undefined\n          ? await this.orgUnitService.createRoot(tenant.id, orgUnit.name, orgUnit.metadata, orgUnit.profileKey, orgUnit.metadata, ...args)\n          : await this.orgUnitService.createChild(\n              {\n                tenantId: tenant.id,\n                parentOrgUnitId: parentId,\n                name: orgUnit.name,\n                metadata: orgUnit.metadata,\n                profileKey: orgUnit.profileKey,\n                profileMetadata: orgUnit.metadata,\n              },\n              ...args\n            );\n      for (const child of orgUnit.children ?? []) {\n        await createOrgTree(created.id, child);\n      }\n      return created;\n    };\n\n    const rootOrgUnit = await createOrgTree(undefined, template.rootOrgUnit);\n    const owner = await this.userService.createUser(template.ownerUser, ...args);\n    await this.membershipService.addUserToTenant(tenant.id, owner.id, MembershipStatus.Active, ...args);\n    const ownerPrincipal = await this.principalService.getUserPrincipal(tenant.id, owner.id, ...args);\n\n    for (const permission of template.permissions) {\n      await this.permissionService.createPermission(permission, ...args);\n    }\n    for (const role of template.roles) {\n      const createdRole = await this.roleService.createRole(\n        {\n          tenantId: tenant.id,\n          key: role.key,\n          name: role.name,\n          description: role.description,\n        },\n        ...args\n      );\n      for (const permissionKey of role.permissionKeys) {\n        await this.rolePermissionService.addPermissionKeyToRole(createdRole.id, permissionKey, ...args);\n      }\n    }\n\n    const ownerRole = await this.roleService.getTenantRoleByKey(tenant.id, template.ownerRoleKey, ...args);\n    await this.roleAssignmentService.assignRole(\n      {\n        tenantId: tenant.id,\n        principalId: ownerPrincipal.id,\n        roleId: ownerRole.id,\n        scopeKind: ScopeKind.OrgUnit,\n        scopeId: rootOrgUnit.id,\n        inheritDown: true,\n      },\n      ...args\n    );\n    await this.effectivePermissionService.rebuildForPrincipal(tenant.id, ownerPrincipal.id, ...args);\n\n    return {\n      tenantId: tenant.id,\n      rootOrgUnitId: rootOrgUnit.id,\n      ownerUserId: owner.id,\n      ownerPrincipalId: ownerPrincipal.id,\n    };\n  }\n}\n","import { transactional } from \"../utils\";\nimport { MembershipStatus, ScopeKind } from \"../types\";\nimport { TenantMembershipService } from \"./tenant-membership.service\";\nimport { OrgUnitMembershipService } from \"./org-unit-membership.service\";\nimport { PrincipalService } from \"./principal.service\";\nimport { RoleService } from \"./role.service\";\nimport { RoleAssignmentService } from \"./role-assignment.service\";\nimport { EffectivePermissionService } from \"./effective-permission.service\";\n\nexport class SystemManagementService {\n  private membershipService = new TenantMembershipService();\n  private orgMembershipService = new OrgUnitMembershipService();\n  private principalService = new PrincipalService();\n  private roleService = new RoleService();\n  private roleAssignmentService = new RoleAssignmentService();\n  private effectivePermissionService = new EffectivePermissionService();\n\n  @transactional()\n  async onboardUserToTenantAndOrgUnit(\n    tenantId: string,\n    userId: string,\n    orgUnitId: string,\n    roleKey: string,\n    ...args: any[]\n  ): Promise<{ principalId: string }> {\n    await this.membershipService.addUserToTenant(tenantId, userId, MembershipStatus.Active, ...args);\n    await this.orgMembershipService.addUserToOrgUnit(tenantId, orgUnitId, userId, MembershipStatus.Active, ...args);\n    const principal = await this.principalService.getUserPrincipal(tenantId, userId, ...args);\n    const role = await this.roleService.getTenantRoleByKey(tenantId, roleKey, ...args);\n    await this.roleAssignmentService.assignRole(\n      {\n        tenantId,\n        principalId: principal.id,\n        roleId: role.id,\n        scopeKind: ScopeKind.OrgUnit,\n        scopeId: orgUnitId,\n        inheritDown: true,\n      },\n      ...args\n    );\n    await this.effectivePermissionService.rebuildForPrincipal(tenantId, principal.id, ...args);\n    return { principalId: principal.id };\n  }\n\n  @transactional()\n  async changeUserOrgRole(\n    tenantId: string,\n    principalId: string,\n    orgUnitId: string,\n    roleKey: string,\n    inheritDown: boolean,\n    ...args: any[]\n  ): Promise<void> {\n    const role = await this.roleService.getTenantRoleByKey(tenantId, roleKey, ...args);\n    const currentAssignments = await this.roleAssignmentService.listPrincipalAssignments(tenantId, principalId, ...args);\n    for (const assignment of currentAssignments.filter((row) => row.scopeKind === ScopeKind.OrgUnit && row.scopeId === orgUnitId)) {\n      await this.roleAssignmentService.revokeAssignment(assignment.id, ...args);\n    }\n    await this.roleAssignmentService.assignRole(\n      {\n        tenantId,\n        principalId,\n        roleId: role.id,\n        scopeKind: ScopeKind.OrgUnit,\n        scopeId: orgUnitId,\n        inheritDown,\n      },\n      ...args\n    );\n    await this.effectivePermissionService.rebuildForPrincipal(tenantId, principalId, ...args);\n  }\n\n  @transactional()\n  async suspendUserInTenant(tenantMembershipId: string, tenantId: string, principalId: string, ...args: any[]): Promise<void> {\n    await this.membershipService.setStatus(tenantMembershipId, MembershipStatus.Suspended, ...args);\n    await this.effectivePermissionService.deleteForPrincipal(tenantId, principalId, ...args);\n  }\n\n  @transactional()\n  async reactivateUserInTenant(tenantMembershipId: string, tenantId: string, principalId: string, ...args: any[]): Promise<void> {\n    await this.membershipService.setStatus(tenantMembershipId, MembershipStatus.Active, ...args);\n    await this.effectivePermissionService.rebuildForPrincipal(tenantId, principalId, ...args);\n  }\n}\n","import { AuthorizationError } from \"@decaf-ts/core\";\nimport { AuthzDataSources, CanAccessInput, ResourceVisibility, ScopeKind } from \"../types\";\nimport { asArray, buildAccessContext, buildArangoContext, buildQdrantFilter, isTimeValid, relationId } from \"../utils\";\n\nfunction scopeKey(scopeKind: ScopeKind, scopeId: string): string {\n  return `${scopeKind}:${scopeId}`;\n}\n\nexport class AuthzService {\n  private readonly dataSources: AuthzDataSources;\n\n  constructor(dataSources: AuthzDataSources = {}) {\n    this.dataSources = dataSources;\n  }\n\n  async canAccess(input: CanAccessInput, ...args: any[]): Promise<boolean> {\n    const at = input.at ?? new Date();\n\n    if (input.scopeKind && input.scopeId) {\n      const permissions = await this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, input.scopeKind, input.scopeId);\n      return asArray(permissions).some(\n        (permission) => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt)\n      );\n    }\n\n    if (!input.resourceProtectedId) return false;\n\n    const resource = await this.dataSources.loadResource?.(input.tenantId, input.resourceProtectedId);\n    if (!resource) return false;\n    if (resource.tenantId !== input.tenantId) return false;\n\n    if (resource.ownerPrincipalId === input.principalId) return true;\n\n    const grants = asArray(await this.dataSources.listResourceGrants?.(input.tenantId, input.resourceProtectedId)).filter(\n      (grant) => grant.principalId === input.principalId && grant.permissionKey === input.permissionKey && isTimeValid(at, grant.startsAt, grant.expiresAt)\n    );\n    if (grants.length > 0) return true;\n\n    const visibility = resource.visibility;\n    if (visibility === ResourceVisibility.Private || visibility === ResourceVisibility.ResourceAcl) {\n      return false;\n    }\n\n    if (visibility === ResourceVisibility.OrgUnit || visibility === ResourceVisibility.OrgSubtree) {\n      const effectivePermissions = asArray(\n        await this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, ScopeKind.OrgUnit, resource.orgUnitId)\n      );\n      return effectivePermissions.some(\n        (permission) => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt)\n      );\n    }\n\n    if (visibility === ResourceVisibility.Tenant) {\n      const effectivePermissions = asArray(\n        await this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, ScopeKind.Tenant, input.tenantId)\n      );\n      return effectivePermissions.some(\n        (permission) => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt)\n      );\n    }\n\n    return false;\n  }\n\n  async requireAccess(input: CanAccessInput, ...args: any[]): Promise<void> {\n    if (!(await this.canAccess(input, ...args))) {\n      throw new AuthorizationError(\n        `Access denied for ${input.permissionKey} on ${input.resourceProtectedId ?? scopeKey(input.scopeKind ?? ScopeKind.Resource, input.scopeId ?? \"\")}`\n      );\n    }\n  }\n\n  async buildAccessContext(tenantId: string, principalId: string, ...args: any[]): Promise<import(\"../types\").AccessContext> {\n    const permissions = asArray(await this.dataSources.listEffectivePermissions?.(tenantId, principalId));\n    const grants = asArray(await this.dataSources.listPrincipalGrants?.(tenantId, principalId));\n    return buildAccessContext({\n      tenantId,\n      principalId,\n      permissions,\n      grants,\n    });\n  }\n\n  async buildArangoContext(tenantId: string, principalId: string, permissionKey: string, ...args: any[]) {\n    const access = await this.buildAccessContext(tenantId, principalId, ...args);\n    const allowedOrgUnitIds = access.allowedOrgUnitIdsByPermission[permissionKey] ?? [];\n    const allowedResourceIds = access.resourceGrants.filter((grant) => grant.permissionKey === permissionKey).map((grant) => grant.resourceId);\n    return buildArangoContext({ tenantId, principalId, permissionKey, allowedOrgUnitIds, allowedResourceIds });\n  }\n\n  async buildQdrantFilter(tenantId: string, principalId: string, permissionKey: string, ...args: any[]) {\n    const access = await this.buildAccessContext(tenantId, principalId, ...args);\n    const allowedOrgUnitIds = access.allowedOrgUnitIdsByPermission[permissionKey] ?? [];\n    const allowedResourceIds = access.resourceGrants.filter((grant) => grant.permissionKey === permissionKey).map((grant) => grant.resourceId);\n    return buildQdrantFilter({ tenantId, principalId, permissionKey, allowedOrgUnitIds, allowedResourceIds });\n  }\n}\n","/**\n * @module integrations\n * @summary Package entry point for shared integration helpers.\n * @description Exposes the package utilities and build-time version metadata for `@decaf-ts/integrations`.\n */\nexport * from \"./utils\";\nexport * from \"./namespaces\";\n\nexport const VERSION: string = \"##VERSION##\";\n\nexport const COMMIT = \"##COMMIT##\";\n\nexport const FULL_VERSION = \"##FULL_VERSION##\";\n\nexport const PACKAGE_NAME: string = \"##PACKAGE##\";\n"],"names":["async","execWithLogging","command","options","log","level","LogLevel","info","debug","Promise","resolve","reject","child","exec","stdout","stderr","on","data","push","trim","code","silly","join","critical","InternalError","err","IsolationTier","MembershipStatus","PrincipalKind","ScopeKind","PermissionCategory","ResourceVisibility","StorageKind","StorageBindingKind","IsolationTierOptions","Object","values","MembershipStatusOptions","PrincipalKindOptions","ScopeKindOptions","PermissionCategoryOptions","ResourceVisibilityOptions","StorageKindOptions","StorageBindingKindOptions","REL_RESTRICT","update","Cascade","NONE","delete","nullable","REL_NULLIFY","REL_CASCADE_DEPENDENT","CASCADE","REL_CASCADE_INSERT_UPDATE","buildArangoContext","tenantId","principalId","permissionKey","allowedOrgUnitIds","allowedResourceIds","buildQdrantFilter","must","key","match","value","should","any","scopeKey","scopeKind","scopeId","nowIso","Date","asArray","sameTenant","rowTenant","relationId","relationMatch","target","lowerSlug","toLowerCase","replace","isTimeValid","at","startsAt","expiresAt","instant","buildAccessContext","permissionsByScope","allowedOrgUnitIdsByPermission","permission","permissions","OrgUnit","resourceGrants","grants","map","grant","resourceId","BaseModelService","ModelService","constructor","clazz","super","newModel","assign","create","args","this","repo","createOne","getById","id","read","updateOne","patch","existing","deleteById","findOneBy","findManyBy","select","where","execute","listAll","crypto","randomUUID","AuthorizationModel","Model","TenantMembership","__decorate","pk","type","String","uuid","prototype","manyToOne","Tenant","undefined","required","User","typeOf","option","column","createdAt","updatedAt","table","model","unique","oneToMany","OrgUnitMembership","OrgUnitClosure","Number","Permission","RolePermission","Role","RoleAssignment","Principal","Boolean","ResourceGrant","ProtectedResource","InheritanceBlock","StorageBinding","TenantProfile","OrgUnitProfile","GroupMembership","Group","EffectivePermission","TenantProfileService","createProfile","profileKey","metadata","tenant","listForTenant","filter","profile","deleteForTenant","row","OrgUnitProfileService","orgUnitId","orgUnit","listForOrgUnit","OrgUnitClosureService","listAncestors","descendant","sort","left","right","depth","listDescendants","ancestor","isAncestorOf","ancestorOrgUnitId","descendantOrgUnitId","some","createSelfLink","insertAncestorLinksForNewChild","parentOrgUnitId","childOrgUnitId","ancestorLinks","link","deleteLinksForSubtree","subtree","descendantIds","Set","ancestorIds","rows","has","InheritanceBlockService","blockCategory","permissionCategory","blockedFromAncestorId","reason","blockedFromAncestor","unblockCategory","blockId","block","categoryBlockedForAncestor","category","TenantService","createTenant","input","slug","name","isolationTier","Pooled","getBySlug","renameTenant","changeSlug","setIsolationTier","deleteTenantControlled","deleteRowsById","service","OrgUnitService","orgUnitPath","parentPath","segment","createProfileIfNeeded","profileMetadata","createRoot","path","createChild","parent","closureService","listChildren","listTenantOrgUnits","listDescendantOrgUnits","includeSelf","descendants","ids","add","listAncestorOrgUnits","ancestors","renameOrgUnit","includes","moveOrgUnit","newParentOrgUnitId","newParent","updated","rebuildTenantClosure","existingLinks","orgUnits","leftDepth","split","length","rightDepth","deleteOrgUnitTree","transactional","UserService","createUser","email","phone","displayName","getByEmail","find","user","updateDisplayName","userId","updateEmail","updatePhone","PrincipalService","createPrincipal","kind","subjectId","getForSubject","principal","getOrCreateForSubject","getUserPrincipal","getGroupPrincipal","groupId","TenantMembershipService","addUserToTenant","status","Active","setStatus","membershipId","listUserTenants","membership","listTenantUsers","removeUserFromTenant","OrgUnitMembershipService","addUserToOrgUnit","listUserOrgUnits","listOrgUnitUsers","removeUserFromOrgUnit","GroupService","createGroup","renameGroup","moveGroupToOrgUnit","listTenantGroups","group","GroupMembershipService","addPrincipalToGroup","listGroupMembers","listPrincipalGroups","removePrincipalFromGroup","resolveGroupPrincipalIdsForPrincipal","principalService","memberships","principals","all","PermissionService","createPermission","description","getByKey","listByCategory","updateDescription","permissionId","RoleService","createRole","getSystemRoleByKey","role","candidate","Error","getTenantRoleByKey","renameRole","roleId","updateRoleMetadata","listTenantRoles","includeSystem","RolePermissionService","addPermissionToRole","addPermissionKeyToRole","removePermissionFromRole","rolePermissionId","listRolePermissions","rolePermission","listPermissionRoles","replaceRolePermissions","permissionIds","createRoleWithPermissions","permissionKeys","RoleAssignmentService","assignRole","inheritDown","conditions","revokeAssignment","assignmentId","listPrincipalAssignments","assignment","listRoleAssignments","listTenantAssignments","updateAssignmentWindow","EffectivePermissionService","listForPrincipal","listForScope","hasPermission","deleteForPrincipal","rebuildForPrincipal","roleAssignmentService","rolePermissionService","permissionService","groupMembershipService","orgUnitClosureService","inheritanceBlockService","materialized","sourceAssignments","groupMemberships","groupAssignments","groupPrincipal","flat","assignments","rolePermissions","scopes","Resource","scoped","sourceKind","sourceId","created","rebuildForTenant","ProtectedResourceService","registerResource","resourceType","visibility","owner","ownerPrincipalId","sensitivity","getByDomainResource","resource","moveResourceToOrgUnit","protectedResourceId","setVisibility","transferOwnership","listOrgUnitResources","listTenantResources","ResourceGrantService","grantResource","createdBy","createdByPrincipalId","revokeGrant","grantId","listResourceGrants","listPrincipalGrants","hasGrant","deleteAllForResource","ResourceLifecycleService","unregisterResource","resolveResourceScope","StorageBindingService","createBinding","storageKind","bindingKind","bindingKey","region","config","listTenantBindings","binding","getBinding","setBindingConfig","bindingId","promoteToDedicated","Dedicated","setShared","Shared","BootstrapService","tenantService","tenantProfileService","orgUnitService","orgUnitProfileService","userService","membershipService","roleService","effectivePermissionService","bootstrapTenantFromTemplate","template","createOrgTree","parentId","children","rootOrgUnit","ownerUser","ownerPrincipal","roles","createdRole","ownerRole","ownerRoleKey","rootOrgUnitId","ownerUserId","SystemManagementService","orgMembershipService","onboardUserToTenantAndOrgUnit","roleKey","changeUserOrgRole","currentAssignments","suspendUserInTenant","tenantMembershipId","Suspended","reactivateUserInTenant","AuthzService","dataSources","canAccess","listEffectivePermissionsForScope","resourceProtectedId","loadResource","Private","ResourceAcl","OrgSubtree","effectivePermissions","requireAccess","AuthorizationError","listEffectivePermissions","access","VERSION","COMMIT","FULL_VERSION","PACKAGE_NAME"],"mappings":"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"}