ngx-dev-toolbar 1.0.4 → 1.0.5

package/index.d.ts

@@ -8,3 +8,12 @@ export * from './tools/feature-flags-tool/feature-flags.models';
 export * from './tools/feature-flags-tool/feature-flags.service';
 export * from './tools/language-tool/language.models';
 export * from './tools/language-tool/language.service';
+export * from './tools/network-mocker-tool/network-mocker-tool.component';
+export * from './tools/network-mocker-tool/network-mocker.models';
+export * from './tools/network-mocker-tool/network-mocker.service';
+export * from './tools/app-features-tool/app-features.models';
+export * from './tools/app-features-tool/app-features.service';
+export * from './tools/app-features-tool/app-features-tool.component';
+export * from './tools/permissions-tool/permissions.models';
+export * from './tools/permissions-tool/permissions.service';
+export * from './tools/permissions-tool/permissions-tool.component';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-dev-toolbar",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "keywords": [
     "devtools",
     "development-toolbar",
@@ -33,4 +33,4 @@
   "dependencies": {
     "tslib": "^2.3.0"
   }
-}
+}

package/tools/app-features-tool/app-features-internal.service.d.ts

@@ -0,0 +1,102 @@
+import { Observable } from 'rxjs';
+import { DevToolbarAppFeature, ForcedAppFeaturesState } from './app-features.models';
+import * as i0 from "@angular/core";
+/**
+ * Internal service for managing app features state and forced overrides.
+ *
+ * This service handles:
+ * - Feature configuration storage
+ * - Forced feature state management
+ * - localStorage persistence
+ * - State validation and cleanup
+ *
+ * @internal This service is for internal toolbar use only. Consumers should use DevToolbarAppFeaturesService.
+ */
+export declare class DevToolbarInternalAppFeaturesService {
+    private readonly STORAGE_KEY;
+    private storageService;
+    private appFeaturesSubject;
+    private forcedFeaturesSubject;
+    private readonly forcedFeatures$;
+    /**
+     * Observable stream of all features with merged forced state
+     */
+    features$: Observable<DevToolbarAppFeature[]>;
+    /**
+     * Signal containing current features with merged forced state
+     */
+    features: import("@angular/core").Signal<DevToolbarAppFeature[]>;
+    constructor();
+    /**
+     * Set available app features for the application.
+     * Validates features, trims whitespace, and triggers validation of forced state.
+     *
+     * @param features - Array of app features to configure
+     * @throws Error if duplicate feature IDs or empty IDs are detected
+     */
+    setAppFeatures(features: DevToolbarAppFeature[]): void;
+    /**
+     * Get observable stream of app features (natural state, no forced state merged)
+     */
+    getAppFeatures(): Observable<DevToolbarAppFeature[]>;
+    /**
+     * Get observable stream of features that have forced overrides
+     */
+    getForcedFeatures(): Observable<DevToolbarAppFeature[]>;
+    /**
+     * Force a feature to enabled or disabled state.
+     * Persists the forced state to localStorage.
+     *
+     * @param featureId - ID of the feature to force
+     * @param isEnabled - Whether to force feature to enabled (true) or disabled (false)
+     */
+    setFeature(featureId: string, isEnabled: boolean): void;
+    /**
+     * Remove forced override for a feature, returning it to natural state.
+     * Persists the change to localStorage.
+     *
+     * @param featureId - ID of the feature to unforce
+     */
+    removeFeatureOverride(featureId: string): void;
+    /**
+     * Apply a preset forced state (for preset integration).
+     * Validates and cleans invalid feature IDs before applying.
+     *
+     * @param state - Forced features state from preset
+     */
+    applyForcedState(state: ForcedAppFeaturesState): void;
+    /**
+     * Get current forced state as a snapshot (defensive copy).
+     * Useful for preset exports and debugging.
+     *
+     * @returns Current forced features state
+     */
+    getCurrentForcedState(): ForcedAppFeaturesState;
+    /**
+     * Merge natural app features with forced state.
+     *
+     * @param appFeatures - Natural feature configuration
+     * @param forcedState - Forced overrides from localStorage/toolbar
+     * @returns Features with merged forced state
+     */
+    private mergeForcedState;
+    /**
+     * Load forced features state from localStorage on initialization.
+     * Handles missing or corrupted data gracefully.
+     */
+    private loadForcedFeatures;
+    /**
+     * Persist forced features state to localStorage.
+     * Handles quota exceeded errors gracefully.
+     *
+     * @param state - Forced state to persist
+     */
+    private saveForcedFeatures;
+    /**
+     * Validate forced feature IDs against configured features and clean up invalid ones.
+     * Called after setAppFeatures() to ensure forced state references valid features.
+     */
+    private validateAndCleanForcedState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarInternalAppFeaturesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarInternalAppFeaturesService>;
+}

package/tools/app-features-tool/app-features-tool.component.d.ts

@@ -0,0 +1,61 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import { AppFeatureFilter, DevToolbarAppFeature } from './app-features.models';
+import * as i0 from "@angular/core";
+/**
+ * Component for managing app features in the dev toolbar.
+ *
+ * Provides UI for:
+ * - Searching features by name and description
+ * - Filtering features by state (all/forced/enabled/disabled)
+ * - Forcing features to enabled/disabled state via 3-state dropdown
+ * - Viewing feature descriptions and current state
+ *
+ * @example
+ * ```html
+ * <ndt-app-features-tool />
+ * ```
+ */
+export declare class DevToolbarAppFeaturesToolComponent {
+    private readonly appFeaturesService;
+    protected readonly activeFilter: import("@angular/core").WritableSignal<AppFeatureFilter>;
+    protected readonly searchQuery: import("@angular/core").WritableSignal<string>;
+    protected readonly features: import("@angular/core").Signal<DevToolbarAppFeature[]>;
+    protected readonly hasNoFeatures: import("@angular/core").Signal<boolean>;
+    protected readonly filteredFeatures: import("@angular/core").Signal<DevToolbarAppFeature[]>;
+    protected readonly hasNoFilteredFeatures: import("@angular/core").Signal<boolean>;
+    protected readonly options: DevToolbarWindowOptions;
+    protected readonly filterOptions: {
+        value: string;
+        label: string;
+    }[];
+    protected readonly featureValueOptions: {
+        value: string;
+        label: string;
+    }[];
+    /**
+     * Handle filter dropdown change.
+     * Updates the active filter to show all/forced/enabled/disabled features.
+     */
+    onFilterChange(value: string | undefined): void;
+    /**
+     * Handle feature value change from 3-state dropdown.
+     * - 'not-forced' (empty string): Remove forced override
+     * - 'on': Force feature to enabled
+     * - 'off': Force feature to disabled
+     */
+    onFeatureChange(featureId: string, value: string): void;
+    /**
+     * Handle search input change.
+     * Updates the search query to filter features by name/description.
+     */
+    onSearchChange(query: string): void;
+    /**
+     * Get the dropdown value for a feature's current state.
+     * - Returns empty string if not forced (natural state)
+     * - Returns 'on' if forced to enabled
+     * - Returns 'off' if forced to disabled
+     */
+    protected getFeatureValue(feature: DevToolbarAppFeature): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarAppFeaturesToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarAppFeaturesToolComponent, "ndt-app-features-tool", never, {}, {}, never, never, true, never>;
+}

package/tools/app-features-tool/app-features.models.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Represents a product-level application feature that can be enabled/disabled
+ * based on license tier, deployment configuration, or environment flags.
+ *
+ * @example
+ * ```typescript
+ * const feature: DevToolbarAppFeature = {
+ *   id: 'advanced-analytics',
+ *   name: 'Advanced Analytics Dashboard',
+ *   description: 'Access advanced reporting and data visualization tools',
+ *   isEnabled: false,  // Not available in current tier
+ *   isForced: false    // Natural state, not overridden
+ * };
+ * ```
+ */
+export interface DevToolbarAppFeature {
+    /**
+     * Unique identifier for the feature
+     * @example 'advanced-analytics', 'multi-user-support', 'white-label-branding'
+     */
+    id: string;
+    /**
+     * Display name shown in the toolbar UI
+     * @example 'Advanced Analytics Dashboard', 'Multi-User Support'
+     */
+    name: string;
+    /**
+     * Optional description explaining the feature's purpose and capabilities
+     * Displayed below the feature name in the UI
+     * @example 'Access advanced reporting and data visualization tools'
+     */
+    description?: string;
+    /**
+     * Current enabled state of the feature
+     * - true: Feature is available to the user (may be natural state or forced)
+     * - false: Feature is not available (may be natural state or forced)
+     */
+    isEnabled: boolean;
+    /**
+     * Whether the feature state is forced via the dev toolbar
+     * - true: State is overridden by developer, ignoring natural application state
+     * - false: State reflects the natural application configuration
+     */
+    isForced: boolean;
+}
+/**
+ * Filter options for displaying features in the toolbar UI.
+ *
+ * - `'all'`: Show all configured features
+ * - `'forced'`: Show only features with isForced = true
+ * - `'enabled'`: Show only features with isEnabled = true (regardless of forced state)
+ * - `'disabled'`: Show only features with isEnabled = false (regardless of forced state)
+ *
+ * @example
+ * ```typescript
+ * // Show only forced overrides
+ * const filter: AppFeatureFilter = 'forced';
+ *
+ * // Show all enabled features (natural or forced)
+ * const filter: AppFeatureFilter = 'enabled';
+ * ```
+ */
+export type AppFeatureFilter = 'all' | 'forced' | 'enabled' | 'disabled';
+/**
+ * Internal storage format for persisted forced feature overrides in localStorage.
+ *
+ * **Storage Rules**:
+ * - Feature ID MUST NOT appear in both `enabled` and `disabled` arrays simultaneously
+ * - If feature forced to enabled, ID MUST be in `enabled` array and NOT in `disabled` array
+ * - If feature forced to disabled, ID MUST be in `disabled` array and NOT in `enabled` array
+ * - If feature not forced, ID MUST NOT be in either array
+ *
+ * **localStorage Key**: `AngularDevTools.app-features`
+ *
+ * @example
+ * ```typescript
+ * // Testing Enterprise tier (force premium features enabled)
+ * const enterpriseState: ForcedAppFeaturesState = {
+ *   enabled: ['analytics', 'multi-user', 'white-label', 'sso-integration'],
+ *   disabled: []
+ * };
+ *
+ * // Testing Basic tier (force premium features disabled)
+ * const basicState: ForcedAppFeaturesState = {
+ *   enabled: [],
+ *   disabled: ['analytics', 'multi-user', 'white-label', 'sso-integration']
+ * };
+ *
+ * // Mixed scenario
+ * const mixedState: ForcedAppFeaturesState = {
+ *   enabled: ['analytics'],          // Test analytics feature
+ *   disabled: ['white-label']        // Ensure branding is off
+ * };
+ * ```
+ */
+export interface ForcedAppFeaturesState {
+    /**
+     * Array of feature IDs forced to enabled state
+     * Features in this array will have isEnabled = true regardless of natural state
+     * @example ['advanced-analytics', 'white-label-branding']
+     */
+    enabled: string[];
+    /**
+     * Array of feature IDs forced to disabled state
+     * Features in this array will have isEnabled = false regardless of natural state
+     * @example ['basic-support', 'community-forums']
+     */
+    disabled: string[];
+}

package/tools/app-features-tool/app-features.service.d.ts

@@ -0,0 +1,151 @@
+import { Observable } from 'rxjs';
+import { DevToolsService } from '../../models/dev-tools.interface';
+import { DevToolbarAppFeature, ForcedAppFeaturesState } from './app-features.models';
+import * as i0 from "@angular/core";
+/**
+ * Public service for managing app features in the dev toolbar.
+ *
+ * This service implements the DevToolsService interface and provides methods for:
+ * - Configuring available product features
+ * - Retrieving forced feature overrides
+ * - Applying preset feature configurations
+ * - Exporting current forced state for presets
+ *
+ * @example
+ * ```typescript
+ * import { DevToolbarAppFeaturesService } from 'ngx-dev-toolbar';
+ *
+ * @Component({...})
+ * export class AppComponent implements OnInit {
+ *   private appFeaturesService = inject(DevToolbarAppFeaturesService);
+ *
+ *   ngOnInit() {
+ *     // Configure available features based on current tier
+ *     const features: DevToolbarAppFeature[] = [
+ *       { id: 'analytics', name: 'Analytics Dashboard', isEnabled: true, isForced: false },
+ *       { id: 'multi-user', name: 'Multi-User Support', isEnabled: false, isForced: false }
+ *     ];
+ *     this.appFeaturesService.setAvailableOptions(features);
+ *
+ *     // Subscribe to forced overrides
+ *     this.appFeaturesService.getForcedValues().subscribe(forcedFeatures => {
+ *       forcedFeatures.forEach(feature => {
+ *         // Apply forced feature state to application logic
+ *         this.applyFeatureState(feature.id, feature.isEnabled);
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare class DevToolbarAppFeaturesService implements DevToolsService<DevToolbarAppFeature> {
+    private internalService;
+    /**
+     * Set available app features for the application.
+     *
+     * Configures the list of product features that can be toggled in the dev toolbar.
+     * Features should represent product-level capabilities like license tiers,
+     * deployment configurations, or environment flags.
+     *
+     * @param features - Array of app features to display in the toolbar
+     * @throws Error if duplicate feature IDs or empty IDs are detected
+     *
+     * @example
+     * ```typescript
+     * const features: DevToolbarAppFeature[] = [
+     *   {
+     *     id: 'advanced-analytics',
+     *     name: 'Advanced Analytics Dashboard',
+     *     description: 'Access premium reporting and data visualization',
+     *     isEnabled: false,  // Not available in current tier
+     *     isForced: false
+     *   },
+     *   {
+     *     id: 'multi-user-support',
+     *     name: 'Multi-User Collaboration',
+     *     description: 'Enable team features and user management',
+     *     isEnabled: true,   // Available in current tier
+     *     isForced: false
+     *   }
+     * ];
+     * this.appFeaturesService.setAvailableOptions(features);
+     * ```
+     */
+    setAvailableOptions(features: DevToolbarAppFeature[]): void;
+    /**
+     * Get observable stream of features that have forced overrides.
+     *
+     * Emits an array of features that have been forced via the dev toolbar.
+     * Only features with `isForced = true` are included in the emissions.
+     * Use this to react to feature override changes and update application behavior.
+     *
+     * @returns Observable that emits array of forced features whenever state changes
+     *
+     * @example
+     * ```typescript
+     * this.appFeaturesService.getForcedValues()
+     *   .pipe(takeUntilDestroyed())
+     *   .subscribe(forcedFeatures => {
+     *     forcedFeatures.forEach(feature => {
+     *       if (feature.isEnabled) {
+     *         this.enableFeature(feature.id);
+     *       } else {
+     *         this.disableFeature(feature.id);
+     *       }
+     *     });
+     *   });
+     * ```
+     */
+    getForcedValues(): Observable<DevToolbarAppFeature[]>;
+    /**
+     * Apply a preset feature configuration (for preset tool integration).
+     *
+     * Accepts a forced features state object and applies it to the current configuration.
+     * Invalid feature IDs (not in configured features) are filtered out with a warning.
+     *
+     * @param state - Forced features state containing enabled/disabled arrays
+     *
+     * @example
+     * ```typescript
+     * // Apply "Enterprise Tier" preset
+     * const enterprisePreset: ForcedAppFeaturesState = {
+     *   enabled: ['analytics', 'multi-user', 'white-label', 'sso'],
+     *   disabled: []
+     * };
+     * this.appFeaturesService.applyPresetFeatures(enterprisePreset);
+     *
+     * // Apply "Basic Tier" preset
+     * const basicPreset: ForcedAppFeaturesState = {
+     *   enabled: [],
+     *   disabled: ['analytics', 'multi-user', 'white-label', 'sso']
+     * };
+     * this.appFeaturesService.applyPresetFeatures(basicPreset);
+     * ```
+     */
+    applyPresetFeatures(state: ForcedAppFeaturesState): void;
+    /**
+     * Get current forced feature state as a snapshot (for preset export).
+     *
+     * Returns the current forced features state with enabled/disabled arrays.
+     * Useful for exporting toolbar state to save as a preset or for debugging.
+     * Returns a defensive copy - mutations will not affect internal state.
+     *
+     * @returns Current forced features state
+     *
+     * @example
+     * ```typescript
+     * // Export current toolbar state to save as preset
+     * const currentState = this.appFeaturesService.getCurrentForcedState();
+     * this.presetsService.savePreset('my-config', {
+     *   appFeatures: currentState,
+     *   // ... other tool states
+     * });
+     *
+     * console.log(currentState);
+     * // { enabled: ['analytics'], disabled: ['white-label'] }
+     * ```
+     */
+    getCurrentForcedState(): ForcedAppFeaturesState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarAppFeaturesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarAppFeaturesService>;
+}

package/tools/network-mocker-tool/network-mocker-tool.component.d.ts

@@ -0,0 +1,23 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarNetworkMockerToolComponent {
+    private readonly networkMockerService;
+    protected readonly newMockUrl: import("@angular/core").WritableSignal<string>;
+    protected readonly newMockMethod: import("@angular/core").WritableSignal<string>;
+    protected readonly newMockStatus: import("@angular/core").WritableSignal<string>;
+    protected readonly newMockResponse: import("@angular/core").WritableSignal<string>;
+    protected readonly mockRequests: import("@angular/core").Signal<import("./network-mocker.models").MockRequest[]>;
+    protected readonly isMockingEnabled: import("@angular/core").Signal<boolean>;
+    protected readonly hasNoMocks: import("@angular/core").Signal<boolean>;
+    protected readonly options: DevToolbarWindowOptions;
+    protected readonly httpMethods: {
+        value: string;
+        label: string;
+    }[];
+    protected onAddMock(): void;
+    protected onToggleMocking(): void;
+    protected onToggleMock(mockId: string): void;
+    protected onRemoveMock(mockId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarNetworkMockerToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarNetworkMockerToolComponent, "ndt-network-mocker-tool", never, {}, {}, never, never, true, never>;
+}

package/tools/network-mocker-tool/network-mocker.models.d.ts

@@ -0,0 +1,16 @@
+export interface MockRequest {
+    id: string;
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    status: number;
+    response: any;
+    isActive: boolean;
+    createdAt: Date;
+}
+export interface MockRequestConfig {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    status?: number;
+    response?: any;
+    delay?: number;
+}

package/tools/network-mocker-tool/network-mocker.service.d.ts

@@ -0,0 +1,16 @@
+import { MockRequest, MockRequestConfig } from './network-mocker.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarNetworkMockerService {
+    private readonly mockRequests;
+    private readonly isMockingEnabled;
+    getMockRequests(): import("@angular/core").Signal<MockRequest[]>;
+    getIsMockingEnabled(): import("@angular/core").Signal<boolean>;
+    addMockRequest(config: MockRequestConfig): void;
+    removeMockRequest(id: string): void;
+    toggleMockRequest(id: string): void;
+    enableMocking(): void;
+    disableMocking(): void;
+    clearAllMocks(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarNetworkMockerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarNetworkMockerService>;
+}

package/tools/permissions-tool/permissions-internal.service.d.ts

@@ -0,0 +1,34 @@
+import { Observable } from 'rxjs';
+import { DevToolbarPermission, ForcedPermissionsState } from './permissions.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarInternalPermissionsService {
+    private readonly STORAGE_KEY;
+    private storageService;
+    private appPermissions$;
+    private forcedStateSubject;
+    private readonly forcedState$;
+    permissions$: Observable<DevToolbarPermission[]>;
+    permissions: import("@angular/core").Signal<DevToolbarPermission[]>;
+    constructor();
+    setAppPermissions(permissions: DevToolbarPermission[]): void;
+    setPermission(id: string, granted: boolean): void;
+    removePermissionOverride(id: string): void;
+    getForcedPermissions(): Observable<DevToolbarPermission[]>;
+    /**
+     * Apply a preset permissions state, replacing the current forced state.
+     * Useful for automated testing or restoring saved configurations.
+     * @param state The preset forced permissions state to apply
+     */
+    applyPresetPermissions(state: ForcedPermissionsState): void;
+    /**
+     * Get the current forced permissions state.
+     * Returns a deep copy to prevent external mutations.
+     * @returns Current forced permissions state
+     */
+    getCurrentForcedState(): ForcedPermissionsState;
+    private loadForcedState;
+    private isValidForcedState;
+    private validateAndCleanForcedState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarInternalPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarInternalPermissionsService>;
+}

package/tools/permissions-tool/permissions-tool.component.d.ts

@@ -0,0 +1,27 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import { DevToolbarPermission, PermissionFilter } from './permissions.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarPermissionsToolComponent {
+    private readonly permissionsService;
+    protected readonly activeFilter: import("@angular/core").WritableSignal<PermissionFilter>;
+    protected readonly searchQuery: import("@angular/core").WritableSignal<string>;
+    protected readonly permissions: import("@angular/core").Signal<DevToolbarPermission[]>;
+    protected readonly hasNoPermissions: import("@angular/core").Signal<boolean>;
+    protected readonly filteredPermissions: import("@angular/core").Signal<DevToolbarPermission[]>;
+    protected readonly hasNoFilteredPermissions: import("@angular/core").Signal<boolean>;
+    protected readonly options: DevToolbarWindowOptions;
+    protected readonly filterOptions: {
+        value: string;
+        label: string;
+    }[];
+    protected readonly permissionValueOptions: {
+        value: string;
+        label: string;
+    }[];
+    onFilterChange(value: string | undefined): void;
+    onPermissionChange(id: string, value: string): void;
+    onSearchChange(query: string): void;
+    protected getPermissionValue(permission: DevToolbarPermission): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarPermissionsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarPermissionsToolComponent, "ndt-permissions-tool", never, {}, {}, never, never, true, never>;
+}

package/tools/permissions-tool/permissions.models.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Represents a permission in the developer toolbar.
+ * Used to configure and override application permissions for testing.
+ */
+export interface DevToolbarPermission {
+    /** Unique identifier for the permission */
+    id: string;
+    /** Human-readable name displayed in the UI */
+    name: string;
+    /** Optional description explaining the permission's purpose */
+    description?: string;
+    /** Whether the permission is currently granted */
+    isGranted: boolean;
+    /** Whether the permission's value has been overridden through the toolbar */
+    isForced: boolean;
+}
+/**
+ * Internal state representing forced permission overrides.
+ * Persisted to localStorage for session continuity.
+ */
+export interface ForcedPermissionsState {
+    /** Array of permission IDs that are forced to granted */
+    granted: string[];
+    /** Array of permission IDs that are forced to denied */
+    denied: string[];
+}
+/**
+ * Filter options for displaying permissions in the tool.
+ */
+export type PermissionFilter = 'all' | 'forced' | 'granted' | 'denied';
+/**
+ * Permission value options for the dropdown control.
+ */
+export type PermissionValue = 'not-forced' | 'granted' | 'denied';