import * as i0 from '@angular/core';
import { WritableSignal, Type, EnvironmentProviders, InjectionToken, AfterContentInit, OnDestroy } from '@angular/core';
import * as _ardimedia_angular_portal_azure from '@ardimedia/angular-portal-azure';

/**
 * Defines a command button in a blade's command bar.
 *
 * Replaces the 18 individual command boolean groups from v0.2.346.
 * Each command has visibility, enabled state, label text, icon, and action callback.
 */
interface BladeCommand {
    /** Unique key identifying the command (e.g. 'save', 'delete', 'new') */
    key: string;
    /** Display text for the command button */
    label: string;
    /** Whether the command button is visible */
    visible: boolean;
    /** Whether the command button is enabled (clickable) */
    enabled: boolean;
    /** SVG icon identifier or CSS class for the command icon */
    icon?: string;
    /** Callback executed when the command is clicked (supports async) */
    action: () => void | Promise<void>;
}
/**
 * Standard command keys matching the 18 commands from v0.2.346:
 * browse, cancel, copy, delete, document, document2, document3, document4, document5,
 * new, order, restart, save, search, start, stop, swap, excel
 */
type StandardCommandKey = 'browse' | 'cancel' | 'copy' | 'delete' | 'document' | 'document2' | 'document3' | 'document4' | 'document5' | 'new' | 'order' | 'restart' | 'save' | 'search' | 'start' | 'stop' | 'swap' | 'excel';
/** Creates a command with sensible defaults (visible, enabled, no-op action) */
declare function createCommand(key: string, label: string, action: () => void | Promise<void>, icon?: string): BladeCommand;

/**
 * Status bar display state for a blade.
 * Ported from UserControlBase.statusBar / statusBarClass in v0.2.346.
 */
interface StatusBarState {
    /** Status bar text message */
    text: string;
    /** CSS class for styling (e.g. 'info', 'error', 'success') */
    style: StatusBarStyle;
}
type StatusBarStyle = 'none' | 'info' | 'error' | 'success' | 'warning';
declare function clearStatusBar(): StatusBarState;
declare function statusBarInfo(text: string): StatusBarState;
declare function statusBarError(text: string): StatusBarState;
declare function statusBarSuccess(text: string): StatusBarState;

/** @internal */
declare function nextBladeUid(): number;
/**
 * Base blade definition used by BladeService to manage the blade stack.
 * Ported from Blade class in v0.2.346 — flattened from the UserControlBase → Blade hierarchy.
 *
 * In v0.2.346 this was a class with 18 command boolean groups and deep inheritance.
 * In v0.3.0 commands are a BladeCommand[] array and blade state is managed by the service.
 */
interface BladeDefinition {
    /** Auto-incrementing unique ID for @for track identity */
    readonly uid: number;
    /** Unique path identifying this blade (lowercased) */
    path: string;
    /** Blade header title */
    title: string;
    /** Blade header subtitle */
    subtitle: string;
    /** Blade width in pixels */
    width: number;
    /** Whether the blade content uses inner HTML (ng-content) vs structured content */
    isInnerHtml: boolean;
    /** Command bar buttons */
    commands: BladeCommand[];
    /** Status bar state */
    statusBar: StatusBarState;
    /** URL-persisted parameters for this blade (e.g., { id: '1' }) */
    params: Record<string, string>;
}
/** Creates a blade definition with sensible defaults.
 *  statusBar and title use getter/setter pairs backed by signals for zoneless change detection. */
declare function createBlade(path: string, title: string, width?: number, params?: Record<string, string>, uid?: number): BladeDefinition;
/**
 * Event args for blade navigation.
 * Ported from IAddBladeEventArgs in v0.2.346.
 */
interface AddBladeEventArgs {
    path: string;
    pathSender: string;
}

/**
 * Localization labels for the angular-portal-azure library.
 * All labels default to German (de-CH). Override via PortalConfig.labels.
 */
interface PortalLabels {
    loading: string;
    saving: string;
    saved: string;
    deleting: string;
    deleted: string;
    loadError: string;
    saveError: string;
    deleteError: string;
    cmdNew: string;
    cmdSave: string;
    cmdDelete: string;
    cmdCancel: string;
    search: string;
    close: string;
    noAppsTitle: string;
    noAppsMessage: string;
    closePanel: string;
    lightMode: string;
    darkMode: string;
    switchToLight: string;
    switchToDark: string;
    settings: string;
    language: string;
    appearance: string;
    unsavedChangesConfirm: string;
}
/** Language preset definition for the built-in language registry. */
interface LanguagePreset {
    code: string;
    displayName: string;
    labels: PortalLabels;
}
/** German (Switzerland / Liechtenstein) — default */
declare const LABELS_DE_CH: PortalLabels;
/** German (Germany) — Swiss spelling rules apply (no ß) */
declare const LABELS_DE_DE: PortalLabels;
/** English */
declare const LABELS_EN: PortalLabels;
/** French */
declare const LABELS_FR: PortalLabels;
/** Spanish */
declare const LABELS_ES: PortalLabels;
/** Italian */
declare const LABELS_IT: PortalLabels;
/** Keep DEFAULT_LABELS as alias for backward compatibility */
declare const DEFAULT_LABELS: PortalLabels;
/** Built-in language presets. Consumers can add custom presets via registerLanguagePreset(). */
declare const LANGUAGE_PRESETS: Map<string, LanguagePreset>;
/** Register a custom language preset. */
declare function registerLanguagePreset(preset: LanguagePreset): void;

/**
 * Exception model for API error responses.
 * Ported from Exception / ExceptionDotNet in v0.2.346.
 */
interface ApiException {
    message: string;
    status?: number;
    statusText?: string;
    data?: Array<{
        key: number;
        value: string;
    }>;
    validationResults?: Array<{
        errorMessage: string;
        memberNames: string[];
    }>;
}
/**
 * Lifecycle hooks for CRUD operations on a blade.
 * Ported from BladeData<T> template method pattern in v0.2.346.
 *
 * Each operation follows the pattern: onBefore → execute → onSuccess | onError
 */
interface BladeDataLifecycle<T> {
    onLoadItem?: () => void;
    onLoadedItem?: () => void;
    onLoadItemError?: (ex: ApiException) => void;
    onLoadItems?: () => void;
    onLoadedItems?: () => void;
    onLoadItemsError?: (ex: ApiException) => void;
    onSaveItem?: () => void;
    onSavedItem?: () => void;
    onSaveItemError?: (ex: ApiException) => void;
    onDeleteItem?: () => void;
    onDeletedItem?: () => boolean;
    onDeleteItemError?: (ex: ApiException) => void;
    onNewItem?: () => void;
    onNewedItem?: () => void;
    onNewItemError?: (ex: ApiException) => void;
    onExecute?: () => void;
    onExecuted?: () => void;
    onExecuteError?: (ex: ApiException) => void;
    isFormValid?: () => boolean;
    isDirty?: () => boolean;
}
/**
 * Extended blade definition for data-driven blades with CRUD operations.
 * Ported from BladeData<T> in v0.2.346.
 */
interface BladeDataDefinition<T> extends BladeDefinition {
    /** Current item being edited/viewed */
    item: T;
    /** List of items (for grid/list blades) */
    items: T[];
    /** Whether data is currently being loaded */
    loading: boolean;
    /** Lifecycle hooks for CRUD operations */
    lifecycle: BladeDataLifecycle<T>;
}
/** Creates a data blade definition with sensible defaults.
 *  statusBar, title, item, items use getter/setter pairs backed by signals for zoneless change detection.
 *  Note: cannot use ...createBlade() spread here — spread copies getter values, not getter/setter pairs. */
declare function createDataBlade<T>(path: string, title: string, width?: number, params?: Record<string, string>, uid?: number): BladeDataDefinition<T>;
/**
 * Execute a load-item operation with lifecycle hooks and status bar updates.
 * Replaces the BladeData.loadItem() template method from v0.2.346.
 */
declare function executeLoadItem<T>(blade: BladeDataDefinition<T>, loadFn: () => Promise<T>, labels?: PortalLabels): Promise<T | void>;
/**
 * Execute a load-items operation with lifecycle hooks and status bar updates.
 */
declare function executeLoadItems<T>(blade: BladeDataDefinition<T>, loadFn: () => Promise<T[]>, labels?: PortalLabels): Promise<T[] | void>;
/**
 * Execute a save-item operation with lifecycle hooks and status bar updates.
 */
declare function executeSaveItem<T>(blade: BladeDataDefinition<T>, saveFn: () => Promise<T>, labels?: PortalLabels): Promise<T | void>;
/**
 * Execute a delete-item operation with lifecycle hooks and status bar updates.
 * Returns true if the blade should be closed after deletion.
 */
declare function executeDeleteItem<T>(blade: BladeDataDefinition<T>, deleteFn: () => Promise<void>, labels?: PortalLabels): Promise<boolean>;

/**
 * Navigation item displayed in a BladeNav component.
 * Ported from BladeNavItem in v0.2.346.
 */
interface BladeNavItem {
    /** Display title */
    title: string;
    /** CSS class for the icon */
    cssClass?: string;
    /** Path of the blade to open when clicked */
    bladePath: string;
    /** External href link (alternative to bladePath) */
    hrefPath?: string;
    /** Comma-separated role names for visibility control */
    roles?: string;
    /** Whether this nav item is visible */
    isVisible: boolean;
    /** Optional callback executed on click (in addition to navigation) */
    callback?: () => void;
    /** Optional badge text (e.g. notification count) */
    badge?: string;
}
declare function createNavItem(title: string, bladePath: string, cssClass?: string): BladeNavItem;

/**
 * Parameters passed when opening a blade.
 * Ported from BladeParameter interface in v0.2.346.
 */
interface BladeParameter {
    action: string;
    item?: unknown;
    itemId: number;
}

/**
 * Tile size enum matching v0.2.346 TileSizes.
 * The names are used in CSS class names (e.g. 'fxs-tilesize-normal').
 */
declare enum TileSize {
    Small = "small",
    Mini = "mini",
    Normal = "normal",
    HeroWide = "herowide"
}
/** Pixel dimensions for each tile size */
declare const TILE_DIMENSIONS: Record<TileSize, {
    width: number;
    height: number;
}>;
/**
 * Tile definition for the panorama/startboard.
 * Ported from Tile in v0.2.346.
 */
interface TileDefinition {
    /** Display title on the tile */
    title: string;
    /** Optional subtitle */
    subtitle?: string;
    /** Path of the blade to open when the tile is clicked */
    bladePath: string;
    /** Tile size (determines CSS class and dimensions) */
    size: TileSize;
    /** Optional CSS class for tile icon/content */
    cssClass?: string;
    /** Whether the tile is disabled (grayed out, not clickable) */
    disabled?: boolean;
}
declare function createTile(title: string, bladePath: string, size?: TileSize): TileDefinition;

/**
 * User account information for the avatar menu.
 * Ported from UserAccount in v0.2.346.
 */
interface UserAccount {
    userName: string;
    firstName: string;
    lastName: string;
    emailAddress?: string;
}
/** Computed full name from first and last name */
declare function getUserDisplayName(account: UserAccount): string;

/**
 * Notification panel definition.
 * Ported from AreaNotification in v0.2.346.
 */
/** Lifecycle hooks for the notification panel */
interface NotificationLifecycle {
    /** Called before hide; return false to prevent hiding */
    onHide?: () => boolean;
    /** Called before showing */
    onShow?: () => void;
    /** Called after the panel is shown */
    onShowed?: () => void;
}
interface NotificationDefinition {
    /** Path/identifier for the content shown in the notification area */
    path: string;
    /** Panel width in pixels (default 250) */
    width: number;
    /** Whether the notification panel is currently visible */
    isVisible: boolean;
    /** Background color (default '#32383f') */
    backgroundColor: string;
    /** Optional lifecycle hooks invoked during show/hide transitions */
    lifecycle?: NotificationLifecycle;
}
declare function createNotificationPanel(): NotificationDefinition;

/**
 * Panorama (startboard) definition.
 * Ported from Panorama + Startboard + Tiles in v0.2.346.
 *
 * The panorama is the dashboard view that shows tiles and toggles
 * visibility with the blade area.
 */
interface PanoramaDefinition {
    /** Portal title displayed in the panorama header */
    title: string;
    /** Whether the panorama/startboard is visible (hidden when blades are open) */
    isVisible: boolean;
    /** Whether tiles have been loaded */
    isTilesLoaded: boolean;
    /** Whether to show tiles at all */
    showTiles: boolean;
    /** Hide the tile section if only one tile exists */
    hideTileIfOnlyOne: boolean;
    /** Positioned tiles with layout coordinates */
    tiles: PositionedTile[];
}
/** A tile with computed layout position (left/top in pixels) */
interface PositionedTile extends TileDefinition {
    /** Horizontal offset in pixels */
    left: number;
    /** Vertical offset in pixels */
    top: number;
}
/**
 * Lay out tiles in a flowing grid pattern matching v0.2.346's Tiles.addTile() algorithm.
 * Tiles wrap after 540px width (3 normal tiles or 1 hero-wide tile).
 */
declare function layoutTiles(tiles: TileDefinition[]): PositionedTile[];
declare function createPanorama(title: string): PanoramaDefinition;

/**
 * A single item in the avatar dropdown menu.
 */
interface AvatarMenuItem {
    /** Display text */
    label: string;
    /** Navigation URL. Used when {@link action} is not set; ignored otherwise (use '#'). */
    href: string;
    /** Optional icon CSS class, e.g. 'ti ti-settings' */
    icon?: string;
    /**
     * Optional click handler. When set, the item performs this action instead of navigating to
     * {@link href} (e.g. open a blade). The dropdown closes and the default link navigation is
     * prevented.
     */
    action?: () => void;
}
/**
 * Avatar menu definition for the user menu in the portal header.
 * Ported from AvatarMenu in v0.2.346.
 */
interface AvatarMenuDefinition {
    /** The logged-in user's account info */
    userAccount: UserAccount;
    /** Whether the avatar dropdown is currently open */
    isOpen: boolean;
    /** Menu items shown in the dropdown */
    items: AvatarMenuItem[];
}
declare function createAvatarMenu(): AvatarMenuDefinition;

/**
 * Configuration for the angular-portal-azure library.
 * Passed to providePortalAzure() in the app's ApplicationConfig.
 *
 * This is new in v0.3.0 — v0.2.346 configured via PortalShell constructor
 * and individual directive attributes.
 */
interface PortalConfig {
    /** Portal title displayed in the panorama header */
    title: string;
    /** Dashboard tiles for the startboard */
    tiles?: TileDefinition[];
    /** Initial user account (can be set later via PortalService) */
    userAccount?: UserAccount;
    /** Theme identifier (default: 'azure-blue') */
    theme?: string;
    /** Override default labels for localization (defaults to German/de-CH) */
    labels?: Partial<PortalLabels>;
    /** Language code (e.g. 'en', 'fr'). Default: auto-detect from browser, fallback 'de-CH' */
    language?: string;
}

/**
 * Multi-word search filter for grid/list blades.
 * Ported from BladeGrid.onFilter() in v0.2.346.
 *
 * Splits the search string by spaces and checks if ALL words
 * are found in ANY string property of the item.
 */
declare function filterItems<T>(items: T[], searchText: string): T[];

/**
 * Central state service for the angular-portal-azure library.
 * Replaces v0.2.346's PortalService + Panorama + AreaNotification state.
 *
 * All state is managed via Angular signals for reactive updates.
 */
declare class PortalService {
    private static readonly LANG_STORAGE_KEY;
    /** Localization labels (defaults to German/de-CH, override via PortalConfig.labels) */
    readonly labels: WritableSignal<PortalLabels>;
    /** Current language code */
    readonly currentLanguage: WritableSignal<string>;
    /** Whether the settings dropdown is open */
    readonly isSettingsOpen: WritableSignal<boolean>;
    /** The blade stack — ordered left-to-right */
    readonly blades: WritableSignal<BladeDefinition[]>;
    /** Panorama (startboard/dashboard) state */
    readonly panorama: WritableSignal<PanoramaDefinition>;
    /** Notification panel state */
    readonly notification: WritableSignal<NotificationDefinition>;
    /** Avatar menu state */
    readonly avatarMenu: WritableSignal<AvatarMenuDefinition>;
    /** Shared parameter for passing data between blades */
    readonly parameter: WritableSignal<BladeParameter>;
    /** Portal theme identifier */
    readonly theme: WritableSignal<string>;
    /** Whether the panorama is visible (true when no blades are open) */
    readonly isPanoramaVisible: i0.Signal<boolean>;
    /** Number of open blades */
    readonly bladeCount: i0.Signal<number>;
    /** Positioned tiles with layout coordinates */
    readonly positionedTiles: i0.Signal<PositionedTile[]>;
    /** Consumer label overrides from PortalConfig — re-applied on every language switch */
    private _configLabelOverrides;
    /**
     * Initialize the portal with configuration.
     * Called by providePortalAzure() during app bootstrap.
     */
    configure(config: PortalConfig): void;
    /** Switch the active language. Persists to localStorage. */
    setLanguage(code: string): void;
    /** Detect language from browser, match to closest preset. */
    private detectBrowserLanguage;
    /** Toggle settings dropdown. Closes avatar menu if opening. */
    toggleSettings(): void;
    /** Close settings dropdown */
    closeSettings(): void;
    /** Update the portal title */
    setTitle(title: string): void;
    /** Update the user account */
    setUserAccount(userAccount: UserAccount): void;
    /** Clear all blades and return to panorama */
    clearBlades(): void;
    /** Set tiles on the startboard */
    setTiles(tiles: TileDefinition[]): void;
    /** Set blade parameter for inter-blade communication */
    setParameter(param: Partial<BladeParameter>): void;
    /** Clear the blade parameter back to defaults */
    clearParameter(): void;
    /** Show the notification panel */
    showNotification(path: string, width?: number, lifecycle?: NotificationLifecycle): void;
    /** Hide the notification panel. Aborted if onHide() returns false. */
    hideNotification(): void;
    /** Toggle avatar menu open/close. Closes settings if opening. */
    toggleAvatarMenu(): void;
    /** Close avatar menu */
    closeAvatarMenu(): void;
    /** Set avatar menu items */
    setAvatarMenuItems(items: AvatarMenuItem[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PortalService>;
}

/**
 * Blade stack management service.
 * Replaces v0.2.346's AreaBlades class.
 *
 * Manages the blade stack: adding, removing, cascade-closing,
 * and panorama visibility toggling.
 *
 * When a BladeRegistry is available, metadata (title, width) from the
 * registry is used as defaults — explicit arguments take precedence.
 */
declare class BladeService {
    private readonly portal;
    private readonly registry;
    /**
     * Unsaved-changes guard registry: blade path -> predicate returning true when the blade has
     * unsaved edits. Populated by apa-blade-detail (from the projected NgForm). Consulted before a
     * blade is closed/replaced or the page is left, so the user can confirm discarding changes.
     * Message can be localised via PortalLabels.unsavedChangesConfirm; the navigation flow is
     * synchronous, so a synchronous window.confirm is used.
     */
    private readonly dirtyChecks;
    /** Optional override for the confirmation message (defaults to the de-CH label). */
    unsavedChangesMessage: string;
    constructor();
    /** Register a blade's unsaved-changes predicate (called by apa-blade-detail). */
    registerDirtyCheck(path: string, isDirty: () => boolean): void;
    /** Remove a blade's unsaved-changes predicate (called when the detail is destroyed). */
    unregisterDirtyCheck(path: string): void;
    private isPathDirty;
    private anyDirty;
    /**
     * Returns true if it's OK to proceed with removing the given blade paths: none of them is dirty,
     * or the user confirmed discarding the changes. Shows one confirmation regardless of how many
     * dirty blades are affected.
     */
    private mayDiscard;
    /** Drop dirty-check entries for paths that are no longer open. */
    private pruneDirtyChecks;
    /**
     * Set the first blade (e.g., when opening a top-level item from a tile).
     * Clears all existing blades, hides panorama, and adds the new blade.
     *
     * Ported from AreaBlades.setFirstBlade() in v0.2.346.
     */
    setFirstBlade(path: string, title?: string, width?: number): BladeDefinition;
    /**
     * Add a blade to the stack. If senderPath is provided, all blades
     * after the sender are removed first (cascade close).
     *
     * Ported from AreaBlades.addBlade() in v0.2.346.
     */
    addBlade(path: string, senderPath?: string, title?: string, width?: number, params?: Record<string, string>): BladeDefinition | undefined;
    /**
     * Open a blade from a navigation event (e.g., tile click, nav item click).
     * Wraps addBlade with AddBladeEventArgs for compatibility.
     */
    openBlade(args: AddBladeEventArgs, title?: string, width?: number): BladeDefinition | undefined;
    /**
     * Clear all blades. Shows panorama if appropriate.
     * Ported from AreaBlades.clearAll() in v0.2.346.
     */
    clearAll(): void;
    /**
     * Remove a specific blade and all blades to its right.
     * This is what happens when a blade is closed.
     *
     * Ported from AreaBlades.clearPath() in v0.2.346.
     */
    clearPath(path: string): boolean;
    /**
     * Remove all blades AFTER a given path (keeps the blade itself).
     * Used for cascade close when a blade opens a child.
     *
     * Ported from AreaBlades.clearChild() in v0.2.346.
     */
    clearChild(path: string): boolean;
    /**
     * Remove blades at and beyond a specific 1-based level.
     * Ported from AreaBlades.clearLevel() in v0.2.346.
     */
    clearLevel(level: number): void;
    /**
     * Remove only the last (rightmost) blade.
     * Ported from AreaBlades.clearLastLevel() in v0.2.346.
     */
    clearLastLevel(): void;
    /**
     * Close a specific blade by its definition reference.
     * Removes the blade and all blades to its right.
     */
    closeBlade(blade: BladeDefinition): void;
    /**
     * Get a blade by path, if it exists in the stack.
     */
    getBlade(path: string): BladeDefinition | undefined;
    /**
     * Check if a blade with the given path is currently open.
     */
    isBladeOpen(path: string): boolean;
    /**
     * Get URL-persisted parameters for a blade by path.
     * Returns empty object if blade not found or has no params.
     */
    getBladeParams(path: string): Record<string, string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BladeService>;
}

/** Entry in the blade registry: component + optional metadata for URL restoration */
interface BladeRegistryEntry {
    component: Type<unknown>;
    title?: string;
    width?: number;
    /** Parameter names this blade expects from the URL (e.g., ['id']) */
    params?: string[];
}
/**
 * Registry for mapping blade paths to Angular components.
 *
 * Allows consumer apps to register components for blade paths,
 * enabling dynamic rendering in BladeHostComponent without
 * manual @switch blocks.
 *
 * Usage in app bootstrap:
 * ```typescript
 * const registry = inject(BladeRegistry);
 * registry.register('customers', CustomerNavComponent);
 * registry.register('customers/list', CustomerListComponent, { title: 'All Customers', width: 585 });
 * ```
 *
 * Or register multiple at once:
 * ```typescript
 * registry.registerAll({
 *   'customers': CustomerNavComponent,
 *   'customers/list': CustomerListComponent,
 * });
 * ```
 */
declare class BladeRegistry {
    private readonly registry;
    /** Register a component for a blade path with optional metadata (title, width, params) */
    register(path: string, component: Type<unknown>, metadata?: {
        title?: string;
        width?: number;
        params?: string[];
    }): void;
    /** Register multiple blade path → component mappings */
    registerAll(mappings: Record<string, Type<unknown>>): void;
    /** Get the component registered for a path, if any */
    get(path: string): Type<unknown> | undefined;
    /** Get the full registry entry (component + metadata) for a path */
    getEntry(path: string): BladeRegistryEntry | undefined;
    /** Check if a component is registered for a path */
    has(path: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BladeRegistry>;
}

/**
 * Optional service that syncs the blade stack with the browser URL.
 *
 * When enabled, blade paths are stored as URL path segments with matrix params:
 *   `/crm/customers/list/detail;id=1`
 *
 * This makes blade states bookmarkable, shareable, and back-button navigable.
 *
 * Opt-in: add `provideBladeRouter()` to your app providers alongside `provideRouter()`.
 * Without it, blade navigation remains purely in-memory (no URL changes).
 */
declare class BladeRouterService {
    private readonly router;
    private readonly portal;
    private readonly registry;
    private readonly destroyRef;
    private readonly config;
    private _syncingFromUrl;
    private _initialRestoreDone;
    constructor();
    /**
     * Encode the blade stack into URL path segments.
     * Each blade contributes its "short name" (suffix after parent prefix).
     * Blades with params get Angular matrix params appended.
     *
     * Example: [customers, customers/list, customers/detail{id:1}]
     *   → "customers/list/detail;id=1"
     */
    private encodeBladesToPath;
    /**
     * Decode URL path segments into blade definitions.
     * Resolves short segment names to full blade paths using the registry.
     *
     * Example: "customers/list/detail;id=1" with route prefix "crm"
     *   → [customers, customers/list, customers/detail] with detail.params={id:'1'}
     */
    private decodeBladesFromPath;
    /**
     * Parse a URL segment into its name and matrix parameters.
     * "detail;id=1;mode=edit" → { name: "detail", params: { id: "1", mode: "edit" } }
     */
    private parseSegment;
    /**
     * Resolve a short segment name to a full blade path using the registry.
     * Tries parent/segment first, then walks up ancestors.
     */
    private resolveSegment;
    /** Restore blade stack from a path-based URL */
    private restoreFromPath;
    /** Check if params match between two blade arrays */
    private paramsMatch;
    /** Get the route prefix from the current URL (e.g., 'crm' from '/crm/...') */
    private getRoutePrefix;
    /** Normalize URL for comparison (strip trailing slashes) */
    private normalizeUrl;
    /** Extract legacy `blades` query parameter from URL */
    private extractLegacyBladesParam;
    /** Handle legacy ?blades= URL by redirecting to new path format */
    private handleLegacyUrl;
    /**
     * Return the effective route prefix. If a prefix was configured via
     * `provideBladeRouter({ prefix })`, use it (including empty string).
     * Otherwise fall back to dynamically reading the first URL segment.
     */
    private getEffectivePrefix;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeRouterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BladeRouterService>;
}

/**
 * Provide the angular-portal-azure library configuration.
 *
 * Usage in app.config.ts:
 * ```typescript
 * export const appConfig: ApplicationConfig = {
 *   providers: [
 *     providePortalAzure({
 *       title: 'My Portal',
 *       tiles: [...],
 *       theme: 'azure-blue',
 *     }),
 *   ],
 * };
 * ```
 *
 * New in v0.3.0 — no equivalent in v0.2.346 (which used PortalShell constructor).
 */
declare function providePortalAzure(config: PortalConfig): EnvironmentProviders;

/** Configuration for `provideBladeRouter()`. */
interface BladeRouterConfig {
    /**
     * Fixed URL prefix for blade path segments.
     *
     * - When omitted, the prefix is read dynamically from the first URL segment (default).
     * - When set to a non-empty string (e.g. `'app'`), that string is used as the fixed prefix.
     * - When set to `''` (empty string), blade paths are encoded directly at the URL root with no prefix.
     */
    prefix?: string;
}
/** @internal */
declare const BLADE_ROUTER_CONFIG: InjectionToken<BladeRouterConfig>;
/**
 * Enables opt-in URL synchronization for the blade stack.
 *
 * Add alongside `provideRouter()` and `providePortalAzure()`:
 * ```typescript
 * export const appConfig: ApplicationConfig = {
 *   providers: [
 *     provideRouter(routes),
 *     providePortalAzure({ title: 'My Portal', ... }),
 *     provideBladeRouter(),
 *   ],
 * };
 * ```
 *
 * Optionally pass a config to set a fixed route prefix:
 * ```typescript
 * provideBladeRouter({ prefix: 'app' })   // → /app/customers/list
 * provideBladeRouter({ prefix: '' })       // → /customers/list (no prefix)
 * ```
 *
 * Without this provider, blade navigation remains purely in-memory.
 */
declare function provideBladeRouter(config?: BladeRouterConfig): EnvironmentProviders;

/**
 * Individual dashboard tile.
 * Ported from the tile section in home.html (v0.2.346).
 *
 * Usage:
 * ```html
 * <apa-tile [tile]="myTile" (tileClick)="onTileClick($event)" />
 * ```
 */
declare class TileComponent {
    readonly tile: i0.InputSignal<PositionedTile>;
    readonly tileClick: i0.OutputEmitterRef<PositionedTile>;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TileComponent, "apa-tile", never, { "tile": { "alias": "tile"; "required": true; "isSignal": true; }; }, { "tileClick": "tileClick"; }, never, never, true, never>;
}

/**
 * Panorama (startboard/dashboard) component.
 * Ported from the fxs-panorama-homearea section in home.html (v0.2.346).
 *
 * Displays tiles on the startboard. When a tile is clicked, it opens
 * the first blade via BladeService.setFirstBlade().
 *
 * When `autoNavigate` is true (default), clicking a tile automatically
 * opens the first blade. Set it to false to handle tile clicks manually
 * via the `(tileClick)` output.
 *
 * Usage:
 * ```html
 * <apa-panorama />
 * <apa-panorama [autoNavigate]="false" (tileClick)="onTileClick($event)" />
 * ```
 */
declare class PanoramaComponent {
    protected readonly portal: PortalService;
    private readonly bladeService;
    /** When false, tile clicks only emit tileClick without opening a blade. */
    readonly autoNavigate: i0.InputSignal<boolean>;
    /** Emitted when a tile is clicked (always, regardless of autoNavigate). */
    readonly tileClick: i0.OutputEmitterRef<PositionedTile>;
    protected panorama: i0.WritableSignal<_ardimedia_angular_portal_azure.PanoramaDefinition>;
    onTileClick(tile: PositionedTile): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanoramaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PanoramaComponent, "apa-panorama", never, { "autoNavigate": { "alias": "autoNavigate"; "required": false; "isSignal": true; }; }, { "tileClick": "tileClick"; }, never, never, true, never>;
}

/**
 * Root portal shell component.
 * Ported from the fxs-portal structure in home.html (v0.2.346).
 *
 * Provides the top bar (with portal title, settings gear, and avatar menu),
 * and the main content area. Child components (panorama, blade-host,
 * notification-panel) are projected via content projection.
 *
 * Usage:
 * ```html
 * <apa-portal-layout>
 *   <apa-panorama />
 *   <apa-blade-host />
 * </apa-portal-layout>
 * ```
 */
declare class PortalLayoutComponent {
    protected readonly portal: PortalService;
    private static readonly STORAGE_KEY;
    private readonly document;
    private readonly elementRef;
    private readonly injector;
    private readonly destroyRef;
    protected readonly isDark: i0.WritableSignal<boolean>;
    /** Available languages from the preset registry */
    protected readonly availableLanguages: {
        code: string;
        displayName: string;
    }[];
    /**
     * Handle an avatar dropdown item click. If the item defines an action (e.g. open a blade), run it
     * and suppress the default link navigation; otherwise let the href navigate normally.
     */
    protected onAvatarItemClick(item: AvatarMenuItem, event: Event): void;
    constructor();
    protected toggleDarkMode(): void;
    protected switchLanguage(code: string): void;
    private applyTheme;
    protected displayName(): string;
    protected initials(): string;
    protected notificationMargin(): number;
    protected onHomeClick(event: Event): void;
    private scrollToLastBlade;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PortalLayoutComponent, "apa-portal-layout", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Command bar for a blade.
 * Ported from the fxs-commandBar section in blade.html (v0.2.346).
 *
 * Replaces the 18 individual command buttons with a dynamic BladeCommand[] array.
 *
 * Usage:
 * ```html
 * <apa-command-bar [commands]="blade.commands" />
 * ```
 */
declare class CommandBarComponent {
    readonly commands: i0.InputSignal<BladeCommand[]>;
    visibleCommands(): BladeCommand[];
    onCommand(cmd: BladeCommand): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommandBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommandBarComponent, "apa-command-bar", never, { "commands": { "alias": "commands"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Blade chrome component — the visual container for a single blade.
 * Ported from blade.html (v0.2.346).
 *
 * Renders the blade header (status bar, close/maximize buttons, title,
 * command bar) and projects blade content via <ng-content>.
 *
 * Usage:
 * ```html
 * <apa-blade [blade]="myBlade">
 *   <p>Blade content here</p>
 * </apa-blade>
 * ```
 */
declare class BladeComponent {
    readonly blade: i0.InputSignal<BladeDefinition>;
    readonly bladeClose: i0.OutputEmitterRef<BladeDefinition>;
    protected readonly portal: PortalService;
    private readonly bladeService;
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BladeComponent, "apa-blade", never, { "blade": { "alias": "blade"; "required": true; "isSignal": true; }; }, { "bladeClose": "bladeClose"; }, never, ["*"], true, never>;
}

/**
 * Blade host — renders the blade stack (journey area).
 * Ported from the apa-blade-area section in home.html (v0.2.346).
 *
 * Each blade in the stack is rendered horizontally. When a new blade
 * is added, the portal layout scrolls to show it.
 *
 * If a component is registered via BladeRegistry for a blade path,
 * it is rendered dynamically via ngComponentOutlet. Otherwise,
 * the blade path is shown as fallback text.
 *
 * Usage:
 * ```html
 * <!-- Default: each component is wrapped in <apa-blade> -->
 * <apa-blade-host />
 *
 * <!-- No wrapper: components render directly (they manage their own blade chrome) -->
 * <apa-blade-host [wrapBlade]="false" />
 * ```
 */
declare class BladeHostComponent {
    /** Whether to wrap each component in an `<apa-blade>` element. Default: true. */
    readonly wrapBlade: i0.InputSignal<boolean>;
    protected readonly portal: PortalService;
    private readonly registry;
    getComponent(path: string): i0.Type<unknown> | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeHostComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BladeHostComponent, "apa-blade-host", never, { "wrapBlade": { "alias": "wrapBlade"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Navigation blade content — renders a list of nav items.
 * Ported from nav.html (v0.2.346).
 *
 * Each nav item shows an icon and title. Clicking a row opens
 * the target blade via BladeService.
 *
 * Usage:
 * ```html
 * <apa-blade [blade]="navBlade">
 *   <apa-blade-nav [items]="navItems" [senderPath]="navBlade.path" />
 * </apa-blade>
 * ```
 */
declare class BladeNavComponent {
    readonly items: i0.InputSignal<BladeNavItem[]>;
    readonly senderPath: i0.InputSignal<string>;
    private readonly bladeService;
    visibleItems(): BladeNavItem[];
    onItemClick(item: BladeNavItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BladeNavComponent, "apa-blade-nav", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "senderPath": { "alias": "senderPath"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Grid/list blade content — renders a searchable list of items.
 * Ported from grid.html + BladeGrid (v0.2.346).
 *
 * Displays items in a table with optional search filtering.
 * Each row shows a title and optional subtitle. Clicking a row
 * opens the target blade.
 *
 * Usage:
 * ```html
 * <apa-blade [blade]="gridBlade">
 *   <apa-blade-grid
 *     [items]="items"
 *     [senderPath]="gridBlade.path"
 *     [displayField]="'title'"
 *     (itemClick)="onItemClick($event)" />
 * </apa-blade>
 * ```
 */
declare class BladeGridComponent {
    readonly items: i0.InputSignal<any[]>;
    readonly senderPath: i0.InputSignal<string>;
    readonly displayField: i0.InputSignal<string>;
    readonly bladePathField: i0.InputSignal<string>;
    readonly idField: i0.InputSignal<string>;
    readonly iconClass: i0.InputSignal<string>;
    readonly searchable: i0.InputSignal<boolean>;
    readonly itemClick: i0.OutputEmitterRef<any>;
    searchText: string;
    private readonly bladeService;
    protected readonly portal: PortalService;
    filteredItems(): any[];
    getDisplayValue(item: any): string;
    onSearchInput(event: Event): void;
    onRowClick(item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BladeGridComponent, "apa-blade-grid", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "senderPath": { "alias": "senderPath"; "required": false; "isSignal": true; }; "displayField": { "alias": "displayField"; "required": false; "isSignal": true; }; "bladePathField": { "alias": "bladePathField"; "required": false; "isSignal": true; }; "idField": { "alias": "idField"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
}

/**
 * Detail/edit blade content — renders a form area for editing an item.
 * Ported from BladeDetail<T> (v0.2.346).
 *
 * Provides a content projection area for forms. The blade's commands
 * (save, delete, cancel, new) are managed via the blade definition.
 *
 * This is a thin wrapper that projects content and provides
 * convenience methods for setting up typical detail blade commands.
 *
 * Usage:
 * ```html
 * <apa-blade [blade]="detailBlade">
 *   <apa-blade-detail [blade]="detailBlade">
 *     <form>
 *       <!-- form fields here -->
 *     </form>
 *   </apa-blade-detail>
 * </apa-blade>
 * ```
 */
declare class BladeDetailComponent implements AfterContentInit, OnDestroy {
    readonly blade: i0.InputSignal<BladeDataDefinition<any>>;
    private readonly bladeService;
    /** The template-driven form projected into this detail, if any (auto-discovered). */
    private readonly form;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BladeDetailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BladeDetailComponent, "apa-blade-detail", never, { "blade": { "alias": "blade"; "required": true; "isSignal": true; }; }, {}, ["form"], ["*"], true, never>;
}
/**
 * Create standard detail blade commands (new, save, delete, cancel).
 * Convenience function for setting up typical detail/edit blade commands
 * matching the v0.2.346 BladeDetail default commands.
 */
declare function createDetailCommands(handlers: {
    onNew?: () => void;
    onSave?: () => void;
    onDelete?: () => void;
    onCancel?: () => void;
}, labels?: PortalLabels): BladeCommand[];

/**
 * Notification panel — right-side overlay panel.
 * Ported from apa-notification-area in home.html (v0.2.346).
 *
 * Usage:
 * ```html
 * <apa-notification-panel>
 *   <!-- Custom notification content -->
 * </apa-notification-panel>
 * ```
 */
declare class NotificationPanelComponent {
    protected readonly portal: PortalService;
    private wasVisible;
    constructor();
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationPanelComponent, "apa-notification-panel", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Avatar menu — user account dropdown in the portal header.
 * Ported from fxs-avatarmenu CSS structure in v0.2.346.
 *
 * Shows the user's name and email. Clicking toggles a dropdown
 * with optional actions (sign out, etc.).
 *
 * Usage:
 * ```html
 * <apa-avatar-menu>
 *   <a href="/Account/SignOut">Abmelden</a>
 * </apa-avatar-menu>
 * ```
 */
declare class AvatarMenuComponent {
    protected readonly portal: PortalService;
    protected userAccount(): _ardimedia_angular_portal_azure.UserAccount;
    protected displayName(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarMenuComponent, "apa-avatar-menu", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Sidebar navigation — optional vertical navigation panel.
 * New in v0.3.0 (no equivalent in v0.2.346).
 *
 * Provides a collapsible sidebar with navigation items that
 * open blades when clicked.
 *
 * Usage:
 * ```html
 * <apa-sidebar [items]="sidebarItems" [collapsed]="false" />
 * <apa-sidebar [items]="sidebarItems" [width]="240" [collapsedWidth]="60" />
 * ```
 */
declare class SidebarComponent {
    readonly items: i0.InputSignal<BladeNavItem[]>;
    readonly collapsed: i0.InputSignal<boolean>;
    readonly width: i0.InputSignal<number>;
    readonly collapsedWidth: i0.InputSignal<number>;
    private readonly bladeService;
    visibleItems(): BladeNavItem[];
    onItemClick(item: BladeNavItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "apa-sidebar", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "collapsedWidth": { "alias": "collapsedWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { AvatarMenuComponent, BLADE_ROUTER_CONFIG, BladeComponent, BladeDetailComponent, BladeGridComponent, BladeHostComponent, BladeNavComponent, BladeRegistry, BladeRouterService, BladeService, CommandBarComponent, DEFAULT_LABELS, LABELS_DE_CH, LABELS_DE_DE, LABELS_EN, LABELS_ES, LABELS_FR, LABELS_IT, LANGUAGE_PRESETS, NotificationPanelComponent, PanoramaComponent, PortalLayoutComponent, PortalService, SidebarComponent, TILE_DIMENSIONS, TileComponent, TileSize, clearStatusBar, createAvatarMenu, createBlade, createCommand, createDataBlade, createDetailCommands, createNavItem, createNotificationPanel, createPanorama, createTile, executeDeleteItem, executeLoadItem, executeLoadItems, executeSaveItem, filterItems, getUserDisplayName, layoutTiles, nextBladeUid, provideBladeRouter, providePortalAzure, registerLanguagePreset, statusBarError, statusBarInfo, statusBarSuccess };
export type { AddBladeEventArgs, ApiException, AvatarMenuDefinition, AvatarMenuItem, BladeCommand, BladeDataDefinition, BladeDataLifecycle, BladeDefinition, BladeNavItem, BladeParameter, BladeRegistryEntry, BladeRouterConfig, LanguagePreset, NotificationDefinition, NotificationLifecycle, PanoramaDefinition, PortalConfig, PortalLabels, PositionedTile, StandardCommandKey, StatusBarState, StatusBarStyle, TileDefinition, UserAccount };