@nextsparkjs/core 0.1.0-beta.69 → 0.1.0-beta.70

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

@@ -1,168 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,123 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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/permission.service.d.ts

@@ -1,212 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,174 +0,0 @@
-/**
- * Plan Service
- *
- * Provides core plan management functions including database queries
- * and registry-based configuration lookups.
- *
- * @module PlanService
- */
-import type { Plan } from '../billing/types';
-import type { PlanDefinition } from '../billing/config-types';
-export interface ListPlansOptions {
-    /** Include hidden plans (default: false) */
-    includeHidden?: boolean;
-}
-export declare class PlanService {
-    /**
-     * Get plan by ID
-     *
-     * @param id - Plan ID
-     * @returns Plan or null if not found
-     *
-     * @example
-     * const plan = await PlanService.getById('plan-uuid-123')
-     */
-    static getById(id: string): Promise<Plan | null>;
-    /**
-     * Get plan by slug
-     *
-     * @param slug - Plan slug (e.g., 'free', 'pro', 'enterprise')
-     * @returns Plan or null if not found
-     *
-     * @example
-     * const plan = await PlanService.getBySlug('pro')
-     */
-    static getBySlug(slug: string): Promise<Plan | null>;
-    /**
-     * Get all plans
-     *
-     * @param options - List options (includeHidden)
-     * @returns Array of plans ordered by sortOrder
-     *
-     * @example
-     * // Get public plans only
-     * const plans = await PlanService.list()
-     *
-     * // Get all plans including hidden
-     * const allPlans = await PlanService.list({ includeHidden: true })
-     */
-    static list(options?: ListPlansOptions): Promise<Plan[]>;
-    /**
-     * Get the default plan (typically 'free')
-     * Uses the defaultPlan from billing registry configuration
-     *
-     * @returns Default plan or null if not found
-     *
-     * @example
-     * const freePlan = await PlanService.getDefault()
-     */
-    static getDefault(): Promise<Plan | null>;
-    /**
-     * Check if a plan exists by slug
-     *
-     * @param slug - Plan slug to check
-     * @returns True if plan exists, false otherwise
-     *
-     * @example
-     * const exists = await PlanService.exists('enterprise')
-     */
-    static exists(slug: string): Promise<boolean>;
-    /**
-     * Get plan configuration from billing registry
-     * This is the static config, not the database record
-     *
-     * @param slug - Plan slug
-     * @returns Plan definition from registry or null
-     *
-     * @example
-     * const config = PlanService.getConfig('pro')
-     * console.log(config?.features) // ['feature1', 'feature2']
-     */
-    static getConfig(slug: string): PlanDefinition | null;
-    /**
-     * Get features for a plan from registry
-     *
-     * @param slug - Plan slug
-     * @returns Array of feature slugs or empty array
-     *
-     * @example
-     * const features = PlanService.getFeatures('pro')
-     * // ['advanced_analytics', 'custom_branding', ...]
-     */
-    static getFeatures(slug: string): string[];
-    /**
-     * Get limits for a plan from registry
-     *
-     * @param slug - Plan slug
-     * @returns Object mapping limit slugs to values (-1 = unlimited)
-     *
-     * @example
-     * const limits = PlanService.getLimits('pro')
-     * // { projects: 100, api_calls: 10000, storage_mb: 5120 }
-     */
-    static getLimits(slug: string): Record<string, number>;
-    /**
-     * Get a specific limit value for a plan
-     *
-     * @param slug - Plan slug
-     * @param limitSlug - Limit slug to get
-     * @returns Limit value (-1 = unlimited, 0 if not found)
-     *
-     * @example
-     * const maxProjects = PlanService.getLimit('pro', 'projects')
-     * // 100
-     */
-    static getLimit(slug: string, limitSlug: string): number;
-    /**
-     * Check if a plan has a specific feature
-     *
-     * @param slug - Plan slug
-     * @param featureSlug - Feature slug to check
-     * @returns True if plan has the feature
-     *
-     * @example
-     * const hasAnalytics = PlanService.hasFeature('pro', 'advanced_analytics')
-     */
-    static hasFeature(slug: string, featureSlug: string): boolean;
-    /**
-     * Check if changing from one plan to another is an upgrade
-     * Based on price comparison (higher price = upgrade)
-     *
-     * @param fromSlug - Current plan slug
-     * @param toSlug - Target plan slug
-     * @returns True if it's an upgrade, false if downgrade or same
-     *
-     * @example
-     * const isUpgrade = PlanService.isUpgrade('free', 'pro') // true
-     * const isDowngrade = PlanService.isUpgrade('pro', 'free') // false
-     */
-    static isUpgrade(fromSlug: string, toSlug: string): boolean;
-    /**
-     * Get all plan slugs from registry
-     *
-     * @returns Array of plan slugs
-     *
-     * @example
-     * const slugs = PlanService.getAllSlugs()
-     * // ['free', 'pro', 'enterprise']
-     */
-    static getAllSlugs(): string[];
-    /**
-     * Get price for a plan in a specific interval
-     *
-     * @param slug - Plan slug
-     * @param interval - 'monthly' or 'yearly'
-     * @returns Price in cents or null if free/not found
-     *
-     * @example
-     * const monthlyPrice = PlanService.getPrice('pro', 'monthly')
-     * // 2900 (cents)
-     */
-    static getPrice(slug: string, interval: 'monthly' | 'yearly'): number | null;
-    /**
-     * Get Stripe price ID for a plan
-     *
-     * @param slug - Plan slug
-     * @param interval - 'monthly' or 'yearly'
-     * @returns Stripe price ID or null
-     *
-     * @example
-     * const priceId = PlanService.getStripePriceId('pro', 'monthly')
-     */
-    static getStripePriceId(slug: string, interval: 'monthly' | 'yearly'): string | null;
-}
-//# sourceMappingURL=plan.service.d.ts.map