@nextsparkjs/core 0.1.0-beta.74 → 0.1.0-beta.76

package/dist/lib/services/namespace.service.d.ts

@@ -0,0 +1,168 @@
+/**
+ * NamespaceService - Provides runtime i18n namespace queries
+ *
+ * This service layer abstracts namespace-registry access, making the registry
+ * a pure data structure (Data-Only pattern). All query logic lives here.
+ *
+ * Performance: All operations are O(1) with zero I/O.
+ *
+ * @example
+ * ```typescript
+ * import { NamespaceService } from './'
+ *
+ * // Get core namespaces
+ * const core = NamespaceService.getCoreNamespaces()
+ * // ['common', 'dashboard', 'settings', ...]
+ *
+ * // Detect route strategy from pathname
+ * const strategy = NamespaceService.detectRouteStrategy('/dashboard/tasks')
+ * // 'DASHBOARD_AUTHENTICATED'
+ *
+ * // Get optimized namespaces for a strategy
+ * const config = NamespaceService.getOptimizedNamespaces(strategy)
+ * // { core: [...], entities: [...], strategy: '...' }
+ * ```
+ */
+import { type RouteNamespaceConfig, type NamespaceConfig } from '@nextsparkjs/registries/namespace-registry';
+export type { RouteNamespaceConfig, NamespaceConfig };
+/**
+ * Route strategy types
+ */
+export type RouteStrategy = 'DASHBOARD_AUTHENTICATED' | 'AUTH_ONLY' | 'PUBLIC_INITIAL' | 'SUPERADMIN' | 'UNKNOWN_FALLBACK';
+/**
+ * NamespaceService
+ *
+ * Static service class for i18n namespace queries.
+ * All methods are static - this class is not meant to be instantiated.
+ */
+export declare class NamespaceService {
+    /**
+     * Get core namespaces (excluding entity namespaces)
+     *
+     * @returns Array of core namespace names
+     *
+     * @example
+     * ```typescript
+     * const namespaces = NamespaceService.getCoreNamespaces()
+     * // ['common', 'dashboard', 'settings', 'auth', 'public', 'validation', 'admin']
+     * ```
+     */
+    static getCoreNamespaces(): string[];
+    /**
+     * Get entity namespaces
+     *
+     * @returns Array of entity namespace names
+     *
+     * @example
+     * ```typescript
+     * const namespaces = NamespaceService.getEntityNamespaces()
+     * // [] (empty if no entity namespaces configured)
+     * ```
+     */
+    static getEntityNamespaces(): string[];
+    /**
+     * Get optimized namespaces based on route strategy
+     *
+     * Returns the namespace configuration for a specific route strategy.
+     * Falls back to UNKNOWN_FALLBACK if strategy is not found.
+     *
+     * @param strategy - The route strategy name
+     * @returns Namespace configuration for the strategy
+     *
+     * @example
+     * ```typescript
+     * const config = NamespaceService.getOptimizedNamespaces('DASHBOARD_AUTHENTICATED')
+     * // { core: ['common', 'dashboard', ...], entities: [], strategy: 'DASHBOARD_AUTHENTICATED' }
+     * ```
+     */
+    static getOptimizedNamespaces(strategy: string): RouteNamespaceConfig;
+    /**
+     * Detect route strategy based on pathname
+     *
+     * Analyzes the pathname to determine which route strategy should be used.
+     * This affects which namespaces are loaded for i18n optimization.
+     *
+     * @param pathname - The URL pathname to analyze
+     * @returns The detected route strategy
+     *
+     * @example
+     * ```typescript
+     * NamespaceService.detectRouteStrategy('/dashboard') // 'DASHBOARD_AUTHENTICATED'
+     * NamespaceService.detectRouteStrategy('/login') // 'AUTH_ONLY'
+     * NamespaceService.detectRouteStrategy('/pricing') // 'PUBLIC_INITIAL'
+     * NamespaceService.detectRouteStrategy('/superadmin') // 'SUPERADMIN'
+     * NamespaceService.detectRouteStrategy('/unknown') // 'UNKNOWN_FALLBACK'
+     * ```
+     */
+    static detectRouteStrategy(pathname: string): RouteStrategy;
+    /**
+     * Get entity paths for namespace route detection
+     *
+     * @returns Array of entity paths used in route detection
+     *
+     * @example
+     * ```typescript
+     * const paths = NamespaceService.getEntityPaths()
+     * // [] (empty if no entity paths configured)
+     * ```
+     */
+    static getEntityPaths(): string[];
+    /**
+     * Get all available route strategies
+     *
+     * @returns Array of all route strategy names
+     *
+     * @example
+     * ```typescript
+     * const strategies = NamespaceService.getStrategies()
+     * // ['DASHBOARD_AUTHENTICATED', 'AUTH_ONLY', 'PUBLIC_INITIAL', 'SUPERADMIN', 'UNKNOWN_FALLBACK']
+     * ```
+     */
+    static getStrategies(): string[];
+    /**
+     * Check if a route strategy exists
+     *
+     * @param strategy - The strategy name to check
+     * @returns True if the strategy exists
+     *
+     * @example
+     * ```typescript
+     * NamespaceService.hasStrategy('DASHBOARD_AUTHENTICATED') // true
+     * NamespaceService.hasStrategy('INVALID') // false
+     * ```
+     */
+    static hasStrategy(strategy: string): boolean;
+    /**
+     * Get the full namespace configuration
+     *
+     * @returns The complete namespace configuration object
+     *
+     * @example
+     * ```typescript
+     * const config = NamespaceService.getConfig()
+     * // { core: [...], entities: [...], routes: {...}, entityPaths: [...] }
+     * ```
+     */
+    static getConfig(): NamespaceConfig;
+}
+/**
+ * @deprecated Use NamespaceService.getCoreNamespaces() instead
+ */
+export declare const getCoreNamespaces: typeof NamespaceService.getCoreNamespaces;
+/**
+ * @deprecated Use NamespaceService.getEntityNamespaces() instead
+ */
+export declare const getEntityNamespaces: typeof NamespaceService.getEntityNamespaces;
+/**
+ * @deprecated Use NamespaceService.getOptimizedNamespaces() instead
+ */
+export declare const getOptimizedNamespaces: typeof NamespaceService.getOptimizedNamespaces;
+/**
+ * @deprecated Use NamespaceService.detectRouteStrategy() instead
+ */
+export declare const detectRouteStrategy: typeof NamespaceService.detectRouteStrategy;
+/**
+ * @deprecated Use NamespaceService.getEntityPaths() instead
+ */
+export declare const getEntityNamespacePaths: typeof NamespaceService.getEntityPaths;
+//# sourceMappingURL=namespace.service.d.ts.map

package/dist/lib/services/namespace.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/namespace.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACrB,MAAM,4CAA4C,CAAA;AAGnD,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,CAAA;AAErD;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,yBAAyB,GACzB,WAAW,GACX,gBAAgB,GAChB,YAAY,GACZ,kBAAkB,CAAA;AAEtB;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,iBAAiB,IAAI,MAAM,EAAE;IAKpC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,mBAAmB,IAAI,MAAM,EAAE;IAKtC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB;IAIrE;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa;IAwC3D;;;;;;;;;;OAUG;IACH,MAAM,CAAC,cAAc,IAAI,MAAM,EAAE;IAKjC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,aAAa,IAAI,MAAM,EAAE;IAIhC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI7C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,SAAS,IAAI,eAAe;CAGpC;AAQD;;GAEG;AACH,eAAO,MAAM,iBAAiB,2CAAqC,CAAA;AAEnE;;GAEG;AACH,eAAO,MAAM,mBAAmB,6CAAuC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,sBAAsB,gDAA0C,CAAA;AAE7E;;GAEG;AACH,eAAO,MAAM,mBAAmB,6CAAuC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,uBAAuB,wCAAkC,CAAA"}

package/dist/lib/services/pattern-usage.service.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Pattern Usage Service
+ *
+ * Tracks which entities (pages, posts, etc.) use each pattern.
+ * Provides sync, query, and count operations for pattern usage tracking.
+ *
+ * @module PatternUsageService
+ */
+import type { BlockInstance } from '../../types/blocks';
+import type { PatternReference } from '../../types/pattern-reference';
+export interface PatternUsage {
+    id: string;
+    patternId: string;
+    entityType: string;
+    entityId: string;
+    teamId: string;
+    createdAt: string;
+}
+export interface PatternUsageWithEntityInfo extends PatternUsage {
+    entityTitle?: string;
+    entityName?: string;
+    entityFirstName?: string;
+    entityLastName?: string;
+    entityEmail?: string;
+    entitySlug?: string;
+    entityStatus?: string;
+    entityUpdatedAt?: string;
+}
+export interface PatternUsageCount {
+    entityType: string;
+    count: number;
+}
+export interface GetUsagesOptions {
+    entityType?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface GetUsagesResult {
+    usages: PatternUsageWithEntityInfo[];
+    counts: PatternUsageCount[];
+    total: number;
+}
+export declare class PatternUsageService {
+    /**
+     * Sync pattern usages for an entity
+     *
+     * Extracts pattern references from blocks and updates the usage table.
+     * Uses diff-based approach: only adds new and removes old references.
+     *
+     * @param entityType - Type of entity (e.g., 'pages', 'posts')
+     * @param entityId - ID of the entity
+     * @param teamId - Team ID for isolation
+     * @param blocks - Array of blocks that may contain pattern references
+     * @param userId - User ID for RLS
+     */
+    static syncUsages(entityType: string, entityId: string, teamId: string, blocks: (BlockInstance | PatternReference)[], userId: string): Promise<void>;
+    /**
+     * Remove all usages for an entity (on delete)
+     *
+     * @param entityType - Type of entity
+     * @param entityId - ID of the entity
+     * @param userId - User ID for RLS
+     */
+    static removeEntityUsages(entityType: string, entityId: string, userId: string): Promise<void>;
+    /**
+     * Get usage count for a pattern
+     *
+     * @param patternId - Pattern ID
+     * @param userId - User ID for RLS
+     * @returns Total usage count
+     */
+    static getUsageCount(patternId: string, userId: string): Promise<number>;
+    /**
+     * Get usage counts grouped by entity type
+     *
+     * @param patternId - Pattern ID
+     * @param userId - User ID for RLS
+     * @returns Array of counts by entity type
+     */
+    static getUsageCounts(patternId: string, userId: string): Promise<PatternUsageCount[]>;
+    /**
+     * Get detailed usages with entity information
+     *
+     * Joins with entity tables to get title, slug, status, etc.
+     *
+     * @param patternId - Pattern ID
+     * @param userId - User ID for RLS
+     * @param options - Filtering and pagination options
+     * @returns Usages with entity info, counts, and total
+     */
+    static getUsagesWithEntityInfo(patternId: string, userId: string, options?: GetUsagesOptions): Promise<GetUsagesResult>;
+    /**
+     * Enrich usages with entity information
+     *
+     * Batches queries by entity type for efficiency.
+     *
+     * @param usages - Array of pattern usages
+     * @param userId - User ID for RLS
+     * @returns Usages with entity info added
+     */
+    private static enrichUsagesWithEntityInfo;
+    /**
+     * Get all pattern IDs that have usages
+     * Useful for checking if any patterns are in use before bulk operations
+     *
+     * @param patternIds - Array of pattern IDs to check
+     * @param userId - User ID for RLS
+     * @returns Array of pattern IDs that have at least one usage
+     */
+    static getPatternsWithUsages(patternIds: string[], userId: string): Promise<string[]>;
+    /**
+     * Validate which pattern IDs exist in the database
+     *
+     * Returns only the IDs that exist and are accessible.
+     * Used for lazy cleanup - filtering orphaned pattern references on entity save.
+     *
+     * @param patternIds - Array of pattern IDs to check
+     * @param userId - User ID for RLS
+     * @returns Set of pattern IDs that exist
+     */
+    static getExistingPatternIds(patternIds: string[], userId: string): Promise<Set<string>>;
+}
+//# sourceMappingURL=pattern-usage.service.d.ts.map

package/dist/lib/services/pattern-usage.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-usage.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/pattern-usage.service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAMrE,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,0BAA2B,SAAQ,YAAY;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,0BAA0B,EAAE,CAAA;IACpC,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;CACd;AAMD,qBAAa,mBAAmB;IAC9B;;;;;;;;;;;OAWG;WACU,UAAU,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,EAC5C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAwDhB;;;;;;OAMG;WACU,kBAAkB,CAC7B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAchB;;;;;;OAMG;WACU,aAAa,CACxB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC;IASlB;;;;;;OAMG;WACU,cAAc,CACzB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAgB/B;;;;;;;;;OASG;WACU,uBAAuB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC;IAgD3B;;;;;;;;OAQG;mBACkB,0BAA0B;IAgI/C;;;;;;;OAOG;WACU,qBAAqB,CAChC,UAAU,EAAE,MAAM,EAAE,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,EAAE,CAAC;IAWpB;;;;;;;;;OASG;WACU,qBAAqB,CAChC,UAAU,EAAE,MAAM,EAAE,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;CAWxB"}

package/dist/lib/services/pattern-usage.service.js

@@ -182,7 +182,7 @@ class PatternUsageService {
         entityInfoMap.set(entityType, /* @__PURE__ */ new Map());
         continue;
       }
-      const tableName = entityConfig.slug;
+      const tableName = entityConfig.tableName || entityConfig.slug;
       try {
         const columnsResult = await queryRows(
           `SELECT column_name

package/dist/lib/services/permission.service.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Permission Service
+ *
+ * Provides runtime permission checks and role-based access control logic.
+ * Uses pre-computed data from permissions-registry for O(1) operations.
+ *
+ * Query functions moved here from permissions-registry to follow data-only pattern.
+ *
+ * @module PermissionService
+ */
+import type { Permission, ResolvedPermission } from '../permissions/types';
+export declare class PermissionService {
+    /**
+     * Check if a role has a specific permission - O(1)
+     *
+     * @param role - Team role to check
+     * @param permission - Permission to verify
+     * @returns True if role has permission
+     *
+     * @example
+     * const canCreate = PermissionService.hasPermission('admin', 'customers.create')
+     */
+    static hasPermission(role: string, permission: Permission): boolean;
+    /**
+     * Unified permission check - works for teams, entities, and features - O(1)
+     *
+     * This is the recommended method for checking any type of permission.
+     * It checks across all permission sources:
+     * - Team permissions (team.view, team.edit, team.members.invite, etc.)
+     * - Entity permissions (customers.create, tasks.update, etc.)
+     * - Feature permissions (page-builder.access, media.upload, etc.)
+     *
+     * @param role - Team role to check
+     * @param action - Action to verify (e.g., 'team.edit', 'customers.create', 'page-builder.access')
+     * @returns True if role can perform action
+     *
+     * @example
+     * // Team permission
+     * PermissionService.canDoAction('admin', 'team.edit')
+     *
+     * // Entity permission
+     * PermissionService.canDoAction('admin', 'customers.create')
+     *
+     * // Feature permission
+     * PermissionService.canDoAction('editor', 'page-builder.access')
+     */
+    static canDoAction(role: string, action: string): boolean;
+    /**
+     * Get all permissions for a role - O(1)
+     *
+     * @param role - Team role
+     * @returns Array of permissions for the role
+     *
+     * @example
+     * const permissions = PermissionService.getRolePermissions('admin')
+     */
+    static getRolePermissions(role: string): Permission[];
+    /**
+     * Get permissions by category - O(1)
+     *
+     * @param category - Permission category
+     * @returns Array of resolved permissions in category
+     *
+     * @example
+     * const customerPerms = PermissionService.getByCategory('customers')
+     */
+    static getByCategory(category: string): ResolvedPermission[];
+    /**
+     * Get all permission categories
+     *
+     * @returns Array of category names
+     *
+     * @example
+     * const categories = PermissionService.getCategories()
+     */
+    static getCategories(): string[];
+    /**
+     * Get full permission matrix for UI - O(1)
+     *
+     * Returns copies to prevent mutation of internal data.
+     *
+     * @returns Object with permissions, matrix, sections, and roles
+     *
+     * @example
+     * const matrix = PermissionService.getMatrix()
+     * // Use in Admin Panel permissions UI
+     */
+    static getMatrix(): {
+        permissions: any[];
+        matrix: any;
+        sections: any[];
+        roles: any[];
+    };
+    /**
+     * Check if a permission ID is valid - O(1)
+     *
+     * @param permission - Permission to validate
+     * @returns True if permission exists
+     *
+     * @example
+     * if (PermissionService.isValid('customers.create')) {
+     *   // Valid permission
+     * }
+     */
+    static isValid(permission: Permission): boolean;
+    /**
+     * Get permission configuration - O(n)
+     *
+     * @param permission - Permission to get config for
+     * @returns Permission config or undefined
+     *
+     * @example
+     * const config = PermissionService.getConfig('customers.delete')
+     * if (config?.dangerous) {
+     *   // Show warning
+     * }
+     */
+    static getConfig(permission: Permission): ResolvedPermission | undefined;
+    /**
+     * Get all permissions
+     *
+     * @returns Array of all permission IDs
+     *
+     * @example
+     * const allPerms = PermissionService.getAll()
+     */
+    static getAll(): Permission[];
+    /**
+     * Check if a role has ANY of the specified permissions
+     *
+     * @param role - Team role to check
+     * @param permissions - Array of permissions to check
+     * @returns True if role has at least one permission
+     *
+     * @example
+     * const canManage = PermissionService.hasAnyPermission('member', [
+     *   'customers.create',
+     *   'customers.update'
+     * ])
+     */
+    static hasAnyPermission(role: string, permissions: Permission[]): boolean;
+    /**
+     * Check if a role has ALL of the specified permissions
+     *
+     * @param role - Team role to check
+     * @param permissions - Array of permissions to check
+     * @returns True if role has all permissions
+     *
+     * @example
+     * const canFullyManage = PermissionService.hasAllPermissions('admin', [
+     *   'customers.create',
+     *   'customers.update',
+     *   'customers.delete'
+     * ])
+     */
+    static hasAllPermissions(role: string, permissions: Permission[]): boolean;
+}
+/**
+ * Check if role has permission
+ * @deprecated Use PermissionService.hasPermission() instead
+ */
+export declare const hasPermission: typeof PermissionService.hasPermission;
+/**
+ * Unified permission check - works for teams, entities, and features
+ * This is the recommended function for checking any type of permission.
+ */
+export declare const canDoAction: typeof PermissionService.canDoAction;
+/**
+ * Get all permissions for a role
+ * @deprecated Use PermissionService.getRolePermissions() instead
+ */
+export declare const getRolePermissions: typeof PermissionService.getRolePermissions;
+/**
+ * Get permissions by category
+ * @deprecated Use PermissionService.getByCategory() instead
+ */
+export declare const getPermissionsByCategory: typeof PermissionService.getByCategory;
+/**
+ * Get all categories
+ * @deprecated Use PermissionService.getCategories() instead
+ */
+export declare const getCategories: typeof PermissionService.getCategories;
+/**
+ * Get full matrix for UI
+ * @deprecated Use PermissionService.getMatrix() instead
+ */
+export declare const getFullMatrix: typeof PermissionService.getMatrix;
+/**
+ * Check if permission exists
+ * @deprecated Use PermissionService.isValid() instead
+ */
+export declare const isValidPermission: typeof PermissionService.isValid;
+/**
+ * Get permission config
+ * @deprecated Use PermissionService.getConfig() instead
+ */
+export declare const getPermissionConfig: typeof PermissionService.getConfig;
+/**
+ * Legacy permission registry interface
+ * @deprecated Use PermissionService class methods instead
+ */
+export declare const permissionRegistry: {
+    hasPermission: typeof PermissionService.hasPermission;
+    canDoAction: typeof PermissionService.canDoAction;
+    getRolePermissions: typeof PermissionService.getRolePermissions;
+    getPermissionsByCategory: typeof PermissionService.getByCategory;
+    getFullMatrix: typeof PermissionService.getMatrix;
+    getPermissionConfig: typeof PermissionService.getConfig;
+    isValidPermission: typeof PermissionService.isValid;
+    isInitialized: () => boolean;
+};
+//# sourceMappingURL=permission.service.d.ts.map

package/dist/lib/services/permission.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/permission.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAoB1E,qBAAa,iBAAiB;IAC5B;;;;;;;;;OASG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO;IAKnE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAazD;;;;;;;;OAQG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE;IAKrD;;;;;;;;OAQG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAI5D;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,IAAI,MAAM,EAAE;IAIhC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,SAAS;;;;;;IAUhB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;IAI/C;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,kBAAkB,GAAG,SAAS;IAIxE;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,IAAI,UAAU,EAAE;IAI7B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO;IAIzE;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO;CAG3E;AAMD;;;GAGG;AACH,eAAO,MAAM,aAAa,wCAAkC,CAAA;AAE5D;;;GAGG;AACH,eAAO,MAAM,WAAW,sCAAgC,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,6CAAuC,CAAA;AAEtE;;;GAGG;AACH,eAAO,MAAM,wBAAwB,wCAAkC,CAAA;AAEvE;;;GAGG;AACH,eAAO,MAAM,aAAa,wCAAkC,CAAA;AAE5D;;;GAGG;AACH,eAAO,MAAM,aAAa,oCAA8B,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,kCAA4B,CAAA;AAE1D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,oCAA8B,CAAA;AAE9D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;CAS9B,CAAA"}