ngx-dev-toolbar 1.0.3 → 1.0.5

package/index.d.ts

@@ -0,0 +1,19 @@
+export * from './components/icons/icon.component';
+export * from './components/icons/icon.models';
+export * from './components/toolbar-tool/toolbar-tool.component';
+export * from './components/toolbar-tool/toolbar-tool.models';
+export * from './dev-toolbar.component';
+export * from './models/dev-tools.interface';
+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/models/dev-tools.interface.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+/**
+ * Interface that should be implemented by any tool service that is used in the dev toolbar
+ */
+export interface DevToolsService<OptionType> {
+    /**
+     * Sets the available options that will be displayed in the tool on the dev toolbar
+     * @param options The options to be displayed
+     */
+    setAvailableOptions(options: OptionType[]): void;
+    /**
+     * Gets the values that were forced/modified through the tool on the dev toolbar.
+     * If the tool only supports a single option, the returned array will have a single element.
+     * @returns Observable of forced values array
+     */
+    getForcedValues(): Observable<OptionType[]>;
+}

package/package.json

@@ -1,13 +1,36 @@
 {
   "name": "ngx-dev-toolbar",
-  "version": "1.0.3",
+  "version": "1.0.5",
+  "keywords": [
+    "devtools",
+    "development-toolbar",
+    "dev-toolbar",
+    "angular",
+    "typescript",
+    "rxjs",
+    "signals"
+  ],
   "peerDependencies": {
-    "@angular/core": "^19.0.0",
-    "@angular/common": "^19.0.0",
-    "@angular/forms": "^19.0.0",
-    "@angular/animations": "^19.0.0",
-    "@angular/cdk": "^19.0.0",
-    "rxjs": "~7.8.0"
+    "@angular/core": ">=18.0.0 ",
+    "@angular/common": ">=18.0.0",
+    "@angular/forms": ">=18.0.0",
+    "@angular/animations": ">=18.0.0",
+    "@angular/cdk": ">=18.0.0",
+    "rxjs": "^6.0.0 || ^7.0.0"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "module": "fesm2022/ngx-dev-toolbar.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/ngx-dev-toolbar.mjs"
+    }
+  },
+  "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/feature-flags-tool/feature-flags-internal.service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { DevToolbarFlag } from './feature-flags.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarInternalFeatureFlagService {
+    private readonly STORAGE_KEY;
+    private storageService;
+    private appFlags$;
+    private forcedFlagsSubject;
+    private readonly forcedFlags$;
+    flags$: Observable<DevToolbarFlag[]>;
+    flags: import("@angular/core").Signal<DevToolbarFlag[]>;
+    constructor();
+    setAppFlags(flags: DevToolbarFlag[]): void;
+    getAppFlags(): Observable<DevToolbarFlag[]>;
+    getForcedFlags(): Observable<DevToolbarFlag[]>;
+    setFlag(flagId: string, isEnabled: boolean): void;
+    removeFlagOverride(flagId: string): void;
+    private loadForcedFlags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarInternalFeatureFlagService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarInternalFeatureFlagService>;
+}

package/tools/feature-flags-tool/feature-flags-tool.component.d.ts

@@ -0,0 +1,27 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import { DevToolbarFlag, FeatureFlagFilter } from './feature-flags.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarFeatureFlagsToolComponent {
+    private readonly featureFlags;
+    protected readonly activeFilter: import("@angular/core").WritableSignal<FeatureFlagFilter>;
+    protected readonly searchQuery: import("@angular/core").WritableSignal<string>;
+    protected readonly flags: import("@angular/core").Signal<DevToolbarFlag[]>;
+    protected readonly hasNoFlags: import("@angular/core").Signal<boolean>;
+    protected readonly filteredFlags: import("@angular/core").Signal<DevToolbarFlag[]>;
+    protected readonly hasNoFilteredFlags: import("@angular/core").Signal<boolean>;
+    protected readonly options: DevToolbarWindowOptions;
+    protected readonly filterOptions: {
+        value: string;
+        label: string;
+    }[];
+    protected readonly flagValueOptions: {
+        value: string;
+        label: string;
+    }[];
+    onFilterChange(value: string | undefined): void;
+    onFlagChange(flagId: string, value: string): void;
+    onSearchChange(query: string): void;
+    protected getFlagValue(flag: DevToolbarFlag): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarFeatureFlagsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarFeatureFlagsToolComponent, "ndt-feature-flags-tool", never, {}, {}, never, never, true, never>;
+}

package/tools/feature-flags-tool/feature-flags.models.d.ts

@@ -0,0 +1,9 @@
+export interface DevToolbarFlag {
+    id: string;
+    name: string;
+    description?: string;
+    link?: string;
+    isEnabled: boolean;
+    isForced: boolean;
+}
+export type FeatureFlagFilter = 'all' | 'forced' | 'enabled' | 'disabled';

package/tools/feature-flags-tool/feature-flags.service.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { DevToolsService } from '../../models/dev-tools.interface';
+import { DevToolbarFlag } from './feature-flags.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarFeatureFlagService implements DevToolsService<DevToolbarFlag> {
+    private internalService;
+    /**
+     * Sets the available flags that will be displayed in the tool on the dev toolbar
+     * @param flags The flags to be displayed
+     */
+    setAvailableOptions(flags: DevToolbarFlag[]): void;
+    /**
+     * Gets the flags that were forced/modified through the tool on the dev toolbar
+     * @returns Observable of forced flags array
+     */
+    getForcedValues(): Observable<DevToolbarFlag[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarFeatureFlagService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarFeatureFlagService>;
+}

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

@@ -0,0 +1,38 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import { DevToolbarStateService } from '../../dev-toolbar-state.service';
+import * as i0 from "@angular/core";
+export declare class DevToolbarHomeToolComponent {
+    protected readonly state: DevToolbarStateService;
+    private readonly settingsService;
+    private readonly storageService;
+    readonly badge: import("@angular/core").InputSignal<string | number | undefined>;
+    readonly title = "Angular Dev Toolbar";
+    readonly options: DevToolbarWindowOptions;
+    readonly links: readonly [{
+        readonly icon: "bug";
+        readonly url: "https://github.com/alfredoperez/ngx-dev-toolbar/issues";
+        readonly label: "Bug report";
+    }, {
+        readonly icon: "lightbulb";
+        readonly url: "https://github.com/alfredoperez/ngx-dev-toolbar/discussions";
+        readonly label: "Suggestions";
+    }, {
+        readonly icon: "docs";
+        readonly url: "https://alfredoperez.github.io/ngx-dev-toolbar/";
+        readonly label: "Docs";
+    }, {
+        readonly icon: "star";
+        readonly url: "https://github.com/alfredoperez/ngx-dev-toolbar";
+        readonly label: "Star on GitHub";
+    }, {
+        readonly icon: "discord";
+        readonly url: "https://discord.com/invite/angular";
+        readonly label: "Community";
+    }];
+    onToggleTheme(): void;
+    onExportSettings(): void;
+    onImportSettings(): void;
+    onResetSettings(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarHomeToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarHomeToolComponent, "ndt-home-tool", never, { "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/{src/tools/home-tool/settings.models.ts → tools/home-tool/settings.models.d.ts}

@@ -1,3 +1,3 @@
 export interface Settings {
-  isDarkMode: boolean;
+    isDarkMode: boolean;
 }

package/tools/home-tool/settings.service.d.ts

@@ -0,0 +1,10 @@
+import { Settings } from './settings.models';
+import * as i0 from "@angular/core";
+export declare class SettingsService {
+    private readonly STORAGE_KEY;
+    private readonly storageService;
+    getSettings(): Settings;
+    setSettings(settings: Settings): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
+}

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

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { Language } from './language.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarInternalLanguageService {
+    private readonly STORAGE_KEY;
+    private readonly storageService;
+    private languages$;
+    private forcedLanguage$;
+    languages: import("@angular/core").Signal<Language[]>;
+    constructor();
+    setAppLanguages(languages: Language[]): void;
+    getAppLanguages(): Observable<Language[]>;
+    setForcedLanguage(language: Language): void;
+    getForcedLanguage(): Observable<Language[]>;
+    removeForcedLanguage(): void;
+    private loadForcedLanguage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarInternalLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarInternalLanguageService>;
+}