@vladimirdukelic/revolutionary-ui-factory/dist/lib/factory/premium-features.d.ts

Revolutionary UI Factory System v2 - Generate ANY UI component for ANY framework with 60-95% code reduction

/**
 * Premium Features Implementation for Revolutionary UI Factory
 * Handles team, sync, analytics, library, and registry functionality
 */
export interface TeamMember {
    id: string;
    email: string;
    name: string;
    role: 'owner' | 'admin' | 'member' | 'viewer';
    joinedAt: string;
    lastActive: string;
    permissions?: string[];
}
export interface Team {
    id: string;
    name: string;
    members: TeamMember[];
    created: string;
    plan: string;
}
type TeamRole = 'owner' | 'admin' | 'member' | 'viewer';
interface TeamInvitation {
    id: string;
    email: string;
    role: TeamRole;
    invitedBy: string;
    invitedAt: Date;
    status: 'pending' | 'accepted' | 'cancelled';
    expiresAt: Date;
}
export declare class TeamManager {
    private teamMembers;
    private invitations;
    constructor();
    private loadMockData;
    getTeam(): Promise<Team | null>;
    inviteMember(email: string, role?: string): Promise<boolean>;
    removeMember(memberId: string): Promise<boolean>;
    updateRole(memberId: string, role: string): Promise<boolean>;
    listMembers(): Promise<TeamMember[]>;
    listInvitations(): Promise<TeamInvitation[]>;
    resendInvitation(invitationId: string): Promise<boolean>;
    cancelInvitation(invitationId: string): Promise<boolean>;
    private getPermissionsForRole;
}
export interface SyncStatus {
    lastSync: string;
    localChanges: number;
    remoteChanges: number;
    conflicts: string[];
}
export interface SyncableItem {
    id: string;
    type: 'component' | 'config' | 'template';
    name: string;
    localPath: string;
    checksum: string;
    modifiedAt: string;
}
export declare class CloudSyncManager {
    private syncConfigPath;
    private localComponents;
    constructor();
    private loadLocalComponents;
    getStatus(): Promise<SyncStatus>;
    push(): Promise<boolean>;
    pull(): Promise<boolean>;
    resolveConflicts(strategy?: 'local' | 'remote' | 'merge'): Promise<boolean>;
    showDiff(): Promise<void>;
    private getLocalItems;
    private detectLocalChanges;
    private detectConflicts;
    private getLastSyncTime;
    private saveItem;
    private updateSyncConfig;
}
export interface ComponentMetrics {
    componentId: string;
    name: string;
    uses: number;
    lastUsed: string;
    avgGenerationTime: number;
    codeReduction: string;
}
export interface UsageStats {
    totalComponents: number;
    totalGenerations: number;
    avgCodeReduction: string;
    topComponents: ComponentMetrics[];
    timeSpent: number;
}
interface DetailedAnalytics {
    dailyBreakdown: Array<{
        date: string;
        generations: number;
        components: number;
        codeReduction: string;
    }>;
    frameworkStats: Record<string, number>;
    featureUsage: Record<string, number>;
    errorRate: number;
    performance: {
        avgGenerationTime: number;
        p95GenerationTime: number;
        p99GenerationTime: number;
    };
}
export declare class AnalyticsManager {
    private localStats;
    private usageHistory;
    constructor();
    private loadLocalStats;
    getStats(period?: string): Promise<UsageStats>;
    private generateMockStats;
    getComponentStats(componentId: string): Promise<ComponentMetrics | null>;
    getDetailedAnalytics(period?: string): Promise<DetailedAnalytics>;
    private generateMockDetailedAnalytics;
    trackUsage(componentType: string, metrics: any): Promise<void>;
    exportAnalytics(format?: 'json' | 'csv'): Promise<string>;
    getInsights(): Promise<string[]>;
    private saveLocalStats;
}
export interface LibraryComponent {
    id: string;
    name: string;
    description: string;
    type: string;
    framework: string[];
    tags: string[];
    version: string;
    author: string;
    created: string;
    updated: string;
    published: boolean;
}
export declare class LibraryManager {
    private libraryPath;
    private localComponents;
    private componentTemplates;
    constructor();
    private loadLocalLibrary;
    listComponents(): Promise<LibraryComponent[]>;
    searchComponents(query: string, filters?: {
        type?: string;
        framework?: string;
        tags?: string[];
    }): Promise<LibraryComponent[]>;
    createComponent(component: Partial<LibraryComponent>, code: string): Promise<string>;
    getComponent(componentId: string): Promise<{
        component: LibraryComponent;
        code: string;
    } | null>;
    updateComponent(componentId: string, updates: Partial<LibraryComponent>, code?: string): Promise<boolean>;
    createVersion(componentId: string, version: string, changes: string): Promise<boolean>;
    publishComponent(componentId: string): Promise<boolean>;
    deleteComponent(componentId: string): Promise<boolean>;
    shareWithTeam(componentId: string): Promise<boolean>;
    importFromFile(filePath: string, metadata?: Partial<LibraryComponent>): Promise<string>;
    exportComponent(componentId: string, outputPath: string): Promise<void>;
    private saveComponent;
    private updateIndex;
}
export interface RegistryConfig {
    url: string;
    authToken: string;
    scope: string;
    publishConfig: {
        access: 'public' | 'restricted';
        requiresApproval: boolean;
    };
}
export interface RegistryPackage {
    name: string;
    version: string;
    description: string;
    author: string;
    published: string;
    downloads: number;
    private: boolean;
}
interface PackageVersion {
    version: string;
    published: string;
    downloads: number;
    deprecated?: boolean;
    deprecationMessage?: string;
}
interface RegistryStats {
    totalPackages: number;
    totalDownloads: number;
    totalVersions: number;
    storageUsed: string;
    lastPublished: string;
}
interface AccessToken {
    token: string;
    name: string;
    created: string;
    lastUsed: string;
    permissions: string[];
}
export declare class RegistryManager {
    private registryConfigPath;
    private localPackages;
    private accessTokens;
    constructor();
    private loadRegistryData;
    getConfig(): Promise<RegistryConfig | null>;
    setupRegistry(config: Partial<RegistryConfig>): Promise<boolean>;
    getStats(): Promise<RegistryStats>;
    listPackages(options?: {
        search?: string;
        scope?: string;
        private?: boolean;
    }): Promise<RegistryPackage[]>;
    getPackageVersions(packageName: string): Promise<PackageVersion[]>;
    publishPackage(packagePath: string, options?: {
        tag?: string;
        access?: 'public' | 'restricted';
        dryRun?: boolean;
    }): Promise<boolean>;
    unpublishPackage(packageName: string, version?: string): Promise<boolean>;
    deprecatePackage(packageName: string, version: string, message: string): Promise<boolean>;
    getAccessToken(name?: string): Promise<string | null>;
    listTokens(): Promise<AccessToken[]>;
    revokeToken(tokenName: string): Promise<boolean>;
    configureNpmrc(registryUrl?: string, token?: string): Promise<void>;
    private saveRegistryData;
}
export declare const mockTeamData: Team;
export declare const mockAnalyticsData: UsageStats;
export {};