import { TranslationContainerOptions } from './types';
import { TranslationModel } from './translation-model';
import { Localization } from './services';
import { PublicModelInterface } from '../../../core/types';
import { IKosDataModel, IKosIdentifiable, IKosModelContainer, IKosModelHolder, KosCreationContext, ReloadAware } from '../../../core';

export declare const MODEL_TYPE = "translation-container-model";
/**
 * TranslationContainer - Multi-namespace translation management with automatic locale switching.
 *
 * The TranslationContainer model serves as the central orchestrator for internationalization in KOS
 * applications. It manages multiple translation namespaces, handles global locale switching, and provides
 * namespace resolution with fallback chains. This container enables building sophisticated multi-language
 * interfaces that adapt automatically to user language preferences across all application features.
 *
 * ## Key Features
 * - **Multi-Namespace Management** - Organize translations by feature areas (dashboard, alerts, settings)
 * - **Global Locale Control** - Centralized locale switching affects all contained translation models
 * - **Automatic Discovery** - Dynamic namespace loading and registration as features request translations
 * - **Fallback Resolution** - Sophisticated locale fallback chains for graceful degradation
 * - **Custom Resolvers** - Flexible translation loading strategies for different deployment scenarios
 * - **Reload Capability** - Dynamic translation updates without application restart
 * - **Default Namespace** - Optional primary namespace for application-wide common translations
 *
 * ## Namespace Organization
 * Translation namespaces organize translations by functional areas:
 * - **Feature-Based**: dashboard, device-config, maintenance, alerts
 * - **Component-Based**: forms, modals, navigation, status-displays
 * - **Common**: common, shared, ui-elements for cross-cutting concerns
 *
 * ## Locale Management Architecture
 * The container manages locale switching across all child translation models:
 * 1. **Centralized Control**: Single point for locale changes
 * 2. **Automatic Propagation**: All child models receive locale updates
 * 3. **Reactive Loading**: Translation files loaded automatically on locale switch
 * 4. **Fallback Coordination**: Container coordinates fallback chains across namespaces
 *
 * ## Common Use Cases
 * - **Application Initialization** - Bootstrap internationalization system with locale descriptors
 * - **User Language Switching** - Provide language selector that updates entire application
 * - **Feature Translation Loading** - Dynamic namespace registration as features are accessed
 * - **Multi-Tenant Systems** - Different translation sets for different deployments
 * - **Development Workflows** - Hot-reload translations during development
 * - **Global Device Interfaces** - Centralized management for device control applications
 *
 * @example Basic Usage
 * ```typescript
 * const translationContainer = TranslationContainer.instance('app-translations')
 *   .options({
 *     lang: 'es',
 *     defaultNamespace: 'common',
 *     descriptor: {
 *       namespaces: {
 *         'common': {
 *           basePath: '/assets/locales',
 *           locales: {
 *             'en': { file: 'en/common.json', defaultLocale: 'en' },
 *             'es': { file: 'es/common.json', defaultLocale: 'en' }
 *           }
 *         }
 *       }
 *     }
 *   })
 *   .build();
 *
 * // Access translations and switch language
 * const commonTranslations = translationContainer.getModel('common');
 * translationContainer.currentLocale = 'fr';
 * ```
 *
 * @group KOS Model
 * @category i18n
 * @interface
 * @useDeclaredType
 *
 * @see {@link TranslationContainerOptions} - Configuration options for TranslationContainer instances
 * @see {@link TranslationModel} - Individual translation namespace model
 * @see {@link useKosTranslation} - React hook for accessing container translations
 * @see {@link useKosTranslationContext} - React hook for container-level operations
 */
export type TranslationContainerModel = PublicModelInterface<TranslationContainerModelImpl>;
/**
 * @ignore
 * @internal
 */
export declare class TranslationContainerModelImpl implements IKosIdentifiable, IKosModelHolder<TranslationModel>, IKosDataModel, ReloadAware {
    /** Unique identifier for the container model instance */
    id: string;
    /** Currently active locale for all managed translation namespaces */
    lang: string;
    /** Base URL for loading translation resources */
    private rootUrl?;
    /** Localization descriptor defining namespace configuration and locale mappings */
    descriptor: Localization;
    /** Optional default namespace identifier for primary application translations */
    private _defaultNamespace?;
    /** Path resolver function for constructing translation file URLs */
    private resolver;
    /** Context logger for debugging translation operations */
    private logger;
    /** URL for dynamically loading localization descriptors */
    private descriptorUrl?;
    /** Array tracking registered namespace identifiers */
    private namespaces;
    /** Container for managing Translation model instances */
    private _models;
    constructor(modelId: string, options: TranslationContainerOptions, context: KosCreationContext);
    set currentLocale(locale: string);
    get defaultNamespace(): TranslationModel | undefined;
    getModel(id: string): TranslationModel | undefined;
    get models(): IKosModelContainer<TranslationModel>;
    get data(): TranslationModel[];
    reload(): Promise<void>;
    resolveNamespace(namespace: string): TranslationModel;
    addModel(model: TranslationModel): void;
    removeModel(id: string): void;
    /**
     * @internal
     */
    init(): Promise<void>;
    /**
     * @internal
     */
    load(): Promise<void>;
}
//# sourceMappingURL=translation-container-model.d.ts.map