@decaf-ts/integrations 0.3.5 → 0.3.7

package/dist/integrations.js

@@ -4,6 +4,14 @@ import { LogLevel } from "@decaf-ts/logging";
 
 import { InternalError } from "@decaf-ts/db-decorators";
 
+import { Cascade, ModelService, pk, uuid, manyToOne, column, createdAt, updatedAt, table, unique, oneToMany, transactional, AuthorizationError } from "@decaf-ts/core";
+
+export { AuthorizationError, transactional } from "@decaf-ts/core";
+
+import { Model, required, type, option, model } from "@decaf-ts/decorator-validation";
+
+import { __decorate, __metadata } from "tslib";
+
 async function execWithLogging(command, options, log, level = LogLevel.info) {
     log.debug(`Executing: ${command}`);
     return new Promise((resolve, reject) => {
@@ -37,13 +45,1841 @@ async function execWithLogging(command, options, log, level = LogLevel.info) {
     });
 }
 
-const VERSION = "0.3.4";
+var IsolationTier;
+
+(function(IsolationTier) {
+    IsolationTier["Pooled"] = "pooled";
+    IsolationTier["Bridge"] = "bridge";
+    IsolationTier["Silo"] = "silo";
+})(IsolationTier || (IsolationTier = {}));
+
+var MembershipStatus;
+
+(function(MembershipStatus) {
+    MembershipStatus["Invited"] = "invited";
+    MembershipStatus["Active"] = "active";
+    MembershipStatus["Suspended"] = "suspended";
+    MembershipStatus["Removed"] = "removed";
+})(MembershipStatus || (MembershipStatus = {}));
+
+var PrincipalKind;
+
+(function(PrincipalKind) {
+    PrincipalKind["User"] = "user";
+    PrincipalKind["Group"] = "group";
+    PrincipalKind["ServiceAccount"] = "service_account";
+    PrincipalKind["Agent"] = "agent";
+    PrincipalKind["ApiKey"] = "api_key";
+})(PrincipalKind || (PrincipalKind = {}));
+
+var ScopeKind;
+
+(function(ScopeKind) {
+    ScopeKind["Tenant"] = "tenant";
+    ScopeKind["OrgUnit"] = "org_unit";
+    ScopeKind["Resource"] = "resource";
+})(ScopeKind || (ScopeKind = {}));
+
+var PermissionCategory;
+
+(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";
+})(PermissionCategory || (PermissionCategory = {}));
+
+var ResourceVisibility;
+
+(function(ResourceVisibility) {
+    ResourceVisibility["Private"] = "private";
+    ResourceVisibility["ResourceAcl"] = "resource_acl";
+    ResourceVisibility["OrgUnit"] = "org_unit";
+    ResourceVisibility["OrgSubtree"] = "org_subtree";
+    ResourceVisibility["Tenant"] = "tenant";
+})(ResourceVisibility || (ResourceVisibility = {}));
+
+var StorageKind;
+
+(function(StorageKind) {
+    StorageKind["Postgres"] = "postgres";
+    StorageKind["Arango"] = "arango";
+    StorageKind["Qdrant"] = "qdrant";
+    StorageKind["ObjectStorage"] = "object_storage";
+})(StorageKind || (StorageKind = {}));
+
+var StorageBindingKind;
+
+(function(StorageBindingKind) {
+    StorageBindingKind["Shared"] = "shared";
+    StorageBindingKind["Dedicated"] = "dedicated";
+})(StorageBindingKind || (StorageBindingKind = {}));
+
+const IsolationTierOptions = Object.values(IsolationTier);
+
+const MembershipStatusOptions = Object.values(MembershipStatus);
+
+const PrincipalKindOptions = Object.values(PrincipalKind);
+
+const ScopeKindOptions = Object.values(ScopeKind);
+
+const PermissionCategoryOptions = Object.values(PermissionCategory);
+
+const ResourceVisibilityOptions = Object.values(ResourceVisibility);
+
+const StorageKindOptions = Object.values(StorageKind);
+
+const StorageBindingKindOptions = Object.values(StorageBindingKind);
+
+const REL_RESTRICT = {
+    update: Cascade.NONE,
+    delete: Cascade.NONE,
+    nullable: false
+};
+
+const REL_NULLIFY = {
+    update: Cascade.NONE,
+    delete: Cascade.NONE,
+    nullable: true
+};
+
+const REL_CASCADE_DEPENDENT = {
+    update: Cascade.CASCADE,
+    delete: Cascade.CASCADE,
+    nullable: false
+};
+
+const REL_CASCADE_INSERT_UPDATE = {
+    update: Cascade.CASCADE,
+    delete: 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 === 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 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 Model {
+    constructor(data) {
+        super(data);
+    }
+}
+
+let TenantMembership = class TenantMembership extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], TenantMembership.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_memberships_tenant"), required(), __metadata("design:type", Object) ], TenantMembership.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => User, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_memberships_user"), required(), __metadata("design:type", Object) ], TenantMembership.prototype, "user", void 0);
+
+__decorate([ required(), type(String), option(MembershipStatusOptions), column(), __metadata("design:type", String) ], TenantMembership.prototype, "status", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], TenantMembership.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], TenantMembership.prototype, "updatedAt", void 0);
+
+TenantMembership = __decorate([ table("tenant_memberships"), model(), __metadata("design:paramtypes", [ Object ]) ], TenantMembership);
+
+let User = class User extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], User.prototype, "id", void 0);
+
+__decorate([ unique(), type(String), column(), __metadata("design:type", String) ], User.prototype, "email", void 0);
+
+__decorate([ unique(), type(String), column(), __metadata("design:type", String) ], User.prototype, "phone", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], User.prototype, "displayName", void 0);
+
+__decorate([ oneToMany(() => TenantMembership, REL_RESTRICT, false), __metadata("design:type", Array) ], User.prototype, "tenantMemberships", void 0);
+
+__decorate([ oneToMany(() => OrgUnitMembership, REL_RESTRICT, false), __metadata("design:type", Array) ], User.prototype, "orgUnitMemberships", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], User.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], User.prototype, "updatedAt", void 0);
+
+User = __decorate([ table("users"), model(), __metadata("design:paramtypes", [ Object ]) ], User);
+
+let OrgUnitMembership = class OrgUnitMembership extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], OrgUnitMembership.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_memberships_tenant"), required(), __metadata("design:type", Object) ], OrgUnitMembership.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_memberships_org_unit"), required(), __metadata("design:type", Object) ], OrgUnitMembership.prototype, "orgUnit", void 0);
+
+__decorate([ manyToOne(() => User, REL_RESTRICT, false, undefined, "fk_org_memberships_user"), required(), __metadata("design:type", Object) ], OrgUnitMembership.prototype, "user", void 0);
+
+__decorate([ required(), type(String), option(MembershipStatusOptions), column(), __metadata("design:type", String) ], OrgUnitMembership.prototype, "status", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], OrgUnitMembership.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], OrgUnitMembership.prototype, "updatedAt", void 0);
+
+OrgUnitMembership = __decorate([ table("org_unit_memberships"), model(), __metadata("design:paramtypes", [ Object ]) ], OrgUnitMembership);
+
+let OrgUnitClosure = class OrgUnitClosure extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], OrgUnitClosure.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_tenant"), required(), __metadata("design:type", Object) ], OrgUnitClosure.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_ancestor"), required(), __metadata("design:type", Object) ], OrgUnitClosure.prototype, "ancestor", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_closure_descendant"), required(), __metadata("design:type", Object) ], OrgUnitClosure.prototype, "descendant", void 0);
+
+__decorate([ required(), type(Number), column(), __metadata("design:type", Number) ], OrgUnitClosure.prototype, "depth", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], OrgUnitClosure.prototype, "createdAt", void 0);
+
+OrgUnitClosure = __decorate([ table("org_unit_closure"), model(), __metadata("design:paramtypes", [ Object ]) ], OrgUnitClosure);
+
+let Permission = class Permission extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], Permission.prototype, "id", void 0);
+
+__decorate([ unique(), required(), type(String), column(), __metadata("design:type", String) ], Permission.prototype, "key", void 0);
+
+__decorate([ required(), type(String), option(PermissionCategoryOptions), column(), __metadata("design:type", String) ], Permission.prototype, "category", void 0);
+
+__decorate([ type(String), column(), __metadata("design:type", String) ], Permission.prototype, "description", void 0);
+
+__decorate([ oneToMany(() => RolePermission, REL_RESTRICT, false), __metadata("design:type", Array) ], Permission.prototype, "rolePermissions", void 0);
+
+Permission = __decorate([ table("permissions"), model(), __metadata("design:paramtypes", [ Object ]) ], Permission);
+
+let RolePermission = class RolePermission extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], RolePermission.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Role, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_permissions_role"), required(), __metadata("design:type", Object) ], RolePermission.prototype, "role", void 0);
+
+__decorate([ manyToOne(() => Permission, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_permissions_permission"), required(), __metadata("design:type", Object) ], RolePermission.prototype, "permission", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], RolePermission.prototype, "createdAt", void 0);
+
+RolePermission = __decorate([ table("role_permissions"), model(), __metadata("design:paramtypes", [ Object ]) ], RolePermission);
+
+let Role = class Role extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], Role.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_NULLIFY, false, undefined, "fk_roles_tenant"), __metadata("design:type", Object) ], Role.prototype, "tenant", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], Role.prototype, "key", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], Role.prototype, "name", void 0);
+
+__decorate([ type(String), column(), __metadata("design:type", String) ], Role.prototype, "description", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], Role.prototype, "metadata", void 0);
+
+__decorate([ oneToMany(() => RolePermission, REL_RESTRICT, false), __metadata("design:type", Array) ], Role.prototype, "rolePermissions", void 0);
+
+__decorate([ oneToMany(() => RoleAssignment, REL_RESTRICT, false), __metadata("design:type", Array) ], Role.prototype, "assignments", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], Role.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], Role.prototype, "updatedAt", void 0);
+
+Role = __decorate([ table("roles"), model(), __metadata("design:paramtypes", [ Object ]) ], Role);
+
+let RoleAssignment = class RoleAssignment extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], RoleAssignment.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_assignments_tenant"), required(), __metadata("design:type", Object) ], RoleAssignment.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_role_assignments_principal"), required(), __metadata("design:type", Object) ], RoleAssignment.prototype, "principal", void 0);
+
+__decorate([ manyToOne(() => Role, REL_RESTRICT, false, undefined, "fk_role_assignments_role"), required(), __metadata("design:type", Object) ], RoleAssignment.prototype, "role", void 0);
+
+__decorate([ required(), type(String), option(ScopeKindOptions), column(), __metadata("design:type", String) ], RoleAssignment.prototype, "scopeKind", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], RoleAssignment.prototype, "scopeId", void 0);
+
+__decorate([ required(), type(Boolean), column(), __metadata("design:type", Boolean) ], RoleAssignment.prototype, "inheritDown", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], RoleAssignment.prototype, "startsAt", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], RoleAssignment.prototype, "expiresAt", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], RoleAssignment.prototype, "conditions", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], RoleAssignment.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], RoleAssignment.prototype, "updatedAt", void 0);
+
+RoleAssignment = __decorate([ table("role_assignments"), model(), __metadata("design:paramtypes", [ Object ]) ], RoleAssignment);
+
+let ResourceGrant = class ResourceGrant extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], ResourceGrant.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_tenant"), required(), __metadata("design:type", Object) ], ResourceGrant.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => ProtectedResource, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_resource"), required(), __metadata("design:type", Object) ], ResourceGrant.prototype, "resource", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_resource_grants_principal"), required(), __metadata("design:type", Object) ], ResourceGrant.prototype, "principal", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], ResourceGrant.prototype, "permissionKey", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], ResourceGrant.prototype, "startsAt", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], ResourceGrant.prototype, "expiresAt", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], ResourceGrant.prototype, "conditions", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_RESTRICT, false, undefined, "fk_resource_grants_created_by"), __metadata("design:type", Object) ], ResourceGrant.prototype, "createdBy", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], ResourceGrant.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], ResourceGrant.prototype, "updatedAt", void 0);
+
+ResourceGrant = __decorate([ table("resource_grants"), model(), __metadata("design:paramtypes", [ Object ]) ], ResourceGrant);
+
+let Principal = class Principal extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], Principal.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_RESTRICT, false, undefined, "fk_principals_tenant"), required(), __metadata("design:type", Object) ], Principal.prototype, "tenant", void 0);
+
+__decorate([ required(), type(String), option(PrincipalKindOptions), column(), __metadata("design:type", String) ], Principal.prototype, "kind", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], Principal.prototype, "subjectId", void 0);
+
+__decorate([ oneToMany(() => RoleAssignment, REL_RESTRICT, false), __metadata("design:type", Array) ], Principal.prototype, "roleAssignments", void 0);
+
+__decorate([ oneToMany(() => ResourceGrant, REL_RESTRICT, false), __metadata("design:type", Array) ], Principal.prototype, "resourceGrants", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], Principal.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], Principal.prototype, "updatedAt", void 0);
+
+Principal = __decorate([ table("principals"), model(), __metadata("design:paramtypes", [ Object ]) ], Principal);
+
+let ProtectedResource = class ProtectedResource extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], ProtectedResource.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_RESTRICT, false, undefined, "fk_protected_resources_tenant"), required(), __metadata("design:type", Object) ], ProtectedResource.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_RESTRICT, false, undefined, "fk_protected_resources_org_unit"), required(), __metadata("design:type", Object) ], ProtectedResource.prototype, "orgUnit", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], ProtectedResource.prototype, "resourceType", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], ProtectedResource.prototype, "resourceId", void 0);
+
+__decorate([ required(), type(String), option(ResourceVisibilityOptions), column(), __metadata("design:type", String) ], ProtectedResource.prototype, "visibility", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_NULLIFY, false, undefined, "fk_protected_resources_owner"), __metadata("design:type", Object) ], ProtectedResource.prototype, "owner", void 0);
+
+__decorate([ type(String), column(), __metadata("design:type", String) ], ProtectedResource.prototype, "sensitivity", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], ProtectedResource.prototype, "metadata", void 0);
+
+__decorate([ oneToMany(() => ResourceGrant, REL_RESTRICT, false), __metadata("design:type", Array) ], ProtectedResource.prototype, "grants", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], ProtectedResource.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], ProtectedResource.prototype, "updatedAt", void 0);
+
+ProtectedResource = __decorate([ table("protected_resources"), model(), __metadata("design:paramtypes", [ Object ]) ], ProtectedResource);
+
+let InheritanceBlock = class InheritanceBlock extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], InheritanceBlock.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_inheritance_blocks_tenant"), required(), __metadata("design:type", Object) ], InheritanceBlock.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_inheritance_blocks_org_unit"), required(), __metadata("design:type", Object) ], InheritanceBlock.prototype, "orgUnit", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_NULLIFY, false, undefined, "fk_inheritance_blocks_blocked_ancestor"), __metadata("design:type", Object) ], InheritanceBlock.prototype, "blockedFromAncestor", void 0);
+
+__decorate([ required(), type(String), option(PermissionCategoryOptions), column(), __metadata("design:type", String) ], InheritanceBlock.prototype, "permissionCategory", void 0);
+
+__decorate([ type(String), column(), __metadata("design:type", String) ], InheritanceBlock.prototype, "reason", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], InheritanceBlock.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], InheritanceBlock.prototype, "updatedAt", void 0);
+
+InheritanceBlock = __decorate([ table("inheritance_blocks"), model(), __metadata("design:paramtypes", [ Object ]) ], InheritanceBlock);
+
+let OrgUnit = class OrgUnit extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], OrgUnit.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_RESTRICT, false, undefined, "fk_org_units_tenant"), required(), __metadata("design:type", Object) ], OrgUnit.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_RESTRICT, false, undefined, "fk_org_units_parent"), __metadata("design:type", Object) ], OrgUnit.prototype, "parent", void 0);
+
+__decorate([ oneToMany(() => OrgUnit, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "children", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], OrgUnit.prototype, "name", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], OrgUnit.prototype, "path", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], OrgUnit.prototype, "metadata", void 0);
+
+__decorate([ oneToMany(() => OrgUnitMembership, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "memberships", void 0);
+
+__decorate([ oneToMany(() => ProtectedResource, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "resources", void 0);
+
+__decorate([ oneToMany(() => InheritanceBlock, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "inheritanceBlocks", void 0);
+
+__decorate([ oneToMany(() => OrgUnitClosure, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "ancestorLinks", void 0);
+
+__decorate([ oneToMany(() => OrgUnitClosure, REL_RESTRICT, false), __metadata("design:type", Array) ], OrgUnit.prototype, "descendantLinks", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], OrgUnit.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], OrgUnit.prototype, "updatedAt", void 0);
+
+OrgUnit = __decorate([ table("org_units"), model(), __metadata("design:paramtypes", [ Object ]) ], OrgUnit);
+
+let StorageBinding = class StorageBinding extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], StorageBinding.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_storage_bindings_tenant"), required(), __metadata("design:type", Object) ], StorageBinding.prototype, "tenant", void 0);
+
+__decorate([ required(), type(String), option(StorageKindOptions), column(), __metadata("design:type", String) ], StorageBinding.prototype, "storageKind", void 0);
+
+__decorate([ required(), type(String), option(StorageBindingKindOptions), column(), __metadata("design:type", String) ], StorageBinding.prototype, "bindingKind", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], StorageBinding.prototype, "bindingKey", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], StorageBinding.prototype, "region", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], StorageBinding.prototype, "config", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], StorageBinding.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], StorageBinding.prototype, "updatedAt", void 0);
+
+StorageBinding = __decorate([ table("storage_bindings"), model(), __metadata("design:paramtypes", [ Object ]) ], StorageBinding);
+
+let Tenant = class Tenant extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], Tenant.prototype, "id", void 0);
+
+__decorate([ unique(), required(), type(String), column(), __metadata("design:type", String) ], Tenant.prototype, "slug", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], Tenant.prototype, "name", void 0);
+
+__decorate([ required(), type(String), option(IsolationTierOptions), column(), __metadata("design:type", String) ], Tenant.prototype, "isolationTier", void 0);
+
+__decorate([ oneToMany(() => OrgUnit, REL_RESTRICT, false), __metadata("design:type", Array) ], Tenant.prototype, "orgUnits", void 0);
+
+__decorate([ oneToMany(() => TenantMembership, REL_RESTRICT, false), __metadata("design:type", Array) ], Tenant.prototype, "memberships", void 0);
+
+__decorate([ oneToMany(() => Principal, REL_RESTRICT, false), __metadata("design:type", Array) ], Tenant.prototype, "principals", void 0);
+
+__decorate([ oneToMany(() => StorageBinding, REL_RESTRICT, false), __metadata("design:type", Array) ], Tenant.prototype, "storageBindings", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], Tenant.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], Tenant.prototype, "updatedAt", void 0);
+
+Tenant = __decorate([ table("tenants"), model(), __metadata("design:paramtypes", [ Object ]) ], Tenant);
+
+let TenantProfile = class TenantProfile extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], TenantProfile.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_tenant_profiles_tenant"), required(), __metadata("design:type", Object) ], TenantProfile.prototype, "tenant", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], TenantProfile.prototype, "profileKey", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], TenantProfile.prototype, "metadata", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], TenantProfile.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], TenantProfile.prototype, "updatedAt", void 0);
+
+TenantProfile = __decorate([ table("tenant_profiles"), model(), __metadata("design:paramtypes", [ Object ]) ], TenantProfile);
+
+let OrgUnitProfile = class OrgUnitProfile extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], OrgUnitProfile.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_CASCADE_DEPENDENT, false, undefined, "fk_org_unit_profiles_org_unit"), required(), __metadata("design:type", Object) ], OrgUnitProfile.prototype, "orgUnit", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], OrgUnitProfile.prototype, "profileKey", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], OrgUnitProfile.prototype, "metadata", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], OrgUnitProfile.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], OrgUnitProfile.prototype, "updatedAt", void 0);
+
+OrgUnitProfile = __decorate([ table("org_unit_profiles"), model(), __metadata("design:paramtypes", [ Object ]) ], OrgUnitProfile);
+
+let GroupMembership = class GroupMembership extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], GroupMembership.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_tenant"), required(), __metadata("design:type", Object) ], GroupMembership.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => Group, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_group"), required(), __metadata("design:type", Object) ], GroupMembership.prototype, "group", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_group_memberships_principal"), required(), __metadata("design:type", Object) ], GroupMembership.prototype, "principal", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], GroupMembership.prototype, "metadata", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], GroupMembership.prototype, "createdAt", void 0);
+
+GroupMembership = __decorate([ table("group_memberships"), model(), __metadata("design:paramtypes", [ Object ]) ], GroupMembership);
+
+let Group = class Group extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], Group.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_RESTRICT, false, undefined, "fk_groups_tenant"), required(), __metadata("design:type", Object) ], Group.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => OrgUnit, REL_NULLIFY, false, undefined, "fk_groups_org_unit"), __metadata("design:type", Object) ], Group.prototype, "orgUnit", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], Group.prototype, "name", void 0);
+
+__decorate([ type(Object), column(), __metadata("design:type", Object) ], Group.prototype, "metadata", void 0);
+
+__decorate([ oneToMany(() => GroupMembership, REL_RESTRICT, false), __metadata("design:type", Array) ], Group.prototype, "members", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], Group.prototype, "createdAt", void 0);
+
+__decorate([ updatedAt(), __metadata("design:type", Date) ], Group.prototype, "updatedAt", void 0);
+
+Group = __decorate([ table("groups"), model(), __metadata("design:paramtypes", [ Object ]) ], Group);
+
+let EffectivePermission = class EffectivePermission extends AuthorizationModel {
+    constructor(data) {
+        super(data);
+    }
+};
+
+__decorate([ pk({
+    type: String
+}), uuid(), __metadata("design:type", String) ], EffectivePermission.prototype, "id", void 0);
+
+__decorate([ manyToOne(() => Tenant, REL_CASCADE_DEPENDENT, false, undefined, "fk_effective_permissions_tenant"), required(), __metadata("design:type", Object) ], EffectivePermission.prototype, "tenant", void 0);
+
+__decorate([ manyToOne(() => Principal, REL_CASCADE_DEPENDENT, false, undefined, "fk_effective_permissions_principal"), required(), __metadata("design:type", Object) ], EffectivePermission.prototype, "principal", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], EffectivePermission.prototype, "permissionKey", void 0);
+
+__decorate([ required(), type(String), option(ScopeKindOptions), column(), __metadata("design:type", String) ], EffectivePermission.prototype, "scopeKind", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], EffectivePermission.prototype, "scopeId", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], EffectivePermission.prototype, "sourceKind", void 0);
+
+__decorate([ required(), type(String), column(), __metadata("design:type", String) ], EffectivePermission.prototype, "sourceId", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], EffectivePermission.prototype, "startsAt", void 0);
+
+__decorate([ column(), __metadata("design:type", Date) ], EffectivePermission.prototype, "expiresAt", void 0);
+
+__decorate([ createdAt(), __metadata("design:type", Date) ], EffectivePermission.prototype, "createdAt", void 0);
+
+EffectivePermission = __decorate([ table("effective_permissions"), model(), __metadata("design:paramtypes", [ Object ]) ], EffectivePermission);
+
+class TenantProfileService extends BaseModelService {
+    constructor() {
+        super(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(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(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(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(Tenant);
+    }
+    async createTenant(input, ...args) {
+        return this.create({
+            slug: input.slug,
+            name: input.name,
+            isolationTier: input.isolationTier ?? 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(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);
+    }
+}
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, Object, String, Object, Object ]), __metadata("design:returntype", Promise) ], OrgUnitService.prototype, "createRoot", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Object, Object ]), __metadata("design:returntype", Promise) ], OrgUnitService.prototype, "createChild", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, String, Object ]), __metadata("design:returntype", Promise) ], OrgUnitService.prototype, "moveOrgUnit", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, Object ]), __metadata("design:returntype", Promise) ], OrgUnitService.prototype, "rebuildTenantClosure", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, Object ]), __metadata("design:returntype", Promise) ], OrgUnitService.prototype, "deleteOrgUnitTree", null);
+
+class UserService extends BaseModelService {
+    constructor() {
+        super(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(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, PrincipalKind.User, userId, ...args);
+    }
+    async getGroupPrincipal(tenantId, groupId, ...args) {
+        return this.getOrCreateForSubject(tenantId, PrincipalKind.Group, groupId, ...args);
+    }
+}
+
+class TenantMembershipService extends BaseModelService {
+    constructor() {
+        super(TenantMembership);
+    }
+    async addUserToTenant(tenantId, userId, status = 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(OrgUnitMembership);
+    }
+    async addUserToOrgUnit(tenantId, orgUnitId, userId, status = 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(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(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(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(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(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(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(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 === ScopeKind.Tenant) {
+                    scopes.push({
+                        scopeKind: scopeKind,
+                        scopeId: tenantId
+                    });
+                } else if (scopeKind === ScopeKind.Resource) {
+                    scopes.push({
+                        scopeKind: scopeKind,
+                        scopeId: scopeId
+                    });
+                } else if (scopeKind === ScopeKind.OrgUnit && !assignment.inheritDown) {
+                    scopes.push({
+                        scopeKind: scopeKind,
+                        scopeId: scopeId
+                    });
+                } else if (scopeKind === 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 === 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);
+        }
+    }
+}
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, Object ]), __metadata("design:returntype", Promise) ], EffectivePermissionService.prototype, "rebuildForPrincipal", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, Object ]), __metadata("design:returntype", Promise) ], EffectivePermissionService.prototype, "rebuildForTenant", null);
+
+class ProtectedResourceService extends BaseModelService {
+    constructor() {
+        super(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(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(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: StorageBindingKind.Dedicated,
+            bindingKey: bindingKey,
+            region: region,
+            config: config
+        }, ...args);
+    }
+    async setShared(bindingId, bindingKey, region, config, ...args) {
+        return this.updateOne(bindingId, {
+            bindingKind: 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, 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: 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
+        };
+    }
+}
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ Object, Object ]), __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, MembershipStatus.Active, ...args);
+        await this.orgMembershipService.addUserToOrgUnit(tenantId, orgUnitId, userId, 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: 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 === ScopeKind.OrgUnit && row.scopeId === orgUnitId)) {
+            await this.roleAssignmentService.revokeAssignment(assignment.id, ...args);
+        }
+        await this.roleAssignmentService.assignRole({
+            tenantId: tenantId,
+            principalId: principalId,
+            roleId: role.id,
+            scopeKind: 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, MembershipStatus.Suspended, ...args);
+        await this.effectivePermissionService.deleteForPrincipal(tenantId, principalId, ...args);
+    }
+    async reactivateUserInTenant(tenantMembershipId, tenantId, principalId, ...args) {
+        await this.membershipService.setStatus(tenantMembershipId, MembershipStatus.Active, ...args);
+        await this.effectivePermissionService.rebuildForPrincipal(tenantId, principalId, ...args);
+    }
+}
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, String, String, Object ]), __metadata("design:returntype", Promise) ], SystemManagementService.prototype, "onboardUserToTenantAndOrgUnit", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, String, String, Boolean, Object ]), __metadata("design:returntype", Promise) ], SystemManagementService.prototype, "changeUserOrgRole", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, String, Object ]), __metadata("design:returntype", Promise) ], SystemManagementService.prototype, "suspendUserInTenant", null);
+
+__decorate([ transactional(), __metadata("design:type", Function), __metadata("design:paramtypes", [ String, String, String, Object ]), __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 === ResourceVisibility.Private || visibility === ResourceVisibility.ResourceAcl) {
+            return false;
+        }
+        if (visibility === ResourceVisibility.OrgUnit || visibility === ResourceVisibility.OrgSubtree) {
+            const effectivePermissions = asArray(await (this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, ScopeKind.OrgUnit, resource.orgUnitId)));
+            return effectivePermissions.some(permission => permission.permissionKey === input.permissionKey && isTimeValid(at, permission.startsAt, permission.expiresAt));
+        }
+        if (visibility === ResourceVisibility.Tenant) {
+            const effectivePermissions = asArray(await (this.dataSources.listEffectivePermissionsForScope?.(input.tenantId, 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 AuthorizationError(`Access denied for ${input.permissionKey} on ${input.resourceProtectedId ?? scopeKey(input.scopeKind ?? 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 = "c7207f5";
+const COMMIT = "c132eea";
 
-const FULL_VERSION = "0.3.4-c7207f5";
+const FULL_VERSION = "0.3.6-c132eea";
 
 const PACKAGE_NAME = "@decaf-ts/integrations";
 
-export { COMMIT, FULL_VERSION, PACKAGE_NAME, VERSION, execWithLogging };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { AuthorizationModel, AuthzService, BaseModelService, BootstrapService, COMMIT, EffectivePermission, EffectivePermissionService, FULL_VERSION, Group, GroupMembership, GroupMembershipService, GroupService, InheritanceBlock, InheritanceBlockService, IsolationTier, IsolationTierOptions, MembershipStatus, MembershipStatusOptions, OrgUnit, OrgUnitClosure, OrgUnitClosureService, OrgUnitMembership, OrgUnitMembershipService, OrgUnitProfile, OrgUnitProfileService, OrgUnitService, PACKAGE_NAME, Permission, PermissionCategory, PermissionCategoryOptions, PermissionService, Principal, PrincipalKind, PrincipalKindOptions, PrincipalService, ProtectedResource, ProtectedResourceService, REL_CASCADE_DEPENDENT, REL_CASCADE_INSERT_UPDATE, REL_NULLIFY, REL_RESTRICT, ResourceGrant, ResourceGrantService, ResourceLifecycleService, ResourceVisibility, ResourceVisibilityOptions, Role, RoleAssignment, RoleAssignmentService, RolePermission, RolePermissionService, RoleService, ScopeKind, ScopeKindOptions, StorageBinding, StorageBindingKind, StorageBindingKindOptions, StorageBindingService, StorageKind, StorageKindOptions, SystemManagementService, Tenant, TenantMembership, TenantMembershipService, TenantProfile, TenantProfileService, TenantService, User, UserService, VERSION, asArray, buildAccessContext, buildArangoContext, buildQdrantFilter, execWithLogging, id, isTimeValid, lowerSlug, nowIso, relationId, relationMatch, sameTenant };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"integrations.js","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":";;;;;;;;;;;;;;AASOA,eAAeC,gBACpBC,SACAC,SACAC,KACAC,QAAkBC,SAASC;IAE3BH,IAAII,MAAM,cAAcN;IAExB,OAAO,IAAIO,QAAQ,CAACC,SAASC;QAC3B,MAAMC,QAAQC,KAAKX,SAASC;QAE5B,MAAMW,SAAmB;QACzB,MAAMC,SAAmB;QAEzBH,MAAME,QAAQE,GAAG,QAASC;YACxBH,OAAOI,KAAKD;YACZb,IAAIC,OAAOY,KAAKE;;QAGlBP,MAAMG,QAAQC,GAAG,QAASC;YACxBF,OAAOG,KAAKD;YACZb,IAAII,MAAMS,KAAKE;;QAGjBP,MAAMI,GAAG,SAAUI;YACjB,IAAIA,SAAS,GAAG;gBACdhB,IAAIiB,MAAM;gBACVX,QAAQ;oBAAEI,QAAQA,OAAOQ,KAAK;oBAAOP,QAAQA,OAAOO,KAAK;;AAC3D,mBAAO;gBACLlB,IAAImB,SACF,4BAA4BH,WAAWL,OAAOO,KAAK;gBAErDX,OACE,IAAIa,cACF,4BAA4BJ,SAASL,OAAOO,KAAK;AAGvD;;QAGFV,MAAMI,GAAG,SAAUS;YACjBrB,IAAImB,SAAS,2BAA2BE;YACxCd,OAAOc;;;AAGb;;ICtDYC;;CAAZ,SAAYA;IACVA,cAAA,YAAA;IACAA,cAAA,YAAA;IACAA,cAAA,UAAA;AACD,EAJD,CAAYA,kBAAAA,gBAAa,CAAA;;IAMbC;;CAAZ,SAAYA;IACVA,iBAAA,aAAA;IACAA,iBAAA,YAAA;IACAA,iBAAA,eAAA;IACAA,iBAAA,aAAA;AACD,EALD,CAAYA,qBAAAA,mBAAgB,CAAA;;IAOhBC;;CAAZ,SAAYA;IACVA,cAAA,UAAA;IACAA,cAAA,WAAA;IACAA,cAAA,oBAAA;IACAA,cAAA,WAAA;IACAA,cAAA,YAAA;AACD,EAND,CAAYA,kBAAAA,gBAAa,CAAA;;IAQbC;;CAAZ,SAAYA;IACVA,UAAA,YAAA;IACAA,UAAA,aAAA;IACAA,UAAA,cAAA;AACD,EAJD,CAAYA,cAAAA,YAAS,CAAA;;IAMTC;;CAAZ,SAAYA;IACVA,mBAAA,WAAA;IACAA,mBAAA,iBAAA;IACAA,mBAAA,kBAAA;IACAA,mBAAA,YAAA;IACAA,mBAAA,WAAA;IACAA,mBAAA,YAAA;IACAA,mBAAA,YAAA;IACAA,mBAAA,aAAA;IACAA,mBAAA,WAAA;IACAA,mBAAA,cAAA;IACAA,mBAAA,UAAA;IACAA,mBAAA,gBAAA;AACD,EAbD,CAAYA,uBAAAA,qBAAkB,CAAA;;IAelBC;;CAAZ,SAAYA;IACVA,mBAAA,aAAA;IACAA,mBAAA,iBAAA;IACAA,mBAAA,aAAA;IACAA,mBAAA,gBAAA;IACAA,mBAAA,YAAA;AACD,EAND,CAAYA,uBAAAA,qBAAkB,CAAA;;IAQlBC;;CAAZ,SAAYA;IACVA,YAAA,cAAA;IACAA,YAAA,YAAA;IACAA,YAAA,YAAA;IACAA,YAAA,mBAAA;AACD,EALD,CAAYA,gBAAAA,cAAW,CAAA;;IAOXC;;CAAZ,SAAYA;IACVA,mBAAA,YAAA;IACAA,mBAAA,eAAA;AACD,EAHD,CAAYA,uBAAAA,qBAAkB,CAAA;;AAKvB,MAAMC,uBAAuBC,OAAOC,OAAOV;;AAC3C,MAAMW,0BAA0BF,OAAOC,OAAOT;;AAC9C,MAAMW,uBAAuBH,OAAOC,OAAOR;;AAC3C,MAAMW,mBAAmBJ,OAAOC,OAAOP;;AACvC,MAAMW,4BAA4BL,OAAOC,OAAON;;AAChD,MAAMW,4BAA4BN,OAAOC,OAAOL;;AAChD,MAAMW,qBAAqBP,OAAOC,OAAOJ;;AACzC,MAAMW,4BAA4BR,OAAOC,OAAOH;;ACzDhD,MAAMW,eAAe;IAC1BC,QAAQC,QAAQC;IAChBC,QAAQF,QAAQC;IAChBE,UAAU;;;AAGL,MAAMC,cAAc;IACzBL,QAAQC,QAAQC;IAChBC,QAAQF,QAAQC;IAChBE,UAAU;;;AAGL,MAAME,wBAAwB;IACnCN,QAAQC,QAAQM;IAChBJ,QAAQF,QAAQM;IAChBH,UAAU;;;AAGL,MAAMI,4BAA4B;IACvCR,QAAQC,QAAQM;IAChBJ,QAAQF,QAAQC;IAChBE,UAAU;;;AAGN,SAAUK,mBAAmBnD;IAOjC,OAAO;QACLoD,UAAUpD,QAAQoD;QAClBC,aAAarD,QAAQqD;QACrBC,eAAetD,QAAQsD;QACvBC,mBAAmB,KAAIvD,QAAQuD;QAC/BC,oBAAoB,KAAIxD,QAAQwD;;AAEpC;;AAEM,SAAUC,kBAAkBzD;IAOhC,OAAO;QACL0D,MAAM,EACJ;YACEC,KAAK;YACLC,OAAO;gBAAEC,OAAO7D,QAAQoD;;WAE1B;YACEU,QAAQ,EACN;gBAAEH,KAAK;gBAAeC,OAAO;oBAAEG,KAAK/D,QAAQuD;;eAC5C;gBAAEI,KAAK;gBAAyBC,OAAO;oBAAEG,KAAK/D,QAAQwD;;eACtD;gBAAEG,KAAK;gBAAsBC,OAAO;oBAAEC,OAAO7D,QAAQqD;;;;;AAK/D;;AAEA,SAASW,WAASC,WAAsBC;IACtC,OAAO,GAAGD,aAAaC;AACzB;;SAEgBC;IACd,OAAO,IAAIC;AACb;;AAEM,SAAUC,QAAWR;IACzB,OAAOA,SAAS;AAClB;;AAEM,SAAUS,WAAWC,WAAoBnB;IAC7C,OAAOoB,WAAWD,eAA0CnB;AAC9D;;AAEM,SAAUqB,cAAcZ,OAAgBa;IAC5C,OAAOA,SAASF,WAAWX,WAAsCa,SAAS;AAC5E;;AAEM,SAAUC,UAAUd;IACxB,OACEA,MACG7C,OACA4D,cACAC,QAAQ,eAAe,KACvBA,QAAQ,YAAY,OAAO;AAElC;;SAEgBC,YAAYC,IAAsBC,UAAiBC;IACjE,MAAMC,UAAUH,MAAM,IAAIX;IAC1B,IAAIY,YAAYE,UAAUF,UAAU,OAAO;IAC3C,IAAIC,aAAaC,UAAUD,WAAW,OAAO;IAC7C,OAAO;AACT;;AAEM,SAAUE,mBAAmBnF;IAMjC,MAAMoF,qBAA+C,CAAA;IACrD,MAAMC,gCAA0D,CAAA;IAEhE,KAAK,MAAMC,cAActF,QAAQuF,aAAa;QAC5C,MAAM5B,MAAMK,WAASsB,WAAWrB,WAAWqB,WAAWpB;QACtDkB,mBAAmBzB,OAAOyB,mBAAmBzB,QAAQ;QACrDyB,mBAAmBzB,KAAK5C,KAAKuE,WAAWhC;QACxC,IAAIgC,WAAWrB,cAAcvC,UAAU8D,SAAS;YAC9CH,8BAA8BC,WAAWhC,iBACvC+B,8BAA8BC,WAAWhC,kBAAkB;YAC7D+B,8BAA8BC,WAAWhC,eAAevC,KAAKuE,WAAWpB;AAC1E;AACF;IAEA,OAAO;QACLd,UAAUpD,QAAQoD;QAClBC,aAAarD,QAAQqD;QACrB+B;QACAC;QACEI,gBAAgBzF,QAAQ0F,OAAOC,IAAKC,UAAK;YACvCC,YAAYD,MAAMC;YAClBvC,eAAesC,MAAMtC;;;AAG7B;;AAEM,MAAgBwC,yBAAoEC;IAIxF,WAAAC,CAAsBC;QACpBC,MAAMD;AACR;IAEU,QAAAE,CAAYF,OAAoBnF;QACxC,OAAOkB,OAAOoE,OAAO,IAAIH,OAAmBnF;AAC9C;IAEA,YAAMuF,CAAOvF,SAAqBwF;QAChC,OAAOC,KAAKC,KAAKH,OAAOrE,OAAOoE,OAAO,IAAStF,UAAoBwF;AACrE;IAEA,eAAMG,CAAU3F,SAAqBwF;QACnC,OAAOC,KAAKF,OAAOvF,SAASwF;AAC9B;IAEA,aAAMI,CAAQC,OAAeL;QAC3B,OAAOC,KAAKC,KAAKI,KAAKD,OAAOL;AAC/B;IAEA,eAAMO,CAAUF,IAAYG,UAAsBR;QAChD,MAAMS,iBAAiBR,KAAKC,KAAKI,KAAKD,OAAOL;QAC7C,OAAOC,KAAKC,KAAK9D,OAAOV,OAAOoE,OAAOW,UAAUD,WAAWR;AAC7D;IAEA,gBAAMU,CAAWL,OAAeL;cACxBC,KAAKC,KAAK3D,OAAO8D,OAAOL;AAChC;IAEA,eAAMW,CAAsCtD,KAAQE,UAAgByC;QAClE,OAAOC,KAAKC,KAAKS,UAAUtD,KAAKE,UAAUyC;AAC5C;IAEA,gBAAMY,CAAuCvD,KAAQE,UAAgByC;QACnE,OAAOC,KAAKC,KAAKW,SAASC,MAAM;YAAEzD,CAACA,MAAME;WAAgBwD,WAAWf;AACtE;IAEA,aAAMgB,IAAWhB;QACf,OAAOC,KAAKC,KAAKW,SAASE,WAAWf;AACvC;;;SAGcK;IACd,OAAOY,OAAOC;AAChB;;AAEM,SAAUhD,WAAWX;IACzB,cAAcA,UAAU,WAAWA,QAAQA,MAAM8C;AACnD;;ACnMM,MAAgBc,2BAA2BC;IAC/C,WAAA1B,CAAYlF;QACVoF,MAAMpF;AACR;;;ACKK,IAAM6G,mBAAN,MAAMA,yBAAyBF;IACpC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBL,iBAAAM,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,iCACjEC,iDACwBV,iBAAAM,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAMI,MAAMtF,uBAAuB,OAAOoF,WAAW,+BAC/DC,iDACoBV,iBAAAM,WAAA,aAAA;;AACkDL,WAAA,EAAtES,YAAYE,KAAOR,SAASS,OAAOtG,0BAA0BuG,+CAAmCd,iBAAAM,WAAA,eAAA;;AACpFL,WAAA,EAAZc,uCAAwBtE,SAAKuD,iBAAAM,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKuD,iBAAAM,WAAA,kBAAA;;AAdnBN,mBAAgBC,WAAA,EAF5BgB,MAAM,uBACNC,wDACYlB;;ACQN,IAAMW,OAAN,MAAMA,aAAab;IAgCxB,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AA/BA8G,WAAA,EAFCC,GAAG;IAAEC,MAAMC;IACXC,6CACWM,KAAAL,WAAA,WAAA;;AAKZL,WAAA,EAHCkB,UACAhB,KAAKC,SACLU,+CACcH,KAAAL,WAAA,cAAA;;AAKfL,WAAA,EAHCkB,UACAhB,KAAKC,SACLU,+CACcH,KAAAL,WAAA,cAAA;;AAKfL,WAAA,EAHCS,YACAP,KAAKC,SACLU,+CACoBH,KAAAL,WAAA,oBAAA;;AAGrBL,WAAA,EADCmB,UAAU,MAAMpB,kBAAkBlF,cAAc,4CACC6F,KAAAL,WAAA,0BAAA;;AAGlDL,WAAA,EADCmB,UAAU,MAAMC,mBAAmBvG,cAAc,4CACE6F,KAAAL,WAAA,2BAAA;;AAGpDL,WAAA,EADCc,uCACWtE,SAAKkE,KAAAL,WAAA,kBAAA;;AAGjBL,WAAA,EADCe,uCACWvE,SAAKkE,KAAAL,WAAA,kBAAA;;AA9BNK,OAAIV,WAAA,EAFhBgB,MAAM,UACNC,wDACYP;;ACPN,IAAMU,oBAAN,MAAMA,0BAA0BvB;IACrC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBgB,kBAAAf,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,8BACjEC,iDACwBW,kBAAAf,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAM1C,SAASxC,uBAAuB,OAAOoF,WAAW,gCAClEC,iDAC0BW,kBAAAf,WAAA,gBAAA;;AAG3BL,WAAA,EAFCM,UAAU,MAAMI,MAAM7F,cAAc,OAAO2F,WAAW,4BACtDC,iDACoBW,kBAAAf,WAAA,aAAA;;AACkDL,WAAA,EAAtES,YAAYE,KAAOR,SAASS,OAAOtG,0BAA0BuG,+CAAmCO,kBAAAf,WAAA,eAAA;;AACpFL,WAAA,EAAZc,uCAAwBtE,SAAK4E,kBAAAf,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAK4E,kBAAAf,WAAA,kBAAA;;AAjBnBe,oBAAiBpB,WAAA,EAF7BgB,MAAM,yBACNC,wDACYG;;ACFN,IAAMC,iBAAN,MAAMA,uBAAuBxB;IAClC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBiB,eAAAhB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,0BACjEC,iDACwBY,eAAAhB,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAM1C,SAASxC,uBAAuB,OAAOoF,WAAW,4BAClEC,iDAC2BY,eAAAhB,WAAA,iBAAA;;AAG5BL,WAAA,EAFCM,UAAU,MAAM1C,SAASxC,uBAAuB,OAAOoF,WAAW,8BAClEC,iDAC6BY,eAAAhB,WAAA,mBAAA;;AACQL,WAAA,EAArCS,YAAYE,KAAOW,SAAST,+CAAwBQ,eAAAhB,WAAA,cAAA;;AACxCL,WAAA,EAAZc,uCAAwBtE,SAAK6E,eAAAhB,WAAA,kBAAA;;AAhBnBgB,iBAAcrB,WAAA,EAF1BgB,MAAM,qBACNC,wDACYI;;ACAN,IAAME,aAAN,MAAMA,mBAAmB1B;IAC9B,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBmB,WAAAlB,WAAA,WAAA;;AACML,WAAA,EAA/CkB,UAAUT,YAAYE,KAAOR,SAASU,+CAAsBU,WAAAlB,WAAA,YAAA;;AACYL,WAAA,EAAxES,YAAYE,KAAOR,SAASS,OAAOnG,4BAA4BoG,+CAAuCU,WAAAlB,WAAA,iBAAA;;AAC7EL,WAAA,EAAzBW,KAAOR,SAASU,+CAA8BU,WAAAlB,WAAA,oBAAA;;AACOL,WAAA,EAArDmB,UAAU,MAAMK,gBAAgB3G,cAAc,4CAAqD0G,WAAAlB,WAAA,wBAAA;;AATzFkB,aAAUvB,WAAA,EAFtBgB,MAAM,gBACNC,wDACYM;;ACAN,IAAMC,iBAAN,MAAMA,uBAAuB3B;IAClC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBoB,eAAAnB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMmB,MAAMrG,uBAAuB,OAAOoF,WAAW,6BAC/DC,iDACoBe,eAAAnB,WAAA,aAAA;;AAGrBL,WAAA,EAFCM,UAAU,MAAMiB,YAAYnG,uBAAuB,OAAOoF,WAAW,mCACrEC,iDACgCe,eAAAnB,WAAA,mBAAA;;AACpBL,WAAA,EAAZc,uCAAwBtE,SAAKgF,eAAAnB,WAAA,kBAAA;;AAZnBmB,iBAAcxB,WAAA,EAF1BgB,MAAM,qBACNC,wDACYO;;ACCN,IAAMC,OAAN,MAAMA,aAAa5B;IACxB,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBqB,KAAApB,WAAA,WAAA;;AAE1CL,WAAA,EADCM,UAAU,MAAMC,QAAQpF,aAAa,OAAOqF,WAAW,yDAC/BiB,KAAApB,WAAA,eAAA;;AACaL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAsBY,KAAApB,WAAA,YAAA;;AACbL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAuBY,KAAApB,WAAA,aAAA;;AAC1BL,WAAA,EAAzBW,KAAOR,SAASU,+CAA8BY,KAAApB,WAAA,oBAAA;;AACrBL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CY,KAAApB,WAAA,iBAAA;;AACPL,WAAA,EAArDmB,UAAU,MAAMK,gBAAgB3G,cAAc,4CAAqD4G,KAAApB,WAAA,wBAAA;;AAC9CL,WAAA,EAArDmB,UAAU,MAAMO,gBAAgB7G,cAAc,4CAAiD4G,KAAApB,WAAA,oBAAA;;AACnFL,WAAA,EAAZc,uCAAwBtE,SAAKiF,KAAApB,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKiF,KAAApB,WAAA,kBAAA;;AAfnBoB,OAAIzB,WAAA,EAFhBgB,MAAM,UACNC,wDACYQ;;ACCN,IAAMC,iBAAN,MAAMA,uBAAuB7B;IAClC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBsB,eAAArB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,+BACjEC,iDACwBiB,eAAArB,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAMqB,WAAWvG,uBAAuB,OAAOoF,WAAW,kCACpEC,iDAC8BiB,eAAArB,WAAA,kBAAA;;AAG/BL,WAAA,EAFCM,UAAU,MAAMmB,MAAM5G,cAAc,OAAO2F,WAAW,6BACtDC,iDACoBiB,eAAArB,WAAA,aAAA;;AAC2CL,WAAA,EAA/DS,YAAYE,KAAOR,SAASS,OAAOpG,mBAAmBqG,+CAA+Ba,eAAArB,WAAA,kBAAA;;AAChDL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA0Ba,eAAArB,WAAA,gBAAA;;AAChBL,WAAA,EAAtCS,YAAYE,KAAOiB,UAAUf,gDAA+Ba,eAAArB,WAAA,oBAAA;;AACnDL,WAAA,EAATa,oCAAoBrE,SAAKkF,eAAArB,WAAA,iBAAA;;AAChBL,WAAA,EAATa,oCAAqBrE,SAAKkF,eAAArB,WAAA,kBAAA;;AACDL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA8Ca,eAAArB,WAAA,mBAAA;;AAClDL,WAAA,EAAZc,uCAAwBtE,SAAKkF,eAAArB,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKkF,eAAArB,WAAA,kBAAA;;AAtBnBqB,iBAAc1B,WAAA,EAF1BgB,MAAM,qBACNC,wDACYS;;ACDN,IAAMG,gBAAN,MAAMA,sBAAsBhC;IACjC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmByB,cAAAxB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,8BACjEC,iDACwBoB,cAAAxB,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAMwB,mBAAmB1G,uBAAuB,OAAOoF,WAAW,gCAC5EC,iDACqCoB,cAAAxB,WAAA,iBAAA;;AAGtCL,WAAA,EAFCM,UAAU,MAAMqB,WAAWvG,uBAAuB,OAAOoF,WAAW,iCACpEC,iDAC8BoB,cAAAxB,WAAA,kBAAA;;AACOL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAgCgB,cAAAxB,WAAA,sBAAA;;AACnDL,WAAA,EAATa,oCAAoBrE,SAAKqF,cAAAxB,WAAA,iBAAA;;AAChBL,WAAA,EAATa,oCAAqBrE,SAAKqF,cAAAxB,WAAA,kBAAA;;AACDL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA8CgB,cAAAxB,WAAA,mBAAA;;AAE/DL,WAAA,EADCM,UAAU,MAAMqB,WAAW9G,cAAc,OAAO2F,WAAW,uEAC7BqB,cAAAxB,WAAA,kBAAA;;AAClBL,WAAA,EAAZc,uCAAwBtE,SAAKqF,cAAAxB,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKqF,cAAAxB,WAAA,kBAAA;;AAtBnBwB,gBAAa7B,WAAA,EAFzBgB,MAAM,oBACNC,wDACYY;;ACCN,IAAMF,YAAN,MAAMA,kBAAkB9B;IAC7B,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBuB,UAAAtB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQ1F,cAAc,OAAO2F,WAAW,yBACxDC,iDACwBkB,UAAAtB,WAAA,eAAA;;AAC2CL,WAAA,EAAnES,YAAYE,KAAOR,SAASS,OAAOrG,uBAAuBsG,+CAA8Bc,UAAAtB,WAAA,aAAA;;AACnDL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA4Bc,UAAAtB,WAAA,kBAAA;;AACHL,WAAA,EAArDmB,UAAU,MAAMO,gBAAgB7G,cAAc,4CAAqD8G,UAAAtB,WAAA,wBAAA;;AAC/CL,WAAA,EAApDmB,UAAU,MAAMU,eAAehH,cAAc,4CAAmD8G,UAAAtB,WAAA,uBAAA;;AACpFL,WAAA,EAAZc,uCAAwBtE,SAAKmF,UAAAtB,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKmF,UAAAtB,WAAA,kBAAA;;AAdnBsB,YAAS3B,WAAA,EAFrBgB,MAAM,eACNC,wDACYU;;ACCN,IAAMG,oBAAN,MAAMA,0BAA0BjC;IACrC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB0B,kBAAAzB,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQ1F,cAAc,OAAO2F,WAAW,kCACxDC,iDACwBqB,kBAAAzB,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAM1C,SAAS/C,cAAc,OAAO2F,WAAW,oCACzDC,iDAC0BqB,kBAAAzB,WAAA,gBAAA;;AACWL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA+BiB,kBAAAzB,WAAA,qBAAA;;AACtBL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA6BiB,kBAAAzB,WAAA,mBAAA;;AACeL,WAAA,EAAxES,YAAYE,KAAOR,SAASS,OAAOlG,4BAA4BmG,+CAAyCiB,kBAAAzB,WAAA,mBAAA;;AAEzGL,WAAA,EADCM,UAAU,MAAMqB,WAAWxG,aAAa,OAAOqF,WAAW,sEAChCsB,kBAAAzB,WAAA,cAAA;;AACDL,WAAA,EAAzBW,KAAOR,SAASU,+CAA8BiB,kBAAAzB,WAAA,oBAAA;;AACrBL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CiB,kBAAAzB,WAAA,iBAAA;;AACRL,WAAA,EAApDmB,UAAU,MAAMU,eAAehH,cAAc,4CAA2CiH,kBAAAzB,WAAA,eAAA;;AAC5EL,WAAA,EAAZc,uCAAwBtE,SAAKsF,kBAAAzB,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKsF,kBAAAzB,WAAA,kBAAA;;AArBnByB,oBAAiB9B,WAAA,EAF7BgB,MAAM,wBACNC,wDACYa;;ACFN,IAAMC,mBAAN,MAAMA,yBAAyBlC;IACpC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB2B,iBAAA1B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,iCACjEC,iDACwBsB,iBAAA1B,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAM1C,SAASxC,uBAAuB,OAAOoF,WAAW,mCAClEC,iDAC0BsB,iBAAA1B,WAAA,gBAAA;;AAE3BL,WAAA,EADCM,UAAU,MAAM1C,SAASzC,aAAa,OAAOqF,WAAW,gFAClBuB,iBAAA1B,WAAA,4BAAA;;AACkCL,WAAA,EAAxES,YAAYE,KAAOR,SAASS,OAAOnG,4BAA4BoG,+CAAiDkB,iBAAA1B,WAAA,2BAAA;;AACvFL,WAAA,EAAzBW,KAAOR,SAASU,+CAAyBkB,iBAAA1B,WAAA,eAAA;;AAC7BL,WAAA,EAAZc,uCAAwBtE,SAAKuF,iBAAA1B,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKuF,iBAAA1B,WAAA,kBAAA;;AAjBnB0B,mBAAgB/B,WAAA,EAF5BgB,MAAM,uBACNC,wDACYc;;ACEN,IAAMnE,UAAN,MAAMA,gBAAgBiC;IAC3B,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBxC,QAAAyC,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQ1F,cAAc,OAAO2F,WAAW,wBACxDC,iDACwB7C,QAAAyC,WAAA,eAAA;;AAEzBL,WAAA,EADCM,UAAU,MAAM1C,SAAS/C,cAAc,OAAO2F,WAAW,6DAChC5C,QAAAyC,WAAA,eAAA;;AACqBL,WAAA,EAA9CmB,UAAU,MAAMvD,SAAS/C,cAAc,4CAAuC+C,QAAAyC,WAAA,iBAAA;;AACzCL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAuBjD,QAAAyC,WAAA,aAAA;;AACdL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAuBjD,QAAAyC,WAAA,aAAA;;AAC1BL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CjD,QAAAyC,WAAA,iBAAA;;AACJL,WAAA,EAAxDmB,UAAU,MAAMC,mBAAmBvG,cAAc,4CAAoD+C,QAAAyC,WAAA,oBAAA;;AAC7CL,WAAA,EAAxDmB,UAAU,MAAMW,mBAAmBjH,cAAc,4CAAkD+C,QAAAyC,WAAA,kBAAA;;AAC5CL,WAAA,EAAvDmB,UAAU,MAAMY,kBAAkBlH,cAAc,4CAAyD+C,QAAAyC,WAAA,0BAAA;;AACpDL,WAAA,EAArDmB,UAAU,MAAME,gBAAgBxG,cAAc,4CAAmD+C,QAAAyC,WAAA,sBAAA;;AAC5CL,WAAA,EAArDmB,UAAU,MAAME,gBAAgBxG,cAAc,4CAAqD+C,QAAAyC,WAAA,wBAAA;;AACvFL,WAAA,EAAZc,uCAAwBtE,SAAKoB,QAAAyC,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKoB,QAAAyC,WAAA,kBAAA;;AArBnBzC,UAAOoC,WAAA,EAFnBgB,MAAM,cACNC,wDACYrD;;ACHN,IAAMoE,iBAAN,MAAMA,uBAAuBnC;IAClC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB4B,eAAA3B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,+BACjEC,iDACwBuB,eAAA3B,WAAA,eAAA;;AACyCL,WAAA,EAAjES,YAAYE,KAAOR,SAASS,OAAOjG,qBAAqBkG,+CAAmCmB,eAAA3B,WAAA,oBAAA;;AACnBL,WAAA,EAAxES,YAAYE,KAAOR,SAASS,OAAOhG,4BAA4BiG,+CAA0CmB,eAAA3B,WAAA,oBAAA;;AACpEL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA6BmB,eAAA3B,WAAA,mBAAA;;AACpBL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAyBmB,eAAA3B,WAAA,eAAA;;AAC5BL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA0CmB,eAAA3B,WAAA,eAAA;;AAC9CL,WAAA,EAAZc,uCAAwBtE,SAAKwF,eAAA3B,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKwF,eAAA3B,WAAA,kBAAA;;AAfnB2B,iBAAchC,WAAA,EAF1BgB,MAAM,qBACNC,wDACYe;;ACGN,IAAMzB,SAAN,MAAMA,eAAeV;IAC1B,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBG,OAAAF,WAAA,WAAA;;AACML,WAAA,EAA/CkB,UAAUT,YAAYE,KAAOR,SAASU,+CAAuBN,OAAAF,WAAA,aAAA;;AACxBL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAuBN,OAAAF,WAAA,aAAA;;AACgBL,WAAA,EAAnES,YAAYE,KAAOR,SAASS,OAAOzG,uBAAuB0G,+CAAuCN,OAAAF,WAAA,sBAAA;;AACnDL,WAAA,EAA9CmB,UAAU,MAAMvD,SAAS/C,cAAc,4CAAuC0F,OAAAF,WAAA,iBAAA;;AACvBL,WAAA,EAAvDmB,UAAU,MAAMpB,kBAAkBlF,cAAc,4CAAmD0F,OAAAF,WAAA,oBAAA;;AACnDL,WAAA,EAAhDmB,UAAU,MAAMQ,WAAW9G,cAAc,4CAA2C0F,OAAAF,WAAA,mBAAA;;AAC/BL,WAAA,EAArDmB,UAAU,MAAMa,gBAAgBnH,cAAc,4CAAqD0F,OAAAF,WAAA,wBAAA;;AACvFL,WAAA,EAAZc,uCAAwBtE,SAAK+D,OAAAF,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAK+D,OAAAF,WAAA,kBAAA;;AAdnBE,SAAMP,WAAA,EAFlBgB,MAAM,YACNC,wDACYV;;ACJN,IAAM0B,gBAAN,MAAMA,sBAAsBpC;IACjC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB6B,cAAA5B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,8BACjEC,iDACwBwB,cAAA5B,WAAA,eAAA;;AACaL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA6BoB,cAAA5B,WAAA,mBAAA;;AAChCL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CoB,cAAA5B,WAAA,iBAAA;;AAChDL,WAAA,EAAZc,uCAAwBtE,SAAKyF,cAAA5B,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAKyF,cAAA5B,WAAA,kBAAA;;AAZnB4B,gBAAajC,WAAA,EAFzBgB,MAAM,oBACNC,wDACYgB;;ACAN,IAAMC,iBAAN,MAAMA,uBAAuBrC;IAClC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB8B,eAAA7B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAM1C,SAASxC,uBAAuB,OAAOoF,WAAW,kCAClEC,iDAC0ByB,eAAA7B,WAAA,gBAAA;;AACWL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA6BqB,eAAA7B,WAAA,mBAAA;;AAChCL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CqB,eAAA7B,WAAA,iBAAA;;AAChDL,WAAA,EAAZc,uCAAwBtE,SAAK0F,eAAA7B,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAK0F,eAAA7B,WAAA,kBAAA;;AAZnB6B,iBAAclC,WAAA,EAF1BgB,MAAM,sBACNC,wDACYiB;;ACEN,IAAMC,kBAAN,MAAMA,wBAAwBtC;IACnC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmB+B,gBAAA9B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,gCACjEC,iDACwB0B,gBAAA9B,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAM8B,OAAOhH,uBAAuB,OAAOoF,WAAW,+BAChEC,iDACsB0B,gBAAA9B,WAAA,cAAA;;AAGvBL,WAAA,EAFCM,UAAU,MAAMqB,WAAWvG,uBAAuB,OAAOoF,WAAW,mCACpEC,iDAC8B0B,gBAAA9B,WAAA,kBAAA;;AACLL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CsB,gBAAA9B,WAAA,iBAAA;;AAChDL,WAAA,EAAZc,uCAAwBtE,SAAK2F,gBAAA9B,WAAA,kBAAA;;AAhBnB8B,kBAAenC,WAAA,EAF3BgB,MAAM,sBACNC,wDACYkB;;ACAN,IAAMC,QAAN,MAAMA,cAAcvC;IACzB,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBgC,MAAA/B,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQ1F,cAAc,OAAO2F,WAAW,qBACxDC,iDACwB2B,MAAA/B,WAAA,eAAA;;AAEzBL,WAAA,EADCM,UAAU,MAAM1C,SAASzC,aAAa,OAAOqF,WAAW,4DAC9B4B,MAAA/B,WAAA,gBAAA;;AACWL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAuBuB,MAAA/B,WAAA,aAAA;;AAC1BL,WAAA,EAAzBW,KAAOvG,SAASyG,+CAA4CuB,MAAA/B,WAAA,iBAAA;;AACNL,WAAA,EAAtDmB,UAAU,MAAMgB,iBAAiBtH,cAAc,4CAA8CuH,MAAA/B,WAAA,gBAAA;;AACjFL,WAAA,EAAZc,uCAAwBtE,SAAK4F,MAAA/B,WAAA,kBAAA;;AACjBL,WAAA,EAAZe,uCAAwBvE,SAAK4F,MAAA/B,WAAA,kBAAA;;AAfnB+B,QAAKpC,WAAA,EAFjBgB,MAAM,WACNC,wDACYmB;;ACAN,IAAMC,sBAAN,MAAMA,4BAA4BxC;IACvC,WAAAzB,CAAYlF;QACVoF,MAAMpF;AACR;;;AAE8B8G,WAAA,EAA7BC,GAAG;IAAEC,MAAMC;IAAWC,6CAAmBiC,oBAAAhC,WAAA,WAAA;;AAG1CL,WAAA,EAFCM,UAAU,MAAMC,QAAQnF,uBAAuB,OAAOoF,WAAW,oCACjEC,iDACwB4B,oBAAAhC,WAAA,eAAA;;AAGzBL,WAAA,EAFCM,UAAU,MAAMqB,WAAWvG,uBAAuB,OAAOoF,WAAW,uCACpEC,iDAC8B4B,oBAAAhC,WAAA,kBAAA;;AACOL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAAgCwB,oBAAAhC,WAAA,sBAAA;;AACGL,WAAA,EAA/DS,YAAYE,KAAOR,SAASS,OAAOpG,mBAAmBqG,+CAA+BwB,oBAAAhC,WAAA,kBAAA;;AAChDL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA0BwB,oBAAAhC,WAAA,gBAAA;;AACjBL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA6BwB,oBAAAhC,WAAA,mBAAA;;AACpBL,WAAA,EAArCS,YAAYE,KAAOR,SAASU,+CAA2BwB,oBAAAhC,WAAA,iBAAA;;AAC9CL,WAAA,EAATa,oCAAoBrE,SAAK6F,oBAAAhC,WAAA,iBAAA;;AAChBL,WAAA,EAATa,oCAAqBrE,SAAK6F,oBAAAhC,WAAA,kBAAA;;AACdL,WAAA,EAAZc,uCAAwBtE,SAAK6F,oBAAAhC,WAAA,kBAAA;;AAnBnBgC,sBAAmBrC,WAAA,EAF/BgB,MAAM,0BACNC,wDACYoB;;ACPP,MAAOC,6BAA6BpE;IACxC,WAAAE;QACEE,MAAM2D;AACR;IAEA,mBAAMM,CACJ/G,UACAgH,YACAC,aACG/D;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACRgH;YACAC;cAEC/D;AAEP;IAEA,mBAAMiE,CAAcnH,aAAqBkD;QACvC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQC,WAAYnG,WAAWmG,QAAQH,QAAQlH;AACtF;IAEA,qBAAMsH,CAAgBtH,aAAqBkD;QACzC,KAAK,MAAMqE,aAAapE,KAAKgE,cAAcnH,aAAakD,OAAO;kBACvDC,KAAKS,WAAW2D,IAAIhE,OAAOL;AACnC;AACF;;;AC7BI,MAAOsE,8BAA8B9E;IACzC,WAAAE;QACEE,MAAM4D;AACR;IAEA,mBAAMK,CACJU,WACAT,YACAC,aACG/D;QAEH,OAAOC,KAAKF,OACV;YACEyE,SAASD;YACTT;YACAC;cAEC/D;AAEP;IAEA,oBAAMyE,CAAeF,cAAsBvE;QACzC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQC,WAAYhG,cAAcgG,QAAQK,SAASD;AAC1F;;;ACvBI,MAAOG,8BAA8BlF;IACzC,WAAAE;QACEE,MAAM+C;AACR;IAEA,mBAAMgC,CAAc7H,UAAkByH,cAAsBvE;QAC1D,cAAcC,KAAKe,WAAWhB,OAC3BkE,OAAQG,OAAQrG,WAAWqG,IAAIL,QAAQlH,aAAaqB,cAAckG,IAAIO,YAAYL,YAClFM,KAAK,CAACC,MAAMC,UAAUD,KAAKE,QAAQD,MAAMC;AAC9C;IAEA,qBAAMC,CAAgBnI,UAAkByH,cAAsBvE;QAC5D,cAAcC,KAAKe,WAAWhB,OAC3BkE,OAAQG,OAAQrG,WAAWqG,IAAIL,QAAQlH,aAAaqB,cAAckG,IAAIa,UAAUX,YAChFM,KAAK,CAACC,MAAMC,UAAUD,KAAKE,QAAQD,MAAMC;AAC9C;IAEA,kBAAMG,CACJrI,UACAsI,mBACAC,wBACGrF;QAEH,cAAcC,KAAK0E,cAAc7H,UAAUuI,wBAAwBrF,OAAOsF,KAAMjB,OAC9ElG,cAAckG,IAAIa,UAAUE;AAEhC;IAEA,oBAAMG,CAAezI,UAAkByH,cAAsBvE;QAC3D,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACRoI,UAAUX;YACVK,YAAYL;YACZS,OAAO;cAENhF;AAEP;IAEA,oCAAMwF,CACJ1I,UACA2I,iBACAC,mBACG1F;QAEH,MAAM2F,sBAAsB1F,KAAK0E,cAAc7H,UAAU2I,oBAAoBzF;QAC7E,KAAK,MAAM4F,QAAQD,eAAe;kBAC1B1F,KAAKF,OACT;gBACEiE,QAAQlH;gBACRoI,UAAUU,KAAKV;gBACfN,YAAYc;gBACZV,OAAOY,KAAKZ,QAAQ;kBAEnBhF;AAEP;AACF;IAEA,2BAAM6F,CAAsB/I,UAAkByH,cAAsBvE;QAClE,MAAM8F,gBAAgB7F,KAAKgF,gBAAgBnI,UAAUyH,cAAcvE;QACnE,MAAM+F,gBAAgB,IAAIC,IAAI,EAACzB,cAAcuB,QAAQzG,IAAKgF,OAAQnG,WAAWmG,IAAIO;QACjF,MAAMqB,cAAc,IAAID,IAAI,EAACzB,cAAcuB,QAAQzG,IAAKgF,OAAQnG,WAAWmG,IAAIa;QAC/E,MAAMgB,cAAcjG,KAAKe,WAAWhB,OAAOkE,OACxCG,OACCrG,WAAWqG,IAAIL,QAAQlH,cACtBiJ,cAAcI,IAAIjI,WAAWmG,IAAIO,gBAAgBqB,YAAYE,IAAIjI,WAAWmG,IAAIa;QAErF,KAAK,MAAMb,OAAO6B,MAAM;kBAChBjG,KAAKS,WAAW2D,IAAIhE,OAAOL;AACnC;AACF;;;ACvEI,MAAOoG,gCAAgC5G;IAC3C,WAAAE;QACEE,MAAMyD;AACR;IAEA,mBAAMgD,CACJvJ,UACAyH,WACA+B,oBACAC,uBACAC,WACGxG;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACR0H,SAASD;YACTkC,qBAAqBF;YACrBD;YACAE;cAECxG;AAEP;IAEA,qBAAM0G,CAAgBC,YAAoB3G;cAClCC,KAAKS,WAAWiG,YAAY3G;AACpC;IAEA,oBAAMyE,CAAe3H,UAAkByH,cAAsBvE;QAC3D,cAAcC,KAAKe,WAAWhB,OAAOkE,OAClC0C,SAAU5I,WAAW4I,MAAM5C,QAAQlH,aAAaqB,cAAcyI,MAAMpC,SAASD;AAElF;IAEA,gCAAMsC,CACJ/J,UACAyH,WACAa,mBACA0B,aACG9G;QAEH,cAAcC,KAAKwE,eAAe3H,UAAUyH,cAAcvE,OAAOsF,KAC9DsB,SACCA,MAAMN,uBAAuBQ,cAC3BF,MAAMH,uBAAuBtI,cAAcyI,MAAMH,qBAAqBrB;AAE9E;;;AC/CI,MAAO2B,sBAAsBvH;IACjC,WAAAE;QACEE,MAAMiC;AACR;IAEA,kBAAMmF,CAAaC,UAA6BjH;QAC9C,OAAOC,KAAKF,OACV;YACEmH,MAAMD,MAAMC;YACZC,MAAMF,MAAME;YACZC,eAAeH,MAAMG,iBAAiBnM,cAAcoM;cAEnDrH;AAEP;IAEA,eAAMsH,CAAUJ,SAAiBlH;QAC/B,OAAOC,KAAKU,UAAU,QAAQuG,SAAkBlH;AAClD;IAEA,kBAAMuH,CAAazK,UAAkBqK,SAAiBnH;QACpD,OAAOC,KAAKM,UAAUzD,UAAU;YAAEqK;cAAWnH;AAC/C;IAEA,gBAAMwH,CAAW1K,UAAkBoK,SAAiBlH;QAClD,OAAOC,KAAKM,UAAUzD,UAAU;YAAEoK;cAAWlH;AAC/C;IAEA,sBAAMyH,CACJ3K,UACAsK,kBACGpH;QAEH,OAAOC,KAAKM,UAAUzD,UAAU;YAAEsK;cAAoBpH;AACxD;IAEA,4BAAM0H,CAAuB5K,aAAqBkD;cAC1CC,KAAKS,WAAW5D,aAAakD;AACrC;;;ACnCFzG,eAAeoO,iBACbC,SACA1B,SACGlG;IAEH,KAAK,MAAMqE,OAAO6B,MAAM;cAChB0B,QAAQlH,WAAW2D,IAAIhE,OAAOL;AACtC;AACF;;AAEM,MAAO6H,uBAAuBrI;IAClC,WAAAE;QACEE,MAAMV;AACR;IAEQ,WAAA4I,CAAYC,YAAgCZ;QAClD,MAAMa,UAAU3J,UAAU8I;QAC1B,OAAOY,aAAa,GAAGA,WAAWxJ,QAAQ,QAAQ,OAAOyJ,YAAY,IAAIA;AAC3E;IAEQ,2BAAMC,CACZ1D,WACAT,YACAoE,oBACGlI;QAEH,KAAK8D,YAAY;eACX,IAAIQ,uBAAwBT,cAAcU,WAAWT,YAAYoE,oBAAoBlI;AAC7F;IAGA,gBAAMmI,CACJrL,UACAqK,MACApD,UACAD,YACAoE,oBACGlI;QAEH,MAAMwE,gBAAgBvE,KAAKF,OACzB;YACEiE,QAAQlH;YACRqK;YACAiB,MAAMnI,KAAK6H,YAAYhG,WAAWqF;YAClCpD;cAEC/D;cAECC,KAAKgI,sBAAsBzD,QAAQnE,IAAIyD,YAAYoE,oBAAoBlI;eACvE,IAAI0E,uBAAwBa,eAAezI,UAAU0H,QAAQnE,OAAOL;QAC1E,OAAOwE;AACT;IAGA,iBAAM6D,CAAYpB,UAA8BjH;QAC9C,MAAMsI,SAASrB,MAAMxB,wBAAwBxF,KAAKG,QAAQ6G,MAAMxB,oBAAoBzF,QAAQ8B;QAC5F,MAAM0C,gBAAgBvE,KAAKF,OACzB;YACEiE,QAAQiD,MAAMnK;YACdwL,QAAQA,QAAQjI,MAAM4G,MAAMxB;YAC5B0B,MAAMF,MAAME;YACZiB,MAAMnI,KAAK6H,YAAYQ,QAAQF,MAAMnB,MAAME;YAC3CpD,UAAUkD,MAAMlD;cAEf/D;cAECC,KAAKgI,sBAAsBzD,QAAQnE,IAAI4G,MAAMnD,YAAYmD,MAAMiB,oBAAoBlI;QACzF,MAAMuI,iBAAiB,IAAI7D;cACrB6D,eAAehD,eAAe0B,MAAMnK,UAAU0H,QAAQnE,OAAOL;QACnE,IAAIiH,MAAMxB,iBAAiB;kBACnB8C,eAAe/C,+BACnByB,MAAMnK,UACNmK,MAAMxB,iBACNjB,QAAQnE,OACLL;AAEP;QACA,OAAOwE;AACT;IAEA,kBAAMgE,CAAa/C,oBAA4BzF;QAC7C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQM,WAAYrG,cAAcqG,QAAQ8D,QAAQ7C;AACzF;IAEA,wBAAMgD,CAAmB3L,aAAqBkD;QAC5C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQM,WAAYxG,WAAWwG,QAAQR,QAAQlH;AACtF;IAEA,4BAAM4L,CACJ5L,UACAyH,WACAoE,cAAc,UACX3I;QAEH,MAAM4I,qBAAoB,IAAIlE,uBAAwBO,gBAAgBnI,UAAUyH,cAAcvE;QAC9F,MAAM6I,MAAM,IAAI7C,IAAI4C,YAAYvJ,IAAKgF,OAAQnG,WAAWmG,IAAIO;QAC5D,IAAI+D,aAAaE,IAAIC,IAAIvE;QACzB,cAActE,KAAKwI,mBAAmB3L,aAAakD,OAAOkE,OAAQM,WAAYqE,IAAI1C,IAAI3B,QAAQnE;AAChG;IAEA,0BAAM0I,CACJjM,UACAyH,WACAoE,cAAc,UACX3I;QAEH,MAAMgJ,mBAAkB,IAAItE,uBAAwBC,cAAc7H,UAAUyH,cAAcvE;QAC1F,MAAM6I,MAAM,IAAI7C,IAAIgD,UAAU3J,IAAKgF,OAAQnG,WAAWmG,IAAIa;QAC1D,IAAIyD,aAAaE,IAAIC,IAAIvE;QACzB,cAActE,KAAKwI,mBAAmB3L,aAAakD,OAAOkE,OAAQM,WAAYqE,IAAI1C,IAAI3B,QAAQnE;AAChG;IAEA,mBAAM4I,CAAc1E,WAAmB4C,SAAiBnH;QACtD,MAAMS,iBAAiBR,KAAKG,QAAQmE,cAAcvE;QAClD,OAAOC,KAAKM,UACVgE,WACA;YAAE4C;YAAMiB,MAAMnI,KAAK6H,YAAYrH,SAAS2H,KAAKc,SAAS,OAAOzI,SAAS2H,KAAK7J,QAAQ,YAAY,MAAMuD,WAAWqF;cAC7GnH;AAEP;IAGM,iBAAAmJ,CACJrM,UACAyH,WACA6E,uBACGpJ;QAEH,MAAMqJ,kBAAkBpJ,KAAKG,QAAQgJ,uBAAuBpJ;QAC5D,MAAMS,iBAAiBR,KAAKG,QAAQmE,cAAcvE;QAClD,MAAMsJ,gBAAgBrJ,KAAKM,UACzBgE,WACA;YACE+D,QAAQe,UAAUhJ;YAClB+H,MAAMnI,KAAK6H,YAAYuB,UAAUjB,MAAM3H,SAAS0G;cAE/CnH;cAECC,KAAKsJ,qBAAqBzM,aAAakD;QAC7C,OAAOsJ;AACT;IAGA,0BAAMC,CAAqBzM,aAAqBkD;QAC9C,MAAMuI,iBAAiB,IAAI7D;QAC3B,MAAM8E,sBAAsBjB,eAAevH,WAAWhB;cAChD2H,iBACJY,gBACAiB,cAActF,OAAQG,OAAQrG,WAAWqG,IAAIL,QAAQlH,eAClDkD;QAGL,MAAMyJ,kBAAkBxJ,KAAKwI,mBAAmB3L,aAAakD,OAAO6E,KAAK,CAACC,MAAMC;YAC9E,MAAM2E,YAAY5E,KAAKsD,KAAKuB,MAAM,KAAKzF,OAAOhB,SAAS0G;YACvD,MAAMC,aAAa9E,MAAMqD,KAAKuB,MAAM,KAAKzF,OAAOhB,SAAS0G;YACzD,OAAOF,YAAYG;;QAGrB,KAAK,MAAMrF,WAAWiF,UAAU;kBACxBlB,eAAehD,eAAezI,UAAU0H,QAAQnE,OAAOL;YAC7D,IAAIwE,QAAQ8D,QAAQ;sBACZC,eAAe/C,+BACnB1I,UACAoB,WAAWsG,QAAQ8D,SACnB9D,QAAQnE,OACLL;AAEP;AACF;AACF;IAGM,uBAAA8J,CAAkBhN,UAAkByH,cAAsBvE;QAC9D,MAAMuI,iBAAiB,IAAI7D;QAC3B,MAAMkE,oBAAoB3I,KAAKyI,uBAAuB5L,UAAUyH,WAAW,SAASvE;QACpF,MAAM+F,gBAAgB,IAAIC,IAAI4C,YAAYvJ,IAAKmF,WAAYA,QAAQnE;QACnE,MAAMoJ,kBAAkBxJ,KAAKwI,mBAAmB3L,aAAakD,OAAOkE,OAAQM,WAC1EuB,cAAcI,IAAI3B,QAAQnE;cAEtBsH,iBAAe1H,MAAMwJ,aAAazJ;cAClCuI,eAAe1C,sBAAsB/I,UAAUyH,cAAcvE;AACrE;;;AAtJMsB,WAAA,EADLyI,uLAqBAlC,eAAAlG,WAAA,cAAA;;AAGKL,WAAA,EADLyI,uJAyBAlC,eAAAlG,WAAA,eAAA;;AA4CKL,WAAA,EADLyI,uKAmBAlC,eAAAlG,WAAA,eAAA;;AAGKL,WAAA,EADLyI,uJA2BAlC,eAAAlG,WAAA,wBAAA;;AAGKL,WAAA,EADLyI,+JAUAlC,eAAAlG,WAAA,qBAAA;;ACxLG,MAAOqI,oBAAoBxK;IAC/B,WAAAE;QACEE,MAAMoC;AACR;IAEA,gBAAMiI,CAAWhD,UAA2BjH;QAC1C,OAAOC,KAAKF,OACV;YACEmK,OAAOjD,MAAMiD;YACbC,OAAOlD,MAAMkD;YACbC,aAAanD,MAAMmD;cAElBpK;AAEP;IAEA,gBAAMqK,CAAWH,UAAkBlK;QACjC,cAAcC,KAAKe,WAAWhB,OAAOsK,KAAMC,QAASA,KAAKL,UAAUA;AACrE;IAEA,uBAAMM,CAAkBC,QAAgBL,gBAAwBpK;QAC9D,OAAOC,KAAKM,UAAUkK,QAAQ;YAAEL;cAAkBpK;AACpD;IAEA,iBAAM0K,CAAYD,QAAgBP,UAA8BlK;QAC9D,OAAOC,KAAKM,UAAUkK,QAAQ;YAAEP;cAAYlK;AAC9C;IAEA,iBAAM2K,CAAYF,QAAgBN,UAA8BnK;QAC9D,OAAOC,KAAKM,UAAUkK,QAAQ;YAAEN;cAAYnK;AAC9C;;;AC9BI,MAAO4K,yBAAyBpL;IACpC,WAAAE;QACEE,MAAMqD;AACR;IAEA,qBAAM4H,CACJ/N,UACAgO,MACAC,cACG/K;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACRgO;YACAC;cAEC/K;AAEP;IAEA,mBAAMgL,CACJlO,UACAgO,MACAC,cACG/K;QAEH,cAAcC,KAAKe,WAAWhB,OAAOsK,KAClCW,aACCjN,WAAWiN,UAAUjH,QAAQlH,aAC7BmO,UAAUH,SAASA,QACnBG,UAAUF,cAAcA;AAE9B;IAEA,2BAAMG,CACJpO,UACAgO,MACAC,cACG/K;QAEH,aAAcC,KAAK+K,cAAclO,UAAUgO,MAAMC,cAAc/K,eAAiBC,KAAK4K,gBAAgB/N,UAAUgO,MAAMC,cAAc/K;AACrI;IAEA,sBAAMmL,CAAiBrO,UAAkB2N,WAAmBzK;QAC1D,OAAOC,KAAKiL,sBAAsBpO,UAAU3B,cAAc6G,MAAMyI,WAAWzK;AAC7E;IAEA,uBAAMoL,CAAkBtO,UAAkBuO,YAAoBrL;QAC5D,OAAOC,KAAKiL,sBAAsBpO,UAAU3B,cAAcuI,OAAO2H,YAAYrL;AAC/E;;;AClDI,MAAOsL,gCAAgC9L;IAC3C,WAAAE;QACEE,MAAMyB;AACR;IAEA,qBAAMkK,CACJzO,UACA2N,QACAe,SAA2BtQ,iBAAiBuQ,WACzCzL;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACRyN,MAAME;YACNe;cAECxL;AAEP;IAEA,eAAM0L,CAAUC,cAAsBH,WAA6BxL;QACjE,OAAOC,KAAKM,UAAUoL,cAAc;YAAEH;cAAaxL;AACrD;IAEA,qBAAM4L,CAAgBnB,WAAmBzK;QACvC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe1N,cAAc0N,WAAWtB,MAAME;AAC7F;IAEA,qBAAMqB,CAAgBhP,aAAqBkD;QACzC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe7N,WAAW6N,WAAW7H,QAAQlH;AAC5F;IAEA,0BAAMiP,CAAqBJ,iBAAyB3L;cAC5CC,KAAKS,WAAWiL,iBAAiB3L;AACzC;;;ACnCI,MAAOgM,iCAAiCxM;IAC5C,WAAAE;QACEE,MAAM8C;AACR;IAEA,sBAAMuJ,CACJnP,UACAyH,WACAkG,QACAe,SAA2BtQ,iBAAiBuQ,WACzCzL;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACR0H,SAASD;YACTgG,MAAME;YACNe;cAECxL;AAEP;IAEA,eAAM0L,CAAUC,cAAsBH,WAA6BxL;QACjE,OAAOC,KAAKM,UAAUoL,cAAc;YAAEH;cAAaxL;AACrD;IAEA,sBAAMkM,CAAiBzB,WAAmBzK;QACxC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe1N,cAAc0N,WAAWtB,MAAME;AAC7F;IAEA,sBAAM0B,CAAiB5H,cAAsBvE;QAC3C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe1N,cAAc0N,WAAWrH,SAASD;AAChG;IAEA,2BAAM6H,CAAsBT,iBAAyB3L;cAC7CC,KAAKS,WAAWiL,iBAAiB3L;AACzC;;;ACtCI,MAAOqM,qBAAqB7M;IAChC,WAAAE;QACEE,MAAM8D;AACR;IAEA,iBAAM4I,CACJxP,UACAqK,MACA5C,WACAR,aACG/D;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACR0H,SAASD;YACT4C;YACApD;cAEC/D;AAEP;IAEA,iBAAMuM,CAAYlB,SAAiBlE,SAAiBnH;QAClD,OAAOC,KAAKM,UAAU8K,SAAS;YAAElE;cAAWnH;AAC9C;IAEA,wBAAMwM,CAAmBnB,SAAiB9G,cAAkCvE;QAC1E,OAAOC,KAAKM,UAAU8K,SAAS;YAAE7G,SAASD;cAAgBvE;AAC5D;IAEA,sBAAMyM,CAAiB3P,aAAqBkD;QAC1C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQwI,SAAU1O,WAAW0O,MAAM1I,QAAQlH;AAClF;;;AChCI,MAAO6P,+BAA+BnN;IAC1C,WAAAE;QACEE,MAAM6D;AACR;IAEA,yBAAMmJ,CACJ9P,UACAuO,SACAtO,aACAgH,aACG/D;QAEH,OAAOC,KAAKF,OACV;YACEiE,QAAQlH;YACR4P,OAAOrB;YACPJ,WAAWlO;YACXgH;cAEC/D;AAEP;IAEA,sBAAM6M,CAAiBxB,YAAoBrL;QACzC,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe1N,cAAc0N,WAAWa,OAAOrB;AAC9F;IAEA,yBAAMyB,CAAoB/P,gBAAwBiD;QAChD,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ2H,cAAe1N,cAAc0N,WAAWZ,WAAWlO;AAClG;IAEA,8BAAMgQ,CAAyBpB,iBAAyB3L;cAChDC,KAAKS,WAAWiL,iBAAiB3L;AACzC;IAEA,0CAAMgN,CAAqCjQ,gBAAwBiD;QACjE,MAAMiN,mBAAmB,IAAIrC;QAC7B,MAAMsC,oBAAoBjN,KAAK6M,oBAAoB/P,gBAAgBiD;QACnE,MAAMmN,mBAAmBnT,QAAQoT,IAC/BF,YAAY7N,IAAI9F,MAAOsS;YACrB,MAAM/O,WAAWoB,WAAW2N,WAAW7H;YACvC,MAAMqH,UAAUnN,WAAW2N,WAAWa;YACtC,MAAMzB,kBAAkBgC,iBAAiB7B,kBAAkBtO,UAAUuO,YAAYrL;YACjF,OAAOiL,UAAU5K;;QAGrB,OAAO8M;AACT;;;AC/CI,MAAOE,0BAA0B7N;IACrC,WAAAE;QACEE,MAAMiD;AACR;IAEA,sBAAMyK,CAAiBrG,UAAiCjH;QACtD,OAAOC,KAAKF,OACV;YACE1C,KAAK4J,MAAM5J;YACXyJ,UAAUG,MAAMH;YAChByG,aAAatG,MAAMsG;cAElBvN;AAEP;IAEA,cAAMwN,CAASnQ,QAAgB2C;QAC7B,cAAcC,KAAKe,WAAWhB,OAAOsK,KAAMtL,cAAeA,WAAW3B,QAAQA;AAC/E;IAEA,oBAAMoQ,CAAe3G,aAAiC9G;QACpD,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQlF,cAAeA,WAAW8H,aAAaA;AACtF;IAEA,uBAAM4G,CAAkBC,cAAsBJ,gBAAoCvN;QAChF,OAAOC,KAAKM,UAAUoN,cAAc;YAAEJ;cAAkBvN;AAC1D;;;AC1BI,MAAO4N,oBAAoBpO;IAC/B,WAAAE;QACEE,MAAMmD;AACR;IAEA,gBAAM8K,CAAW5G,UAA2BjH;QAC1C,OAAOC,KAAKF,OACV;YACEiE,QAAQiD,MAAMnK;YACdO,KAAK4J,MAAM5J;YACX8J,MAAMF,MAAME;YACZoG,aAAatG,MAAMsG;YACnBxJ,UAAUkD,MAAMlD;cAEf/D;AAEP;IAEA,wBAAM8N,CAAmBzQ,QAAgB2C;QACvC,MAAM+N,cAAc9N,KAAKe,WAAWhB,OAAOsK,KAAM0D,cAAeA,UAAUhK,UAAUgK,UAAU3Q,QAAQA;QACtG,KAAK0Q,MAAM;YACT,MAAM,IAAIE,MAAM,SAAS5Q;AAC3B;QACA,OAAO0Q;AACT;IAEA,wBAAMG,CAAmBpR,UAAkBO,QAAgB2C;QACzD,MAAM+N,cAAc9N,KAAKe,WAAWhB,OAAOsK,KACxC0D,aAAchQ,WAAWgQ,UAAUhK,QAAQlH,aAAakR,UAAU3Q,QAAQA;QAE7E,KAAK0Q,MAAM;YACT,MAAM,IAAIE,MAAM,SAAS5Q,6BAA6BP;AACxD;QACA,OAAOiR;AACT;IAEA,gBAAMI,CAAWC,QAAgBjH,SAAiBnH;QAChD,OAAOC,KAAKM,UAAU6N,QAAQ;YAAEjH;cAAWnH;AAC7C;IAEA,wBAAMqO,CACJD,QACArK,aACG/D;QAEH,OAAOC,KAAKM,UAAU6N,QAAQ;YAAErK;cAAe/D;AACjD;IAEA,qBAAMsO,CAAgBxR,UAAkByR,gBAAgB,UAAUvO;QAChE,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ6J,QAC3CQ,iBAAiBR,KAAK/J,UAAUhG,WAAW+P,KAAK/J,QAAQlH,YAAYkB,WAAW+P,KAAK/J,QAAQlH;AAEhG;;;ACnDFvD,eAAeoO,eACbC,SACA1B,SACGlG;IAEH,KAAK,MAAMqE,OAAO6B,MAAM;cAChB0B,QAAQlH,WAAW2D,IAAIhE,OAAOL;AACtC;AACF;;AAEM,MAAOwO,8BAA8BhP;IACzC,WAAAE;QACEE,MAAMkD;AACR;IAEA,yBAAM2L,CAAoBL,QAAgBT,iBAAyB3N;QACjE,OAAOC,KAAKF,OACV;YACEgO,MAAMK;YACNpP,YAAY2O;cAEX3N;AAEP;IAEA,4BAAM0O,CAAuBN,QAAgBpR,kBAA0BgD;QACrE,MAAMhB,oBAAmB,IAAIqO,mBAAoBG,SAASxQ,kBAAkBgD;QAC5E,OAAOC,KAAKwO,oBAAoBL,QAAQpP,WAAWqB,OAAOL;AAC5D;IAEA,8BAAM2O,CAAyBC,qBAA6B5O;cACpDC,KAAKS,WAAWkO,qBAAqB5O;AAC7C;IAEA,yBAAM6O,CAAoBT,WAAmBpO;QAC3C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ4K,kBAAmB3Q,cAAc2Q,eAAef,MAAMK;AACrG;IAEA,yBAAMW,CAAoBpB,iBAAyB3N;QACjD,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ4K,kBAAmB3Q,cAAc2Q,eAAe9P,YAAY2O;AAC3G;IAEA,4BAAMqB,CAAuBZ,QAAgBa,kBAA4BjP;QACvE,MAAMS,iBAAiBR,KAAK4O,oBAAoBT,WAAWpO;cACrD2H,eAAe1H,MAAMQ,aAAaT;QACxC,OAAOhG,QAAQoT,IAAI6B,cAAc5P,IAAKsO,gBAAiB1N,KAAKwO,oBAAoBL,QAAQT,iBAAiB3N;AAC3G;IAEA,+BAAMkP,CACJjI,OACAkI,mBACGnP;QAEH,MAAM+N,cAAa,IAAIH,aAAcC,WAAW5G,UAAUjH;QAC1D,KAAK,MAAMhD,iBAAiBmS,gBAAgB;kBACpClP,KAAKyO,uBAAuBX,KAAK1N,IAAIrD,kBAAkBgD;AAC/D;QACA,OAAO+N;AACT;;;AC3DI,MAAOqB,8BAA8B5P;IACzC,WAAAE;QACEE,MAAMoD;AACR;IAEA,gBAAMqM,CAAWpI,UAA2BjH;QAC1C,OAAOC,KAAKF,OACV;YACEiE,QAAQiD,MAAMnK;YACdmO,WAAWhE,MAAMlK;YACjBgR,MAAM9G,MAAMmH;YACZzQ,WAAWsJ,MAAMtJ;YACjBC,SAASqJ,MAAMrJ;YACf0R,aAAarI,MAAMqI,eAAe;YAClC5Q,UAAUuI,MAAMvI;YAChBC,WAAWsI,MAAMtI;YACjB4Q,YAAYtI,MAAMsI;cAEjBvP;AAEP;IAEA,sBAAMwP,CAAiBC,iBAAyBzP;cACxCC,KAAKS,WAAW+O,iBAAiBzP;AACzC;IAEA,8BAAM0P,CAAyB5S,UAAkBC,gBAAwBiD;QACvE,cAAcC,KAAKe,WAAWhB,OAAOkE,OAClCyL,cAAe3R,WAAW2R,WAAW3L,QAAQlH,aAAaqB,cAAcwR,WAAW1E,WAAWlO;AAEnG;IAEA,yBAAM6S,CAAoBxB,WAAmBpO;QAC3C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQyL,cAAexR,cAAcwR,WAAW5B,MAAMK;AAC7F;IAEA,2BAAMyB,CAAsB/S,aAAqBkD;QAC/C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQyL,cAAe3R,WAAW2R,WAAW3L,QAAQlH;AAC5F;IAEA,4BAAMgT,CACJL,cACA/Q,UACAC,cACGqB;QAEH,OAAOC,KAAKM,UAAUkP,cAAc;YAAE/Q;YAAUC;cAAgBqB;AAClE;;;ACxCI,MAAO+P,mCAAmCvQ;IAC9C,WAAAE;QACEE,MAAM+D;AACR;IAEA,sBAAMqM,CAAiBlT,UAAkBC,gBAAwBiD;QAC/D,cAAcC,KAAKe,WAAWhB,OAAOkE,OAClClF,cAAehB,WAAWgB,WAAWgF,QAAQlH,aAAaqB,cAAca,WAAWiM,WAAWlO;AAEnG;IAEA,kBAAMkT,CACJnT,UACAa,WACAC,YACGoC;QAEH,cAAcC,KAAKe,WAAWhB,OAAOkE,OAClClF,cAAehB,WAAWgB,WAAWgF,QAAQlH,aAAakC,WAAWrB,cAAcA,aAAaqB,WAAWpB,YAAYA;AAE5H;IAEA,mBAAMsS,CACJpT,UACAC,aACAC,eACAW,WACAC,SACAa,OACGuB;QAEH,cAAcC,KAAK+P,iBAAiBlT,UAAUC,gBAAgBiD,OAAOsF,KAClEtG,cACCA,WAAWhC,kBAAkBA,iBAC7BgC,WAAWrB,cAAcA,aACzBqB,WAAWpB,YAAYA,aACrBoB,WAAWN,aAAaD,MAAMO,WAAWN,YAAYD,SACrDO,WAAWL,cAAcF,MAAMO,WAAWL,aAAaF;AAE/D;IAEA,wBAAM0R,CAAmBrT,UAAkBC,gBAAwBiD;QACjE,KAAK,MAAMqE,aAAapE,KAAK+P,iBAAiBlT,UAAUC,gBAAgBiD,OAAO;kBACvEC,KAAKS,WAAW2D,IAAIhE,OAAOL;AACnC;AACF;IAEA,qBAAMoE,CAAgBtH,aAAqBkD;QACzC,KAAK,MAAMqE,cAAcpE,KAAKe,WAAWhB,OAAOkE,OAAQlF,cAAehB,WAAWgB,WAAWgF,QAAQlH,YAAY;kBACzGmD,KAAKS,WAAW2D,IAAIhE,OAAOL;AACnC;AACF;IAGM,yBAAAoQ,CAAoBtT,UAAkBC,gBAAwBiD;cAC5DC,KAAKkQ,mBAAmBrT,UAAUC,gBAAgBiD;QAExD,MAAMqQ,wBAAwB,IAAIjB;QAClC,MAAMkB,wBAAwB,IAAI9B;QAClC,MAAM+B,oBAAoB,IAAIlD;QAC9B,MAAMmD,yBAAyB,IAAI7D;QACnC,MAAMM,mBAAmB,IAAIrC;QAC7B,MAAM6F,wBAAwB,IAAI/L;QAClC,MAAMgM,0BAA0B,IAAItK;QAEpC,MAAMuK,eAA8C;QACpD,MAAMC,0BAA0BP,sBAAsBX,yBAAyB5S,UAAUC,gBAAgBiD;QACzG,MAAM6Q,yBAAyBL,uBAAuB1D,oBAAoB/P,gBAAgBiD;QAC1F,MAAM8Q,0BACE9W,QAAQoT,IACZyD,iBAAiBxR,IAAI9F,MAAOsS;YAC1B,MAAMkF,uBAAuB9D,iBAAiB7B,kBAAkBlN,WAAW2N,WAAW7H,SAAS9F,WAAW2N,WAAWa,WAAW1M;YAChI,OAAOqQ,sBAAsBX,yBAAyB5S,UAAUiU,eAAe1Q,OAAOL;aAG1FgR;QAEF,MAAMC,cAAc,KAAIL,sBAAsBE;QAC9C,KAAK,MAAMnB,cAAcsB,aAAa;YACpC,MAAMC,wBAAwBZ,sBAAsBzB,oBAAoB3Q,WAAWyR,WAAW5B,UAAU/N;YACxG,MAAMf,oBAAoBjF,QAAQoT,IAChC8D,gBAAgB7R,IAAI9F,MAAOuV,kBACzByB,kBAAkB5P,UAAU,MAAMzC,WAAW4Q,eAAe9P,gBAAyBgB;YAGzF,KAAK,MAAMhB,cAAcC,aAAa;gBACpC,KAAKD,YAAY;gBACjB,MAAMrB,YAAYgS,WAAWhS;gBAC7B,MAAMC,UAAU+R,WAAW/R;gBAC3B,MAAMuT,SAA2D;gBACjE,IAAIxT,cAAcvC,UAAUyG,QAAQ;oBAClCsP,OAAO1W,KAAK;wBAAEkD;wBAAWC,SAASd;;AACpC,uBAAO,IAAIa,cAAcvC,UAAUgW,UAAU;oBAC3CD,OAAO1W,KAAK;wBAAEkD;wBAAWC;;AAC3B,uBAAO,IAAID,cAAcvC,UAAU8D,YAAYyQ,WAAWL,aAAa;oBACrE6B,OAAO1W,KAAK;wBAAEkD;wBAAWC;;AAC3B,uBAAO,IAAID,cAAcvC,UAAU8D,WAAWyQ,WAAWL,aAAa;oBACpE,MAAM1G,oBAAoB6H,sBAAsBxL,gBAAgBnI,UAAUc,YAAYoC;oBACtFmR,OAAO1W,QAAQmO,YAAYvJ,IAAKgF,QAAG;wBAAQ1G;wBAAWC,SAASM,WAAWmG,IAAIO;;AAChF;gBAEA,KAAK,MAAMyM,UAAUF,QAAQ;oBAC3B,IACExT,cAAcvC,UAAU8D,WACxByQ,WAAWL,eACX+B,OAAOzT,YAAYA,iBACZ8S,wBAAwB7J,2BAC7B/J,UACAuU,OAAOzT,SACPA,SACAoB,WAAW8H,aACR9G,OAEL;wBACA;AACF;oBACA2Q,aAAalW,KAAK;wBAChB4F,IAAI;wBACJvD;wBACAC;wBACAC,eAAegC,WAAW3B;wBAC1BM,WAAW0T,OAAO1T;wBAClBC,SAASyT,OAAOzT;wBAChB0T,YAAY;wBACZC,UAAU5B,WAAWtP;wBACrB3B,UAAUiR,WAAWjR;wBACrBC,WAAWgR,WAAWhR;;AAE1B;AACF;AACF;QAEA,MAAM6S,gBAAgBxX,QAAQoT,IAC5BuD,aAAatR,IAAKL,cAChBiB,KAAKF,OACH;YACEiE,QAAQhF,WAAWlC;YACnBmO,WAAWjM,WAAWjC;YACtBC,eAAegC,WAAWhC;YAC1BW,WAAWqB,WAAWrB;YACtBC,SAASoB,WAAWpB;YACpB0T,YAAYtS,WAAWsS;YACvBC,UAAUvS,WAAWuS;YACrB7S,UAAUM,WAAWN;YACrBC,WAAWK,WAAWL;cAErBqB;QAIT,OAAOwR;AACT;IAGA,sBAAMC,CAAiB3U,aAAqBkD;QAC1C,MAAMmN,qBAAoB,IAAIvC,kBAAmB5J,WAAWhB,OAAOkE,OAAQ+G,aAAcjN,WAAWiN,UAAUjH,QAAQlH;QACtH,KAAK,MAAMmO,aAAakC,YAAY;kBAC5BlN,KAAKmQ,oBAAoBtT,UAAUmO,UAAU5K,OAAOL;AAC5D;AACF;;;AAzGMsB,WAAA,EADLyI,+JAkGAgG,2BAAApO,WAAA,uBAAA;;AAGKL,WAAA,EADLyI,uJAMAgG,2BAAApO,WAAA,oBAAA;;ACtKG,MAAO+P,iCAAiClS;IAC5C,WAAAE;QACEE,MAAMwD;AACR;IAEA,sBAAMuO,CAAiB1K,UAAiCjH;QACtD,OAAOC,KAAKF,OACV;YACEiE,QAAQiD,MAAMnK;YACd0H,SAASyC,MAAM1C;YACfqN,cAAc3K,MAAM2K;YACpBrS,YAAY0H,MAAM1H;YAClBsS,YAAY5K,MAAM4K;YAClBC,OAAO7K,MAAM8K;YACbC,aAAa/K,MAAM+K;YACnBjO,UAAUkD,MAAMlD;cAEf/D;AAEP;IAEA,yBAAMiS,CAAoBnV,UAAkB8U,cAAsBrS,eAAuBS;QACvF,cAAcC,KAAKe,WAAWhB,OAAOsK,KAClC4H,YAAalU,WAAWkU,SAASlO,QAAQlH,aAAaoV,SAASN,iBAAiBA,gBAAgBM,SAAS3S,eAAeA;AAE7H;IAEA,2BAAM4S,CAAsBC,qBAA6B7N,cAAsBvE;QAC7E,OAAOC,KAAKM,UAAU6R,qBAAqB;YAAE5N,SAASD;cAAgBvE;AACxE;IAEA,mBAAMqS,CAAcD,qBAA6BP,eAAmC7R;QAClF,OAAOC,KAAKM,UAAU6R,qBAAqB;YAAEP;cAAiB7R;AAChE;IAEA,uBAAMsS,CAAkBF,qBAA6BL,qBAAyC/R;QAC5F,OAAOC,KAAKM,UAAU6R,qBAAqB;YAAEN,OAAOC;cAAuB/R;AAC7E;IAEA,0BAAMuS,CAAqBhO,cAAsBvE;QAC/C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQgO,YAAa/T,cAAc+T,SAAS1N,SAASD;AAC5F;IAEA,yBAAMiO,CAAoB1V,aAAqBkD;QAC7C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQgO,YAAalU,WAAWkU,SAASlO,QAAQlH;AACxF;;;AC7CI,MAAO2V,6BAA6BjT;IACxC,WAAAE;QACEE,MAAMuD;AACR;IAEA,mBAAMuP,CAAczL,UAA8BjH;QAChD,OAAOC,KAAKF,OACV;YACEiE,QAAQiD,MAAMnK;YACdoV,UAAUjL,MAAM1H;YAChB0L,WAAWhE,MAAMlK;YACjBC,eAAeiK,MAAMjK;YACrB0B,UAAUuI,MAAMvI;YAChBC,WAAWsI,MAAMtI;YACjB4Q,YAAYtI,MAAMsI;YAClBoD,WAAW1L,MAAM2L;cAEhB5S;AAEP;IAEA,iBAAM6S,CAAYC,YAAoB9S;cAC9BC,KAAKS,WAAWoS,YAAY9S;AACpC;IAEA,wBAAM+S,CAAmBX,wBAAgCpS;QACvD,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ5E,SAAUnB,cAAcmB,MAAM4S,UAAUE;AACvF;IAEA,yBAAMY,CAAoBlW,UAAkBC,gBAAwBiD;QAClE,cAAcC,KAAKe,WAAWhB,OAAOkE,OAClC5E,SAAUtB,WAAWsB,MAAM0E,QAAQlH,aAAaqB,cAAcmB,MAAM2L,WAAWlO;AAEpF;IAEA,cAAMkW,CACJnW,UACAC,aACAqV,qBACApV,eACAyB,OACGuB;QAEH,cAAcC,KAAK+S,oBAAoBlW,UAAUC,gBAAgBiD,OAAOsF,KACrEhG,SACCnB,cAAcmB,MAAM4S,UAAUE,wBAC9B9S,MAAMtC,kBAAkBA,mBACtBsC,MAAMZ,aAAaD,MAAMa,MAAMZ,YAAYD,SAC3Ca,MAAMX,cAAcF,MAAMa,MAAMX,aAAaF;AAErD;IAEA,0BAAMyU,CAAqBd,wBAAgCpS;QACzD,KAAK,MAAMqE,aAAapE,KAAK8S,mBAAmBX,wBAAwBpS,OAAO;kBACvEC,KAAKS,WAAW2D,IAAIhE,OAAOL;AACnC;AACF;;;MCvDWmT;IACX,wBAAMC,CAAmBhB,wBAAgCpS;eACjD,IAAIyS,sBAAuBS,qBAAqBd,wBAAwBpS;eACxE,IAAI0R,0BAA2BhR,WAAW0R,wBAAwBpS;AAC1E;IAEA,0BAAMqT,CACJjB,wBACGpS;QAOH,MAAMkS,kBAAiB,IAAIR,0BAA2BtR,QAAQgS,wBAAwBpS;QACtF,OAAO;YACLlD,UAAUoB,WAAWgU,SAASlO;YAC9BO,WAAWrG,WAAWgU,SAAS1N;YAC/BqN,YAAYK,SAASL;YACrBE,kBAAkBG,SAASJ,QAAQ5T,WAAWgU,SAASJ,SAAShQ;;AAEpE;;;ACvBI,MAAOwR,8BAA8B9T;IACzC,WAAAE;QACEE,MAAM0D;AACR;IAEA,mBAAMiQ,CAActM,UAAqCjH;QACvD,OAAOC,KAAKF,OACV;YACEiE,QAAQiD,MAAMnK;YACd0W,aAAavM,MAAMuM;YACnBC,aAAaxM,MAAMwM;YACnBC,YAAYzM,MAAMyM;YAClBC,QAAQ1M,MAAM0M;YACdC,QAAQ3M,MAAM2M;cAEb5T;AAEP;IAEA,wBAAM6T,CAAmB/W,aAAqBkD;QAC5C,cAAcC,KAAKe,WAAWhB,OAAOkE,OAAQ4P,WAAY5V,WAAW4V,QAAQ9P,YAAYlH;AAC1F;IAEA,gBAAMiX,CAAWjX,UAAkB0W,gBAA6BxT;QAC9D,cAAcC,KAAK4T,mBAAmB/W,aAAakD,OAAOsK,KAAMwJ,WAAYA,QAAQN,gBAAgBA;AACtG;IAEA,sBAAMQ,CACJC,WACAL,WACG5T;QAEH,OAAOC,KAAKM,UAAU0T,WAAW;YAAEL;cAAa5T;AAClD;IAEA,wBAAMkU,CACJD,WACAP,YACAC,QACAC,WACG5T;QAEH,OAAOC,KAAKM,UAAU0T,WAAW;YAAER,aAAajY,mBAAmB2Y;YAAWT;YAAYC;YAAQC;cAAa5T;AACjH;IAEA,eAAMoU,CACJH,WACAP,YACAC,QACAC,WACG5T;QAEH,OAAOC,KAAKM,UAAU0T,WAAW;YAAER,aAAajY,mBAAmB6Y;YAAQX;YAAYC;YAAQC;cAAa5T;AAC9G;;;MCrCWsU;IAAb,WAAA5U;QACUO,KAAAsU,gBAAgB,IAAIxN;QACpB9G,KAAAuU,uBAAuB,IAAI5Q;QAC3B3D,KAAAwU,iBAAiB,IAAI5M;QACrB5H,KAAAyU,wBAAwB,IAAIpQ;QAC5BrE,KAAA0U,cAAc,IAAI3K;QAClB/J,KAAA2U,oBAAoB,IAAItJ;QACxBrL,KAAAgN,mBAAmB,IAAIrC;QACvB3K,KAAAsQ,oBAAoB,IAAIlD;QACxBpN,KAAA4U,cAAc,IAAIjH;QAClB3N,KAAAqQ,wBAAwB,IAAI9B;QAC5BvO,KAAAoQ,wBAAwB,IAAIjB;QAC5BnP,KAAA6U,6BAA6B,IAAI/E;AA6E3C;IA1EE,iCAAMgF,CACJC,aACGhV;QAEH,MAAMgE,eAAe/D,KAAKsU,cAAcvN,aAAagO,SAAShR,WAAWhE;QACzE,IAAIgV,SAAShR,OAAOF,YAAY;kBACxB7D,KAAKuU,qBAAqB3Q,cAAcG,OAAO3D,IAAI2U,SAAShR,OAAOF,YAAYkR,SAAShR,OAAOkE,oBAAoBlI;AAC3H;QAEA,MAAMiV,gBAAgB1b,OAAO2b,UAA8B1Q;YACzD,MAAMgN,UACJ0D,aAAapT,kBACH7B,KAAKwU,eAAetM,WAAWnE,OAAO3D,IAAImE,QAAQ2C,MAAM3C,QAAQT,UAAUS,QAAQV,YAAYU,QAAQT,aAAa/D,cACnHC,KAAKwU,eAAepM,YACxB;gBACEvL,UAAUkH,OAAO3D;gBACjBoF,iBAAiByP;gBACjB/N,MAAM3C,QAAQ2C;gBACdpD,UAAUS,QAAQT;gBAClBD,YAAYU,QAAQV;gBACpBoE,iBAAiB1D,QAAQT;kBAExB/D;YAEX,KAAK,MAAM7F,SAASqK,QAAQ2Q,YAAY,IAAI;sBACpCF,cAAczD,QAAQnR,IAAIlG;AAClC;YACA,OAAOqX;;QAGT,MAAM4D,oBAAoBH,cAAcnT,WAAWkT,SAASI;QAC5D,MAAMtD,cAAc7R,KAAK0U,YAAY1K,WAAW+K,SAASK,cAAcrV;cACjEC,KAAK2U,kBAAkBrJ,gBAAgBvH,OAAO3D,IAAIyR,MAAMzR,IAAInF,iBAAiBuQ,WAAWzL;QAC9F,MAAMsV,uBAAuBrV,KAAKgN,iBAAiB9B,iBAAiBnH,OAAO3D,IAAIyR,MAAMzR,OAAOL;QAE5F,KAAK,MAAMhB,cAAcgW,SAAS/V,aAAa;kBACvCgB,KAAKsQ,kBAAkBjD,iBAAiBtO,eAAegB;AAC/D;QACA,KAAK,MAAM+N,QAAQiH,SAASO,OAAO;YACjC,MAAMC,oBAAoBvV,KAAK4U,YAAYhH,WACzC;gBACE/Q,UAAUkH,OAAO3D;gBACjBhD,KAAK0Q,KAAK1Q;gBACV8J,MAAM4G,KAAK5G;gBACXoG,aAAaQ,KAAKR;kBAEjBvN;YAEL,KAAK,MAAMhD,iBAAiB+Q,KAAKoB,gBAAgB;sBACzClP,KAAKqQ,sBAAsB5B,uBAAuB8G,YAAYnV,IAAIrD,kBAAkBgD;AAC5F;AACF;QAEA,MAAMyV,kBAAkBxV,KAAK4U,YAAY3G,mBAAmBlK,OAAO3D,IAAI2U,SAASU,iBAAiB1V;cAC3FC,KAAKoQ,sBAAsBhB,WAC/B;YACEvS,UAAUkH,OAAO3D;YACjBtD,aAAauY,eAAejV;YAC5B+N,QAAQqH,UAAUpV;YAClB1C,WAAWvC,UAAU8D;YACrBtB,SAASwX,YAAY/U;YACrBiP,aAAa;cAEZtP;cAECC,KAAK6U,2BAA2B1E,oBAAoBpM,OAAO3D,IAAIiV,eAAejV,OAAOL;QAE3F,OAAO;YACLlD,UAAUkH,OAAO3D;YACjBsV,eAAeP,YAAY/U;YAC3BuV,aAAa9D,MAAMzR;YACnB0R,kBAAkBuD,eAAejV;;AAErC;;;AAzEMiB,WAAA,EADLyI,uJA0EAuK,iBAAA3S,WAAA,+BAAA;;MCnGUkU;IAAb,WAAAnW;QACUO,KAAA2U,oBAAoB,IAAItJ;QACxBrL,KAAA6V,uBAAuB,IAAI9J;QAC3B/L,KAAAgN,mBAAmB,IAAIrC;QACvB3K,KAAA4U,cAAc,IAAIjH;QAClB3N,KAAAoQ,wBAAwB,IAAIjB;QAC5BnP,KAAA6U,6BAA6B,IAAI/E;AAoE3C;IAjEE,mCAAMgG,CACJjZ,UACA2N,QACAlG,WACAyR,YACGhW;cAEGC,KAAK2U,kBAAkBrJ,gBAAgBzO,UAAU2N,QAAQvP,iBAAiBuQ,WAAWzL;cACrFC,KAAK6V,qBAAqB7J,iBAAiBnP,UAAUyH,WAAWkG,QAAQvP,iBAAiBuQ,WAAWzL;QAC1G,MAAMiL,kBAAkBhL,KAAKgN,iBAAiB9B,iBAAiBrO,UAAU2N,WAAWzK;QACpF,MAAM+N,aAAa9N,KAAK4U,YAAY3G,mBAAmBpR,UAAUkZ,YAAYhW;cACvEC,KAAKoQ,sBAAsBhB,WAC/B;YACEvS;YACAC,aAAakO,UAAU5K;YACvB+N,QAAQL,KAAK1N;YACb1C,WAAWvC,UAAU8D;YACrBtB,SAAS2G;YACT+K,aAAa;cAEZtP;cAECC,KAAK6U,2BAA2B1E,oBAAoBtT,UAAUmO,UAAU5K,OAAOL;QACrF,OAAO;YAAEjD,aAAakO,UAAU5K;;AAClC;IAGA,uBAAM4V,CACJnZ,UACAC,aACAwH,WACAyR,SACA1G,gBACGtP;QAEH,MAAM+N,aAAa9N,KAAK4U,YAAY3G,mBAAmBpR,UAAUkZ,YAAYhW;QAC7E,MAAMkW,2BAA2BjW,KAAKoQ,sBAAsBX,yBAAyB5S,UAAUC,gBAAgBiD;QAC/G,KAAK,MAAM2P,cAAcuG,mBAAmBhS,OAAQG,OAAQA,IAAI1G,cAAcvC,UAAU8D,WAAWmF,IAAIzG,YAAY2G,YAAY;kBACvHtE,KAAKoQ,sBAAsBb,iBAAiBG,WAAWtP,OAAOL;AACtE;cACMC,KAAKoQ,sBAAsBhB,WAC/B;YACEvS;YACAC;YACAqR,QAAQL,KAAK1N;YACb1C,WAAWvC,UAAU8D;YACrBtB,SAAS2G;YACT+K;cAECtP;cAECC,KAAK6U,2BAA2B1E,oBAAoBtT,UAAUC,gBAAgBiD;AACtF;IAGM,yBAAAmW,CAAoBC,oBAA4BtZ,UAAkBC,gBAAwBiD;cACxFC,KAAK2U,kBAAkBlJ,UAAU0K,oBAAoBlb,iBAAiBmb,cAAcrW;cACpFC,KAAK6U,2BAA2B3E,mBAAmBrT,UAAUC,gBAAgBiD;AACrF;IAGM,4BAAAsW,CAAuBF,oBAA4BtZ,UAAkBC,gBAAwBiD;cAC3FC,KAAK2U,kBAAkBlJ,UAAU0K,oBAAoBlb,iBAAiBuQ,WAAWzL;cACjFC,KAAK6U,2BAA2B1E,oBAAoBtT,UAAUC,gBAAgBiD;AACtF;;;AAhEMsB,WAAA,EADLyI,+KAyBA8L,wBAAAlU,WAAA,iCAAA;;AAGKL,WAAA,EADLyI,wLA0BA8L,wBAAAlU,WAAA,qBAAA;;AAGKL,WAAA,EADLyI,uKAIA8L,wBAAAlU,WAAA,uBAAA;;AAGKL,WAAA,EADLyI,uKAIA8L,wBAAAlU,WAAA,0BAAA;;AC9EH,SAASjE,SAASC,WAAsBC;IACtC,OAAO,GAAGD,aAAaC;AACzB;;MAEa2Y;IAGX,WAAA7W,CAAY8W,cAAgC;QAC1CvW,KAAKuW,cAAcA;AACrB;IAEA,eAAMC,CAAUxP,UAA0BjH;QACxC,MAAMvB,KAAKwI,MAAMxI,MAAM,IAAIX;QAE3B,IAAImJ,MAAMtJ,aAAasJ,MAAMrJ,SAAS;YACpC,MAAMqB,qBAAoBgB,KAAKuW,YAAYE,mCAAmCzP,MAAMnK,UAAUmK,MAAMtJ,WAAWsJ,MAAMrJ;YACrH,OAAOG,QAAQkB,aAAaqG,KACzBtG,cAAeA,WAAWhC,kBAAkBiK,MAAMjK,iBAAiBwB,YAAYC,IAAIO,WAAWN,UAAUM,WAAWL;AAExH;QAEA,KAAKsI,MAAM0P,qBAAqB,OAAO;QAEvC,MAAMzE,kBAAiBjS,KAAKuW,YAAYI,eAAe3P,MAAMnK,UAAUmK,MAAM0P;QAC7E,KAAKzE,UAAU,OAAO;QACtB,IAAIA,SAASpV,aAAamK,MAAMnK,UAAU,OAAO;QAEjD,IAAIoV,SAASH,qBAAqB9K,MAAMlK,aAAa,OAAO;QAE5D,MAAMqC,SAASrB,eAAckC,KAAKuW,YAAYzD,qBAAqB9L,MAAMnK,UAAUmK,MAAM0P,uBAAsBzS,OAC5G5E,SAAUA,MAAMvC,gBAAgBkK,MAAMlK,eAAeuC,MAAMtC,kBAAkBiK,MAAMjK,iBAAiBwB,YAAYC,IAAIa,MAAMZ,UAAUY,MAAMX;QAE7I,IAAIS,OAAOwK,SAAS,GAAG,OAAO;QAE9B,MAAMiI,aAAaK,SAASL;QAC5B,IAAIA,eAAevW,mBAAmBub,WAAWhF,eAAevW,mBAAmBwb,aAAa;YAC9F,OAAO;AACT;QAEA,IAAIjF,eAAevW,mBAAmB4D,WAAW2S,eAAevW,mBAAmByb,YAAY;YAC7F,MAAMC,uBAAuBjZ,eACrBkC,KAAKuW,YAAYE,mCAAmCzP,MAAMnK,UAAU1B,UAAU8D,SAASgT,SAAS3N;YAExG,OAAOyS,qBAAqB1R,KACzBtG,cAAeA,WAAWhC,kBAAkBiK,MAAMjK,iBAAiBwB,YAAYC,IAAIO,WAAWN,UAAUM,WAAWL;AAExH;QAEA,IAAIkT,eAAevW,mBAAmBuG,QAAQ;YAC5C,MAAMmV,uBAAuBjZ,eACrBkC,KAAKuW,YAAYE,mCAAmCzP,MAAMnK,UAAU1B,UAAUyG,QAAQoF,MAAMnK;YAEpG,OAAOka,qBAAqB1R,KACzBtG,cAAeA,WAAWhC,kBAAkBiK,MAAMjK,iBAAiBwB,YAAYC,IAAIO,WAAWN,UAAUM,WAAWL;AAExH;QAEA,OAAO;AACT;IAEA,mBAAMsY,CAAchQ,UAA0BjH;QAC5C,WAAYC,KAAKwW,UAAUxP,UAAUjH,OAAQ;YAC3C,MAAM,IAAIkX,mBACR,qBAAqBjQ,MAAMjK,oBAAoBiK,MAAM0P,uBAAuBjZ,SAASuJ,MAAMtJ,aAAavC,UAAUgW,UAAUnK,MAAMrJ,WAAW;AAEjJ;AACF;IAEA,wBAAMiB,CAAmB/B,UAAkBC,gBAAwBiD;QACjE,MAAMf,cAAclB,eAAckC,KAAKuW,YAAYW,2BAA2Bra,UAAUC;QACxF,MAAMqC,SAASrB,eAAckC,KAAKuW,YAAYxD,sBAAsBlW,UAAUC;QAC9E,OAAO8B,mBAAmB;YACxB/B;YACAC;YACAkC;YACAG;;AAEJ;IAEA,wBAAMvC,CAAmBC,UAAkBC,aAAqBC,kBAA0BgD;QACxF,MAAMoX,eAAenX,KAAKpB,mBAAmB/B,UAAUC,gBAAgBiD;QACvE,MAAM/C,oBAAoBma,OAAOrY,8BAA8B/B,kBAAkB;QACjF,MAAME,qBAAqBka,OAAOjY,eAAe+E,OAAQ5E,SAAUA,MAAMtC,kBAAkBA,eAAeqC,IAAKC,SAAUA,MAAMC;QAC/H,OAAO1C,mBAAmB;YAAEC;YAAUC;YAAaC;YAAeC;YAAmBC;;AACvF;IAEA,uBAAMC,CAAkBL,UAAkBC,aAAqBC,kBAA0BgD;QACvF,MAAMoX,eAAenX,KAAKpB,mBAAmB/B,UAAUC,gBAAgBiD;QACvE,MAAM/C,oBAAoBma,OAAOrY,8BAA8B/B,kBAAkB;QACjF,MAAME,qBAAqBka,OAAOjY,eAAe+E,OAAQ5E,SAAUA,MAAMtC,kBAAkBA,eAAeqC,IAAKC,SAAUA,MAAMC;QAC/H,OAAOpC,kBAAkB;YAAEL;YAAUC;YAAaC;YAAeC;YAAmBC;;AACtF;;;ACvFK,MAAMma,UAAkB;;AAExB,MAAMC,SAAS;;AAEf,MAAMC,eAAe;;AAErB,MAAMC,eAAuB;;"}