@fgv/ts-res 5.0.0-9 → 5.0.1-1

package/dist/ts-res.d.ts

@@ -1,19 +1,23 @@
 import { Brand } from '@fgv/ts-utils';
 import { Collections } from '@fgv/ts-utils';
 import { Converter } from '@fgv/ts-utils';
+import { Converters } from '@fgv/ts-json-base';
 import { DetailedResult } from '@fgv/ts-utils';
-import { FileTree } from '@fgv/ts-utils';
+import { FileTree } from '@fgv/ts-json-base';
 import { Hash } from '@fgv/ts-utils';
 import { ICollectible } from '@fgv/ts-utils';
 import { IReadOnlyResultMap } from '@fgv/ts-utils';
+import { JsonCompatible } from '@fgv/ts-json-base';
 import { JsonObject } from '@fgv/ts-json-base';
 import { JsonValue } from '@fgv/ts-json-base';
+import { Logging } from '@fgv/ts-utils';
 import { ObjectConverter } from '@fgv/ts-utils';
 import { Result } from '@fgv/ts-utils';
 import { ResultMap } from '@fgv/ts-utils';
 import { ValidatingCollector } from '@fgv/ts-utils';
 import { ValidatingConvertingCollector } from '@fgv/ts-utils';
 import { ValidatingResultMap } from '@fgv/ts-utils';
+import { Validator } from '@fgv/ts-utils';
 
 /**
  * An abstract decision represents a class of decisions with candidates
@@ -131,6 +135,63 @@ declare const allPredefinedSystemConfigurations: ReadonlyArray<PredefinedSystemC
  */
 export declare const allResourceValueMergeMethods: ResourceValueMergeMethod[];
 
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IAnyQualifierTypeConfig | AnyQualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IAnyQualifierTypeConfig | AnyQualifierTypeConfig} objects.
+ * @public
+ */
+declare const anyQualifierTypeConfig: Converter<Model_2.IAnyQualifierTypeConfig, unknown>;
+
+/**
+ * Base implementation class containing shared validation logic for both read-only and mutable validators.
+ * @internal
+ */
+declare abstract class BaseContextQualifierProviderValidator<T extends IContextQualifierProvider = IContextQualifierProvider> implements IContextQualifierProviderValidatorBase<T> {
+    /**
+     * The wrapped context qualifier provider.
+     */
+    abstract readonly provider: T;
+    /**
+     * The readonly qualifier collector that defines and validates the qualifiers for this context.
+     */
+    get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * Gets a qualifier value by its string name, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    get(name: string): Result<QualifierContextValue>;
+    /**
+     * Gets a qualifier value by its number index, converting to strongly-typed QualifierIndex.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    getByIndex(index: number): Result<QualifierContextValue>;
+    /**
+     * Gets a validated qualifier context value by its string name.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidated(name: string): Result<QualifierContextValue>;
+    /**
+     * Gets a validated qualifier context value by its number index.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidatedByIndex(index: number): Result<QualifierContextValue>;
+    /**
+     * Checks if a qualifier value exists with the given string name.
+     * @param name - The string name to convert and check.
+     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
+     * or `Failure` with an error message if an error occurs during the check.
+     */
+    has(name: string): Result<boolean>;
+}
+
 /**
  * Converts an array of {@link Helpers.IConditionTokenParts | condition token parts} into an array of
  * syntactically validated {@link ConditionToken | condition tokens}.
@@ -179,6 +240,27 @@ declare function buildQualifierDefaultValuesToken(parts: ReadonlyArray<IQualifie
  */
 declare function buildQualifierDefaultValueToken({ qualifier, value }: IQualifierDefaultValueTokenParts): Result<QualifierDefaultValueToken>;
 
+/**
+ * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
+ * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
+ * if successful, `Failure` with an error message otherwise.
+ * @public
+ */
+declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.ISystemQualifierTypeConfig, SystemQualifierType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType>;
+}
+
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
+ * @public
+ */
+declare class BuiltInResourceTypeFactory implements IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: ResourceTypes.Config.IResourceTypeConfig): Result<ResourceType>;
+}
+
 declare namespace Bundle {
     export {
         IBundleMetadata,
@@ -190,6 +272,7 @@ declare namespace Bundle {
         IBundleLoaderCreateParams,
         BundleUtils,
         IBundleComponents,
+        Model_4 as Model,
         Convert_10 as Convert,
         BundleNormalizer
     }
@@ -557,6 +640,139 @@ declare class CandidateReducer {
     reduceCandidate(candidate: ResourceCandidate): Result<IReducedCandidate | undefined>;
 }
 
+/**
+ * Implementation of a candidate value that stores normalized JSON data.
+ * The value is normalized on creation and a hash-based key is generated
+ * for efficient deduplication.
+ * @public
+ */
+declare class CandidateValue implements ICandidateValue {
+    private readonly _collectible;
+    private readonly _json;
+    /**
+     * The unique key for this candidate value.
+     */
+    get key(): CandidateValueKey;
+    /**
+     * The index of this candidate value in the collection.
+     */
+    get index(): CandidateValueIndex | undefined;
+    /**
+     * The normalized JSON value.
+     */
+    get json(): JsonValue;
+    /**
+     * Constructor for a {@link Resources.CandidateValue} object.
+     * @param params - Parameters to create the candidate value.
+     * @internal
+     */
+    protected constructor(params: ICandidateValueCreateParams);
+    /**
+     * Creates a new {@link Resources.CandidateValue} object.
+     * @param params - Parameters to create the candidate value.
+     * @returns `Success` with the new candidate value if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: ICandidateValueCreateParams): Result<CandidateValue>;
+    /**
+     * Sets the index of this candidate value.
+     * @param index - The index to set.
+     * @returns `Success` with the index if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    setIndex(index: number): Result<CandidateValueIndex>;
+}
+
+/**
+ * A `ValidatingCollector` for {@link Resources.CandidateValue | CandidateValues},
+ * which collects candidate values supplied as either {@link Resources.CandidateValue | CandidateValue} or
+ * `JsonValue`.
+ * @public
+ */
+declare class CandidateValueCollector extends ValidatingCollector<CandidateValue> {
+    readonly normalizer: Hash.HashingNormalizer;
+    /**
+     * Constructor for a {@link Resources.CandidateValueCollector} object.
+     * @param params - Parameters to create the collector.
+     * @internal
+     */
+    protected constructor(params?: ICandidateValueCollectorCreateParams);
+    /**
+     * Creates a new {@link Resources.CandidateValueCollector} object.
+     * @param params - Parameters to create the collector.
+     * @returns `Success` with the new collector if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params?: ICandidateValueCollectorCreateParams): Result<CandidateValueCollector>;
+    /**
+     * Returns an array of JSON values ordered by their indices.
+     * @returns Array of JsonValue objects in index order.
+     * @public
+     */
+    getValuesByIndex(): JsonValue[];
+    /**
+     * Converter method to handle CandidateValue | JsonValue.
+     * @param from - The value to convert.
+     * @returns `Success` with the CandidateValue if successful, or `Failure` with an error message if not.
+     * @internal
+     */
+    private _toCandidateValue;
+}
+
+/**
+ * Branded number representing a validated candidate value index.
+ * Candidate value indices are used to identify candidate values
+ * within a resource set and to enable sharing of like values.
+ * @public
+ */
+export declare type CandidateValueIndex = Brand<number, 'CandidateValueIndex'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link CandidateValueIndex | CandidateValueIndex}.
+ * @public
+ */
+declare const candidateValueIndex: Converter<CandidateValueIndex, unknown>;
+
+/**
+ * Branded string representing a validated candidate value key.
+ * Candidate value keys are used to identify candidate values
+ * within a resource set and to enable sharing of like values.
+ * @public
+ */
+export declare type CandidateValueKey = Brand<string, 'CandidateValueKey'>;
+
+/**
+ * `Converter` which validates an `unknown` value as a {@link CandidateValueKey | CandidateValueKey}.
+ * @public
+ */
+declare const candidateValueKey: Converter<CandidateValueKey, unknown>;
+
+/**
+ * @internal
+ */
+declare const candidateValueKey_2: RegExp;
+
+/**
+ * A factory that chains multiple factories together.
+ * @public
+ */
+declare class ChainedConfigInitFactory<TConfig, T> implements IConfigInitFactory<TConfig, T> {
+    readonly factories: IConfigInitFactory<TConfig, T>[];
+    /**
+     * Constructor for a chained config init factory.
+     * @param factories - The factories to chain.
+     */
+    constructor(factories: IConfigInitFactory<TConfig, T>[]);
+    /**
+     * Creates a new instance of a configuration object.
+     * @param config - The configuration object to create.
+     * @returns A result containing the new instance of the configuration object.
+     */
+    create(config: TConfig): Result<T>;
+}
+
 /**
  * `Converter` for a normalized {@link ResourceJson.Json.IChildConditionDecl | child condition declaration}.
  * @public
@@ -668,7 +884,10 @@ declare namespace Common {
         ResourceTypeIndex,
         ResourceValueMergeMethod,
         allResourceValueMergeMethods,
-        CandidateCompleteness
+        CandidateCompleteness,
+        CandidateValueIndex,
+        CandidateValueKey,
+        IResourceResolver
     }
 }
 
@@ -757,30 +976,39 @@ declare const compiledResource: ObjectConverter<Model_3.ICompiledResource, unkno
  * and use pre-compiled resource collections without rebuilding them from scratch.
  * @public
  */
-declare class CompiledResourceCollection implements IResourceManager {
+declare class CompiledResourceCollection implements IResourceManager<IResource> {
     readonly conditions: ReadOnlyConditionCollector;
     readonly conditionSets: ReadOnlyConditionSetCollector;
     readonly decisions: ReadOnlyAbstractDecisionCollector;
     private readonly _qualifierTypes;
     private readonly _qualifiers;
     private readonly _resourceTypes;
+    private readonly _candidateValues;
     private readonly _builtResources;
     private _cachedResourceTree?;
     /**
-     * A {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} which
+     * A {@link QualifierTypes.ReadOnlyQualifierTypeCollector | ReadOnlyQualifierTypeCollector} which
      * contains the {@link QualifierTypes.QualifierType | qualifier types} used in this collection.
      */
-    get qualifierTypes(): QualifierTypeCollector;
+    get qualifierTypes(): ReadOnlyQualifierTypeCollector;
     /**
-     * A {@link Qualifiers.QualifierCollector | QualifierCollector} which
+     * A {@link Qualifiers.IReadOnlyQualifierCollector | ReadOnlyQualifierCollector} which
      * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
      */
-    get qualifiers(): QualifierCollector;
+    get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs contained in this compiled resource collection.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
      * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.
      */
-    get resourceTypes(): ResourceTypeCollector;
+    get resourceTypes(): ReadOnlyResourceTypeCollector;
+    /**
+     * The candidate values in the collection.
+     */
+    get candidateValues(): ReadonlyArray<JsonValue>;
     /**
      * {@inheritdoc Runtime.IResourceManager.builtResources}
      */
@@ -829,7 +1057,7 @@ declare class CompiledResourceCollection implements IResourceManager {
      * @returns Result containing the resource tree root, or failure if tree construction fails
      * @public
      */
-    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<IResource>>;
+    getBuiltResourceTree(): Result<ReadOnlyResourceTreeRoot<IResource>>;
     /**
      * Reconstructs a QualifierTypeCollector from compiled data.
      * @param compiled - The compiled resource collection
@@ -878,6 +1106,12 @@ declare class CompiledResourceCollection implements IResourceManager {
      * @internal
      */
     private _buildDecisions;
+    /**
+     * Gets a candidate value from the collection.
+     * @param valueIndex - The index of the candidate value to get.
+     * @returns
+     */
+    private _getCandidateValue;
     /**
      * Reconstructs a ValidatingResultMap of resources from compiled data.
      * @param compiled - The compiled resource collection
@@ -1292,6 +1526,14 @@ export declare class ConditionSet implements IValidatedConditionSetDecl {
      * @public
      */
     static getKeyForDecl(decl: IValidatedConditionSetDecl): Result<ConditionSetKey>;
+    /**
+     * Gets a condition set key from a loose condition set declaration.
+     * @param conditionSet - The loose condition set declaration to convert.
+     * @param conditionCollector - The condition collector used for validation.
+     * @returns `Success` with the condition set key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyFromLooseDecl(conditionSet: ResourceJson.Json.ConditionSetDecl | undefined, conditionCollector: ConditionCollector): Result<ConditionSetKey>;
     /**
      * Gets a {@link ConditionSetToken | condition set token} for this condition set,
      * if possible.
@@ -1641,6 +1883,18 @@ declare namespace Config {
     export {
         Model,
         Convert_9 as Convert,
+        createQualifierTypeFactory,
+        createResourceTypeFactory,
+        QualifierTypeFactoryFunction,
+        ResourceTypeFactoryFunction,
+        IConfigInitFactory,
+        ChainedConfigInitFactory,
+        BuiltInQualifierTypeFactory,
+        QualifierTypeFactory,
+        ValidatingQualifierTypeFactory,
+        BuiltInResourceTypeFactory,
+        ResourceTypeFactory,
+        ValidatingResourceTypeFactory,
         updateSystemConfigurationQualifierDefaultValues,
         ISystemConfigurationInitParams,
         SystemConfiguration,
@@ -1657,14 +1911,17 @@ export { Config }
 declare namespace Config_2 {
     export {
         Convert_2 as Convert,
+        isSystemQualifierTypeConfig,
         IQualifierTypeConfig,
         ILanguageQualifierTypeConfig,
+        LiteralValueHierarchyDecl,
         ITerritoryQualifierTypeConfig,
         ILiteralQualifierTypeConfig,
         ISystemLanguageQualifierTypeConfig,
         ISystemTerritoryQualifierTypeConfig,
         ISystemLiteralQualifierTypeConfig,
-        ISystemQualifierTypeConfig
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
     }
 }
 
@@ -1683,7 +1940,7 @@ declare const containerContextDecl: Converter<Normalized.IContainerContextDecl>;
 
 declare namespace Context {
     export {
-        Convert_7 as Convert,
+        Convert_8 as Convert,
         IContextMatchOptions,
         IContextQualifierValueDecl,
         IContextDecl,
@@ -1696,11 +1953,19 @@ export { Context }
 
 declare namespace Context_2 {
     export {
+        IContextQualifierProviderBase,
+        IReadOnlyContextQualifierProvider,
+        IMutableContextQualifierProvider,
         IContextQualifierProvider,
         ContextQualifierProvider,
+        IContextQualifierProviderValidatorBase,
         IReadOnlyContextQualifierProviderValidator,
+        IMutableContextQualifierProviderValidator,
+        IReadOnlyContextQualifierProviderValidatorCreateParams,
+        IMutableContextQualifierProviderValidatorCreateParams,
         IContextQualifierProviderValidatorCreateParams,
-        ContextQualifierProviderValidator,
+        ReadOnlyContextQualifierProviderValidator,
+        MutableContextQualifierProviderValidator,
         ISimpleContextQualifierProviderCreateParams,
         SimpleContextQualifierProvider,
         IValidatingSimpleContextQualifierProviderCreateParams,
@@ -1719,7 +1984,7 @@ declare const contextDecl: Converter<Record<string, string>, unknown>;
  * Provides common functionality and enforces the contract for derived classes.
  * @public
  */
-declare abstract class ContextQualifierProvider implements IContextQualifierProvider {
+declare abstract class ContextQualifierProvider implements IContextQualifierProviderBase {
     /**
      * The readonly qualifier collector that defines and validates the qualifiers for this context.
      */
@@ -1753,96 +2018,6 @@ declare abstract class ContextQualifierProvider implements IContextQualifierProv
     abstract getNames(): Result<ReadonlyArray<QualifierName>>;
 }
 
-/**
- * A wrapper for {@link Runtime.Context.IContextQualifierProvider | IContextQualifierProvider} that accepts
- * string inputs and converts them to strongly-typed values before calling the wrapped provider.
- * This eliminates the need for type casting in consumer code while maintaining type safety.
- * @public
- */
-declare class ContextQualifierProviderValidator implements IReadOnlyContextQualifierProviderValidator {
-    /**
-     * The wrapped context qualifier provider.
-     */
-    readonly provider: IContextQualifierProvider;
-    /**
-     * The readonly qualifier collector that defines and validates the qualifiers for this context.
-     */
-    get qualifiers(): IReadOnlyQualifierCollector;
-    /**
-     * Constructs a new {@link Runtime.Context.ContextQualifierProviderValidator | ContextQualifierProviderValidator}.
-     * @param params - Required parameters for constructing the validator.
-     */
-    constructor(params: IContextQualifierProviderValidatorCreateParams);
-    /**
-     * Gets a qualifier value by its string name, converting to strongly-typed QualifierName.
-     * @param name - The string name to convert and look up.
-     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found or an error occurs.
-     */
-    get(name: string): Result<QualifierContextValue>;
-    /**
-     * Gets a qualifier value by its number index, converting to strongly-typed QualifierIndex.
-     * @param index - The number index to convert and look up.
-     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found or an error occurs.
-     */
-    getByIndex(index: number): Result<QualifierContextValue>;
-    /**
-     * Gets a validated qualifier context value by its string name.
-     * @param name - The string name to convert and look up.
-     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found, invalid, or an error occurs.
-     */
-    getValidated(name: string): Result<QualifierContextValue>;
-    /**
-     * Gets a validated qualifier context value by its number index.
-     * @param index - The number index to convert and look up.
-     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found, invalid, or an error occurs.
-     */
-    getValidatedByIndex(index: number): Result<QualifierContextValue>;
-    /**
-     * Checks if a qualifier value exists with the given string name.
-     * @param name - The string name to convert and check.
-     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
-     * or `Failure` with an error message if an error occurs during the check.
-     */
-    has(name: string): Result<boolean>;
-    /**
-     * Sets a qualifier value using string inputs, converting to strongly-typed values.
-     * @param name - The string name to convert.
-     * @param value - The string value to convert.
-     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
-     * or `Failure` with an error message if an error occurs.
-     */
-    set(name: string, value: string): Result<QualifierContextValue>;
-    /**
-     * Removes a qualifier value using string input, converting to strongly-typed QualifierName.
-     * @param name - The string name to convert.
-     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
-     * or `Failure` with an error message if an error occurs.
-     */
-    remove(name: string): Result<QualifierContextValue>;
-    /**
-     * Validates a string as a QualifierName.
-     * @param name - The string to validate.
-     * @returns `Success` with the strongly-typed QualifierName, or `Failure` if invalid.
-     */
-    private _validateQualifierName;
-    /**
-     * Validates a number as a QualifierIndex.
-     * @param index - The number to validate.
-     * @returns `Success` with the strongly-typed QualifierIndex, or `Failure` if invalid.
-     */
-    private _validateQualifierIndex;
-    /**
-     * Validates a string as a QualifierContextValue.
-     * @param value - The string to validate.
-     * @returns `Success` with the strongly-typed QualifierContextValue, or `Failure` if invalid.
-     */
-    private _validateQualifierContextValue;
-}
-
 /**
  * A string representing a validated context qualifier token. Context qualifier tokens are used
  * for filtering resources by context criteria. A context qualifier token has the form
@@ -1998,6 +2173,7 @@ declare namespace Convert {
         qualifierIndex,
         qualifierTypeName,
         qualifierTypeIndex,
+        qualifierContextValue,
         qualifierMatchScore,
         conditionPriority,
         conditionOperator,
@@ -2015,6 +2191,8 @@ declare namespace Convert {
         resourceIndex,
         resourceTypeName,
         resourceTypeIndex,
+        candidateValueKey,
+        candidateValueIndex,
         resourceValueMergeMethod,
         contextQualifierToken,
         contextToken,
@@ -2024,7 +2202,7 @@ declare namespace Convert {
 }
 export { Convert }
 
-export declare namespace Convert_10 {
+declare namespace Convert_10 {
     export {
         bundleMetadata,
         bundleExportMetadata,
@@ -2045,15 +2223,32 @@ declare namespace Convert_11 {
     }
 }
 
+declare namespace Convert_12 {
+    export {
+        zipArchiveInputType,
+        zipArchiveConfigType,
+        zipArchiveInputInfo,
+        zipArchiveConfigInfo,
+        zipArchiveManifest,
+        mimeType,
+        importedFile,
+        importedDirectory,
+        systemConfiguration_2 as systemConfiguration
+    }
+}
+
 declare namespace Convert_2 {
     export {
+        qualifierTypeConfig,
         languageQualifierTypeConfig,
         territoryQualifierTypeConfig,
         literalQualifierTypeConfig,
         systemLanguageQualifierTypeConfig,
         systemTerritoryQualifierTypeConfig,
         systemLiteralQualifierTypeConfig,
-        systemQualifierTypeConfig
+        systemQualifierTypeConfig,
+        jsonQualifierTypeConfig,
+        anyQualifierTypeConfig
     }
 }
 
@@ -2099,16 +2294,6 @@ declare namespace Convert_6 {
 }
 
 declare namespace Convert_7 {
-    export {
-        contextQualifierValueDecl,
-        contextDecl,
-        IContextDeclConvertContext,
-        validatedContextQualifierValueDecl,
-        validatedContextDecl
-    }
-}
-
-declare namespace Convert_8 {
     export {
         looseConditionDecl,
         childConditionDecl,
@@ -2126,13 +2311,32 @@ declare namespace Convert_8 {
     }
 }
 
+declare namespace Convert_8 {
+    export {
+        contextQualifierValueDecl,
+        contextDecl,
+        IContextDeclConvertContext,
+        validatedContextQualifierValueDecl,
+        validatedContextDecl
+    }
+}
+
 declare namespace Convert_9 {
     export {
+        validateSystemConfiguration,
         systemConfiguration,
         predefinedSystemConfiguration
     }
 }
 
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createQualifierTypeFactory<T extends QualifierType = QualifierType>(fn: QualifierTypeFactoryFunction<T>): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>;
+
 /**
  * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
@@ -2143,19 +2347,27 @@ declare namespace Convert_9 {
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-declare function createQualifierTypeFromConfig(typeConfig: Config_2.IQualifierTypeConfig<JsonObject>): Result<QualifierType>;
+declare function createQualifierTypeFromConfig(typeConfig: Config_2.IAnyQualifierTypeConfig): Result<QualifierType>;
 
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISystemQualifierTypeConfig): Result<QualifierType>;
+declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISystemQualifierTypeConfig): Result<SystemQualifierType>;
+
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createResourceTypeFactory(fn: ResourceTypeFactoryFunction): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 
 /**
  * Creates a {@link ResourceTypes.ResourceType | ResourceType} from a configuration object.
@@ -2167,6 +2379,17 @@ declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISyste
  */
 declare function createResourceTypeFromConfig(config: IResourceTypeConfig): Result<ResourceType>;
 
+/**
+ * Create a ZIP archive manifest object
+ * @param inputType - Type of input (file or directory)
+ * @param originalPath - Original file/directory path
+ * @param archivePath - Path within the archive
+ * @param configPath - Optional configuration file path
+ * @returns ZIP archive manifest
+ * @public
+ */
+declare function createZipArchiveManifest(inputType: 'file' | 'directory', originalPath: string, archivePath: string, configPath?: string): Json_2.IZipArchiveManifest;
+
 /**
  * Simple collectible implementation of {@link Decisions.IDecision | IDecision}.
  * @public
@@ -2334,8 +2557,163 @@ declare const DefaultResourceTypes: ReadonlyArray<ResourceTypes.Config.IResource
  */
 declare const DefaultSystemConfiguration: ISystemConfiguration;
 
-declare namespace Example {
-    export {
+/**
+ * Class for generating resource deltas between baseline and delta resolvers.
+ * Creates partial/augment candidates for updated resources and full/replace candidates for new resources.
+ * Uses Diff.jsonThreeWayDiff for efficient delta computation.
+ * @public
+ */
+declare class DeltaGenerator {
+    /**
+     * The baseline resource resolver to compare against.
+     * @internal
+     */
+    private readonly _baselineResolver;
+    /**
+     * The delta resource resolver containing changes.
+     * @internal
+     */
+    private readonly _deltaResolver;
+    /**
+     * The resource manager to clone and update.
+     * @internal
+     */
+    private readonly _resourceManager;
+    /**
+     * Logger for status and error reporting.
+     * @internal
+     */
+    private readonly _logger;
+    /**
+     * Constructor for a {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @internal
+     */
+    protected constructor(params: IDeltaGeneratorParams);
+    /**
+     * Creates a new {@link Resources.DeltaGenerator | DeltaGenerator} object.
+     * @param params - Parameters to create a new {@link Resources.DeltaGenerator | DeltaGenerator}.
+     * @returns `Success` with the new {@link Resources.DeltaGenerator | DeltaGenerator} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params: IDeltaGeneratorParams): Result<DeltaGenerator>;
+    /**
+     * Generates deltas between baseline and delta resolvers.
+     * Creates a cloned resource manager with partial/augment candidates for updates
+     * and full/replace candidates for new resources.
+     *
+     * @param options - Options controlling delta generation behavior.
+     * @returns `Success` with the updated resource manager if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    generate(options?: IDeltaGeneratorOptions): Result<ResourceManagerBuilder>;
+    /**
+     * Validates the provided context declaration.
+     * @param context - The context declaration to validate.
+     * @returns `Success` with the validated context if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _validateContext;
+    /**
+     * Enumerates target resource IDs for delta generation.
+     * If specific resource IDs are provided, uses those. Otherwise, discovers all resources
+     * from both the baseline resource manager and the delta resolver to ensure comprehensive
+     * coverage of all potential resources.
+     *
+     * @param requestedIds - Optional array of specific resource IDs to target.
+     * @param context - The validated context to use for resource discovery.
+     * @returns `Success` with array of resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _enumerateTargetResources;
+    /**
+     * Discovers all unique resource IDs from both baseline and delta resolvers.
+     * Creates a union of resource IDs from the baseline resource manager and delta resolver
+     * to ensure comprehensive coverage of all resources.
+     *
+     * @returns `Success` with array of unique resource IDs if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _discoverAllResourceIds;
+    /**
+     * Creates a clone of the resource manager for delta operations.
+     * @returns `Success` with the cloned resource manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _cloneResourceManager;
+    /**
+     * Generates deltas for the specified resources and adds them to the cloned manager.
+     *
+     * @param clonedManager - The cloned resource manager to update.
+     * @param resourceIds - Array of resource IDs to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the updated manager if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateDeltas;
+    /**
+     * Generates a delta for a single resource and adds appropriate candidates to the manager.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID to process.
+     * @param context - The context to use for resource resolution.
+     * @param skipUnchanged - Whether to skip resources that haven't changed.
+     * @returns `Success` with the resource delta result if successful, `Failure` otherwise.
+     * @internal
+     */
+    private _generateResourceDelta;
+    /**
+     * Checks if two JSON values are identical.
+     * @param value1 - First value to compare.
+     * @param value2 - Second value to compare.
+     * @returns True if values are identical, false otherwise.
+     * @internal
+     */
+    private _areValuesIdentical;
+    /**
+     * Creates a new resource candidate for a newly discovered resource.
+     * Uses full/replace merge method since this is a completely new resource.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the new resource.
+     * @param value - The resolved value for the new resource.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createNewResourceCandidate;
+    /**
+     * Creates a delta candidate for an updated resource.
+     * Computes the difference between baseline and delta values and creates
+     * a partial/augment candidate with only the changed properties.
+     *
+     * @param manager - The resource manager to update.
+     * @param resourceId - The resource ID for the updated resource.
+     * @param baselineValue - The baseline resolved value.
+     * @param deltaValue - The delta resolved value.
+     * @param context - The context used for resolution.
+     * @returns `Success` if the candidate was added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private _createDeltaCandidate;
+}
+
+/**
+ * Type for handling empty branch nodes during tree composition.
+ * The handler receives the branch node, names of failed children, and the resolver for recovery attempts.
+ * It can return:
+ * - Success(undefined) to omit the branch from the result
+ * - Success(value) to use an alternate value for the branch
+ * - Failure to propagate the error
+ * @public
+ */
+declare type EmptyBranchHandler = (branchNode: IReadOnlyResourceTreeNode<IResource>, failedChildNames: string[], resolver: ResourceResolver) => Result<JsonValue | undefined>;
+
+declare namespace Example {
+    export {
         ExtendedQualifierTypes,
         ExtendedQualifiers,
         ExtendedResourceTypes,
@@ -2479,6 +2857,30 @@ declare class FsItemImporter implements IImporter {
  */
 declare type FsItemResultDetail = 'failed' | 'skipped' | 'succeeded';
 
+/**
+ * Generate a timestamp-based filename for ZIP archives
+ * @param customName - Optional custom name prefix
+ * @returns Generated filename
+ * @public
+ */
+declare function generateZipArchiveFilename(customName?: string): string;
+
+/**
+ * Extract directory name from a file path
+ * @param path - File path
+ * @returns Directory name
+ * @public
+ */
+declare function getDirectoryName(path: string): string;
+
+/**
+ * Gets the name for a resource ID.
+ * @param id - The resource ID to get the name for.
+ * @returns The resource name if found, or undefined if not.
+ * @public
+ */
+declare function getNameForResourceId(id: string | undefined): Result<ResourceName>;
+
 /**
  * Returns the {@link Config.Model.ISystemConfiguration | system configuration} declaration for the
  * specified predefined system configuration.
@@ -2520,7 +2922,8 @@ declare namespace Helpers {
         IQualifierDefaultValueTokenParts,
         splitResourceId,
         joinResourceIds,
-        joinOptionalResourceIds
+        joinOptionalResourceIds,
+        getNameForResourceId
     }
 }
 export { Helpers }
@@ -2559,6 +2962,12 @@ declare interface IAbstractDecisionCreateParams {
     index?: number;
 }
 
+/**
+ * A union of all qualifier type configurations.
+ * @public
+ */
+declare type IAnyQualifierTypeConfig = IQualifierTypeConfig | ISystemQualifierTypeConfig;
+
 /**
  * A complete resource bundle that encapsulates built resources, configuration, and metadata.
  * Bundles provide a portable, integrity-verified way to distribute pre-compiled resource collections.
@@ -2757,6 +3166,69 @@ declare interface ICandidateInfo {
     readonly json?: JsonObject;
 }
 
+/**
+ * Interface for a candidate value that can be collected and indexed.
+ * Candidate values are normalized JSON values that can be shared across
+ * multiple resource candidates to reduce duplication.
+ * @public
+ */
+declare interface ICandidateValue extends Collections.ICollectible<CandidateValueKey, CandidateValueIndex> {
+    /**
+     * The unique key for this candidate value, derived from the hash of the normalized JSON.
+     */
+    readonly key: CandidateValueKey;
+    /**
+     * The index of this candidate value in the collection.
+     */
+    readonly index: CandidateValueIndex | undefined;
+    /**
+     * The normalized JSON value.
+     */
+    readonly json: JsonValue;
+    /**
+     * Sets the index of this candidate value.
+     * @param index - The index to set.
+     * @returns `Success` with the index if successful, or `Failure` with an error message if not.
+     */
+    setIndex(index: number): Result<CandidateValueIndex>;
+}
+
+/**
+ * Parameters for creating a {@link Resources.CandidateValueCollector}.
+ * @public
+ */
+declare interface ICandidateValueCollectorCreateParams {
+    /**
+     * Optional normalizer to use for normalizing JSON values.
+     * If not provided, a default Crc32Normalizer will be used.
+     */
+    normalizer?: Hash.HashingNormalizer;
+    /**
+     * Optional initial candidate values to add to the collection.
+     */
+    candidateValues?: (CandidateValue | JsonValue)[];
+}
+
+/**
+ * Parameters for creating a {@link Resources.CandidateValue | CandidateValue}.
+ * @public
+ */
+declare interface ICandidateValueCreateParams {
+    /**
+     * The JSON value to store. Will be normalized during creation.
+     */
+    json: JsonValue;
+    /**
+     * Optional normalizer to use for normalizing the JSON value.
+     * If not provided, a default Crc32Normalizer will be used.
+     */
+    normalizer?: Hash.Crc32Normalizer;
+    /**
+     * Optional index if the value is already indexed.
+     */
+    index?: number;
+}
+
 /**
  * Non-validated child declaration of a {@link Conditions.Condition | condition}.
  * @public
@@ -2880,9 +3352,9 @@ declare interface ICompiledAbstractDecision {
  */
 declare interface ICompiledCandidate {
     /**
-     * The JSON value of the candidate.
+     * The global index of the JSON value of the candidate.
      */
-    json: JsonValue;
+    valueIndex: Common.CandidateValueIndex;
     /**
      * Indicates if this is a partial resource that needs to be merged.
      */
@@ -3055,6 +3527,10 @@ declare interface ICompiledResourceCollection {
      * Array of all decisions in the collection.
      */
     decisions: ReadonlyArray<ICompiledAbstractDecision>;
+    /**
+     * Array of all candidate values in the collection.
+     */
+    candidateValues: ReadonlyArray<JsonValue>;
     /**
      * Array of all resources in the collection.
      */
@@ -3246,6 +3722,19 @@ declare interface IConditionTokenParts {
     value: string;
 }
 
+/**
+ * Interface for a factory that creates a new instance of a configuration object.
+ * @public
+ */
+declare interface IConfigInitFactory<TConfig, T> {
+    /**
+     * Creates a new instance of a configuration object.
+     * @param config - The configuration object to create.
+     * @returns A result containing the new instance of the configuration object.
+     */
+    create(config: TConfig): Result<T>;
+}
+
 /**
  * Declared context for a resource container.
  * @public
@@ -3303,11 +3792,19 @@ declare interface IContextMatchOptions {
 }
 
 /**
- * Abstract interface for providing qualifier values in an optimized runtime context.
+ * Union type for context qualifier providers that can be either read-only or mutable.
+ * Provides compile-time type discrimination via the `mutable` property.
+ * @public
+ */
+declare type IContextQualifierProvider = IReadOnlyContextQualifierProvider | IMutableContextQualifierProvider;
+
+/**
+ * Base interface for providing qualifier values in an optimized runtime context.
+ * Contains common read-only operations shared by both mutable and immutable providers.
  * Acts as a property bag using the Result pattern for qualifier value lookups.
  * @public
  */
-declare interface IContextQualifierProvider {
+declare interface IContextQualifierProviderBase {
     /**
      * Gets a qualifier value by its name, index, or qualifier object.
      * @param nameOrIndexOrQualifier - The {@link QualifierName | qualifier name}, {@link QualifierIndex | index}, or {@link Qualifiers.Qualifier | qualifier object} to look up.
@@ -3342,13 +3839,62 @@ declare interface IContextQualifierProvider {
 }
 
 /**
- * Parameters for constructing a {@link Runtime.Context.ContextQualifierProviderValidator | ContextQualifierProviderValidator}.
+ * Base interface for shared operations between read-only and mutable context qualifier provider validators.
+ * Contains common methods that don't depend on provider mutability.
  * @public
  */
-declare interface IContextQualifierProviderValidatorCreateParams {
-    provider: IContextQualifierProvider;
+declare interface IContextQualifierProviderValidatorBase<T extends IContextQualifierProvider = IContextQualifierProvider> {
+    /**
+     * The wrapped context qualifier provider.
+     */
+    readonly provider: T;
+    /**
+     * The readonly qualifier collector that defines and validates the qualifiers for this context.
+     */
+    readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * Gets a qualifier value by its string name, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    get(name: string): Result<QualifierContextValue>;
+    /**
+     * Gets a qualifier value by its number index, converting to strongly-typed QualifierIndex.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    getByIndex(index: number): Result<QualifierContextValue>;
+    /**
+     * Gets a validated qualifier context value by its string name.
+     * @param name - The string name to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidated(name: string): Result<QualifierContextValue>;
+    /**
+     * Gets a validated qualifier context value by its number index.
+     * @param index - The number index to convert and look up.
+     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
+     * or `Failure` with an error message if not found, invalid, or an error occurs.
+     */
+    getValidatedByIndex(index: number): Result<QualifierContextValue>;
+    /**
+     * Checks if a qualifier value exists with the given string name.
+     * @param name - The string name to convert and check.
+     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
+     * or `Failure` with an error message if an error occurs during the check.
+     */
+    has(name: string): Result<boolean>;
 }
 
+/**
+ * Union type for validator constructor parameters.
+ * @public
+ */
+declare type IContextQualifierProviderValidatorCreateParams = IReadOnlyContextQualifierProviderValidatorCreateParams | IMutableContextQualifierProviderValidatorCreateParams;
+
 /**
  * Non-validated declaration of a single context qualifier value.
  * @public
@@ -3416,6 +3962,49 @@ declare interface IDeclarationOptions {
     normalized?: boolean;
 }
 
+/**
+ * Interface for options controlling delta generation behavior.
+ * @public
+ */
+declare interface IDeltaGeneratorOptions {
+    /**
+     * Context to use when resolving resources. If not provided, uses empty context.
+     */
+    context?: Context.IContextDecl;
+    /**
+     * Array of specific resource IDs to include in delta generation.
+     * If not provided, generates deltas for all resources in the delta resolver.
+     */
+    resourceIds?: ReadonlyArray<string>;
+    /**
+     * Whether to skip resources that haven't changed. Default: true.
+     */
+    skipUnchanged?: boolean;
+}
+
+/**
+ * Interface for parameters to create a {@link Resources.DeltaGenerator | DeltaGenerator}.
+ * @public
+ */
+declare interface IDeltaGeneratorParams {
+    /**
+     * The baseline resource resolver to compare against.
+     */
+    baselineResolver: IResourceResolver;
+    /**
+     * The delta resource resolver containing changes.
+     */
+    deltaResolver: IResourceResolver;
+    /**
+     * The resource manager to clone and update.
+     */
+    resourceManager: ResourceManagerBuilder;
+    /**
+     * Optional logger for status and error reporting.
+     */
+    logger?: Logging.ILogger;
+}
+
 /**
  * @internal
  */
@@ -3530,6 +4119,46 @@ declare interface IImportContext {
     readonly conditions?: ReadonlyArray<IConditionDecl>;
 }
 
+/**
+ * JSON representation of an imported directory structure
+ * @public
+ */
+declare interface IImportedDirectory {
+    /** Directory name */
+    name: string;
+    /** Files in this directory */
+    files: IImportedFile[];
+    /** Subdirectories */
+    subdirectories: IImportedDirectory[];
+}
+
+/**
+ * Imported directory structure
+ * @public
+ */
+declare type IImportedDirectory_2 = Json_2.IImportedDirectory;
+
+/**
+ * JSON representation of an imported file
+ * @public
+ */
+declare interface IImportedFile {
+    /** File name */
+    name: string;
+    /** Full path within archive */
+    path: string;
+    /** File content as string */
+    content: string;
+    /** MIME type */
+    type: string;
+}
+
+/**
+ * Imported file representation
+ * @public
+ */
+declare type IImportedFile_2 = Json_2.IImportedFile;
+
 /**
  * Generic interface for an importer than accepts a typed
  * {@link Import.IImportable | importable} item, extracts any resources
@@ -3663,6 +4292,11 @@ declare interface IJsonResourceTypeCreateParams {
      * instance.
      */
     index?: number;
+    /**
+     * Optional template for new instances of {@link ResourceTypes.JsonResourceType | JsonResourceType}
+     * resources.
+     */
+    template?: JsonObject;
 }
 
 /**
@@ -3727,10 +4361,10 @@ declare interface ILiteralQualifierTypeCreateParams {
      */
     enumeratedValues?: ReadonlyArray<string>;
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of literal values to use for matching. If not provided, no hierarchy will be used.
      */
-    hierarchy?: LiteralValueHierarchyDecl<string>;
+    hierarchy?: Config_2.LiteralValueHierarchyDecl<string>;
     /**
      * Global index for this qualifier type.
      */
@@ -3754,7 +4388,7 @@ declare interface ILiteralValue<T extends string> {
  */
 declare interface ILiteralValueHierarchyCreateParams<T extends string = string> {
     values: ReadonlyArray<T>;
-    hierarchy?: LiteralValueHierarchyDecl<T>;
+    hierarchy?: Partial<LiteralValueHierarchyDecl<T>>;
 }
 
 /**
@@ -3986,6 +4620,19 @@ declare class ImportContext implements IValidatedImportContext {
     static forContainerImport(container?: ResourceJson.Normalized.IContainerContextDecl, importer?: ImportContext): Result<ImportContext | undefined>;
 }
 
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+declare const importedDirectory: Converter<Json_2.IImportedDirectory>;
+
+/**
+ * Converter for imported file
+ * @public
+ */
+declare const importedFile: Converter<Json_2.IImportedFile>;
+
 /**
  * `Converter` for a normalized {@link ResourceJson.Normalized.IImporterResourceCandidateDecl | importer resource candidate declaration}.
  * @public
@@ -4083,30 +4730,97 @@ declare class ImportManager {
 }
 
 /**
- * Parameters for creating a {@link Import.Importers.PathImporter | PathImporter}.
- * @public
- */
-declare interface IPathImporterCreateParams {
-    qualifiers: IReadOnlyQualifierCollector;
-    tree?: FileTree.FileTree;
-    ignoreFileTypes?: string[];
-}
-
-/**
- * Parameters for creating a new {@link Qualifiers.QualifierCollector}.
+ * Mutable interface for providing qualifier values in an optimized runtime context.
+ * Extends the base interface with mutation operations and explicit mutability marker.
  * @public
  */
-declare interface IQualifierCollectorCreateParams {
+declare interface IMutableContextQualifierProvider extends IContextQualifierProviderBase {
     /**
-     * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} used to
-     * create {@link Qualifiers.Qualifier | qualifiers} from {@link Qualifiers.IQualifierDecl | declarations}.
+     * Explicit mutability marker for compile-time type discrimination.
+     * Always `true` for mutable providers.
      */
-    qualifierTypes: ReadOnlyQualifierTypeCollector;
+    readonly mutable: true;
     /**
-     * Optional list of {@link Qualifiers.IQualifierDecl | declarations} for the qualifiers to add to the collection
-     * upon creation.
-     */
-    qualifiers?: IQualifierDecl[];
+     * Sets a qualifier value in this provider.
+     * @param name - The {@link QualifierName | qualifier name} to set.
+     * @param value - The {@link QualifierContextValue | qualifier context value} to set.
+     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if not.
+     */
+    set(name: QualifierName, value: QualifierContextValue): Result<QualifierContextValue>;
+    /**
+     * Removes a qualifier value from this provider.
+     * @param name - The {@link QualifierName | qualifier name} to remove.
+     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if not found or an error occurs.
+     */
+    remove(name: QualifierName): Result<QualifierContextValue>;
+    /**
+     * Clears all qualifier values from this provider.
+     */
+    clear(): void;
+}
+
+/**
+ * A mutable interface for validators wrapping mutable context qualifier providers.
+ * Extends the base interface with mutation operations and provides compile-time type safety.
+ * @public
+ */
+declare interface IMutableContextQualifierProviderValidator<T extends IMutableContextQualifierProvider = IMutableContextQualifierProvider> extends IContextQualifierProviderValidatorBase<T> {
+    /**
+     * The wrapped mutable context qualifier provider.
+     */
+    readonly provider: T;
+    /**
+     * Sets a qualifier value using string inputs, converting to strongly-typed values.
+     * @param name - The string name to convert.
+     * @param value - The string value to convert.
+     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    set(name: string, value: string): Result<QualifierContextValue>;
+    /**
+     * Removes a qualifier value using string input, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert.
+     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    remove(name: string): Result<QualifierContextValue>;
+}
+
+/**
+ * Parameters for constructing a mutable context qualifier provider validator.
+ * @public
+ */
+declare interface IMutableContextQualifierProviderValidatorCreateParams<T extends IMutableContextQualifierProvider = IMutableContextQualifierProvider> {
+    provider: T;
+}
+
+/**
+ * Parameters for creating a {@link Import.Importers.PathImporter | PathImporter}.
+ * @public
+ */
+declare interface IPathImporterCreateParams {
+    qualifiers: IReadOnlyQualifierCollector;
+    tree?: FileTree.FileTree;
+    ignoreFileTypes?: string[];
+}
+
+/**
+ * Parameters for creating a new {@link Qualifiers.QualifierCollector}.
+ * @public
+ */
+declare interface IQualifierCollectorCreateParams {
+    /**
+     * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} used to
+     * create {@link Qualifiers.Qualifier | qualifiers} from {@link Qualifiers.IQualifierDecl | declarations}.
+     */
+    qualifierTypes: ReadOnlyQualifierTypeCollector;
+    /**
+     * Optional list of {@link Qualifiers.IQualifierDecl | declarations} for the qualifiers to add to the collection
+     * upon creation.
+     */
+    qualifiers?: IQualifierDecl[];
 }
 
 /**
@@ -4171,11 +4885,15 @@ declare interface IQualifierDefaultValueTokenParts {
  * territories, etc).
  * @public
  */
-declare interface IQualifierType extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
+declare interface IQualifierType<TCFGJSON extends JsonObject = JsonObject> extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
     /**
      * The name of the qualifier type.
      */
     readonly name: QualifierTypeName;
+    /**
+     * Name of the underlying system type.
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Unique key for this qualifier.
      */
@@ -4238,6 +4956,17 @@ declare interface IQualifierType extends ICollectible<QualifierTypeName, Qualifi
      * Sets the index for this qualifier type. Once set, index is immutable.
      */
     setIndex(index: number): Result<QualifierTypeIndex>;
+    /**
+     * Gets the configuration for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    /**
+     * Validates configuration JSON data for this qualifier type.
+     * @param from - The unknown data to validate as configuration JSON.
+     * @returns `Success` with validated JSON configuration if valid, `Failure` with an error message otherwise.
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
 }
 
 /**
@@ -4292,68 +5021,36 @@ declare interface IQualifierTypeCreateParams {
 }
 
 /**
- * A read-only interface exposing non-mutating methods of a {@link Runtime.Context.ContextQualifierProviderValidator | ContextQualifierProviderValidator}.
+ * Read-only interface for providing qualifier values in an optimized runtime context.
+ * Explicitly marked as immutable with compile-time type discrimination.
  * @public
  */
-declare interface IReadOnlyContextQualifierProviderValidator {
-    /**
-     * {@inheritdoc Runtime.Context.ContextQualifierProviderValidator.provider}
-     */
-    readonly provider: IContextQualifierProvider;
-    /**
-     * {@inheritdoc Runtime.Context.ContextQualifierProviderValidator.qualifiers}
-     */
-    readonly qualifiers: IReadOnlyQualifierCollector;
-    /**
-     * Gets a qualifier value by its string name, converting to strongly-typed QualifierName.
-     * @param name - The string name to convert and look up.
-     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found or an error occurs.
-     */
-    get(name: string): Result<QualifierContextValue>;
-    /**
-     * Gets a qualifier value by its number index, converting to strongly-typed QualifierIndex.
-     * @param index - The number index to convert and look up.
-     * @returns `Success` with the {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found or an error occurs.
-     */
-    getByIndex(index: number): Result<QualifierContextValue>;
-    /**
-     * Gets a validated qualifier context value by its string name.
-     * @param name - The string name to convert and look up.
-     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found, invalid, or an error occurs.
-     */
-    getValidated(name: string): Result<QualifierContextValue>;
-    /**
-     * Gets a validated qualifier context value by its number index.
-     * @param index - The number index to convert and look up.
-     * @returns `Success` with the validated {@link QualifierContextValue | qualifier context value} if found,
-     * or `Failure` with an error message if not found, invalid, or an error occurs.
-     */
-    getValidatedByIndex(index: number): Result<QualifierContextValue>;
-    /**
-     * Checks if a qualifier value exists with the given string name.
-     * @param name - The string name to convert and check.
-     * @returns `Success` with `true` if the qualifier value exists, `false` if it doesn't,
-     * or `Failure` with an error message if an error occurs during the check.
-     */
-    has(name: string): Result<boolean>;
+declare interface IReadOnlyContextQualifierProvider extends IContextQualifierProviderBase {
     /**
-     * Sets a qualifier value using string inputs, converting to strongly-typed values.
-     * @param name - The string name to convert.
-     * @param value - The string value to convert.
-     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
-     * or `Failure` with an error message if an error occurs.
+     * Explicit mutability marker for compile-time type discrimination.
+     * Always `false` for read-only providers.
      */
-    set(name: string, value: string): Result<QualifierContextValue>;
+    readonly mutable: false;
+}
+
+/**
+ * A read-only interface for validators wrapping read-only context qualifier providers.
+ * Only exposes read operations, providing compile-time type safety by excluding mutation methods.
+ * @public
+ */
+declare interface IReadOnlyContextQualifierProviderValidator<T extends IReadOnlyContextQualifierProvider = IReadOnlyContextQualifierProvider> {
     /**
-     * Removes a qualifier value using string input, converting to strongly-typed QualifierName.
-     * @param name - The string name to convert.
-     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
-     * or `Failure` with an error message if an error occurs.
+     * The wrapped read-only context qualifier provider.
      */
-    remove(name: string): Result<QualifierContextValue>;
+    readonly provider: T;
+}
+
+/**
+ * Parameters for constructing a read-only context qualifier provider validator.
+ * @public
+ */
+declare interface IReadOnlyContextQualifierProviderValidatorCreateParams<T extends IReadOnlyContextQualifierProvider = IReadOnlyContextQualifierProvider> {
+    provider: T;
 }
 
 /**
@@ -4398,7 +5095,7 @@ declare interface IReadOnlyResourceTreeBranch<T> {
  * Interface for a read-only result-based resource tree with navigation methods.
  * @public
  */
-declare interface IReadOnlyResourceTreeChildren<T, TID extends string = ResourceId, TNAME extends string = ResourceName> extends IReadOnlyResultMap<ResourceName, IReadOnlyResourceTreeNode<T>> {
+declare interface IReadOnlyResourceTreeChildren<T, TID extends string = ResourceId, TNAME extends string = ResourceName> extends IReadOnlyResultMap<TNAME, IReadOnlyResourceTreeNode<T>> {
     /**
      * Gets a tree node by its full ResourceId path.
      * @param id - The ResourceId path to look up
@@ -4485,6 +5182,29 @@ declare interface IReducedCandidate {
     readonly mergeMethod?: ResourceValueMergeMethod;
 }
 
+/**
+ * Options for configuring resource tree resolution.
+ * @public
+ */
+declare interface IResolveResourceTreeOptions {
+    /**
+     * Controls how errors are handled when resolving individual resources in the tree.
+     * - 'fail': Aggregate all errors and fail if any resource fails to resolve
+     * - 'ignore': Skip failed resources and omit them from the result
+     * - callback: Custom error handler that can provide alternate values or propagate errors
+     * @defaultValue 'fail'
+     */
+    onResourceError?: 'fail' | 'ignore' | ResourceErrorHandler;
+    /**
+     * Controls how empty branch nodes are handled during tree composition.
+     * - 'allow': Include empty branches as empty objects in the result
+     * - 'omit': Exclude empty branches from the parent object
+     * - callback: Custom handler that can provide alternate values or recovery logic
+     * @defaultValue 'allow'
+     */
+    onEmptyBranch?: 'allow' | 'omit' | EmptyBranchHandler;
+}
+
 /**
  * Interface for a resource that can be used in the runtime layer.
  * This provides the minimal properties needed from a resource without requiring
@@ -4494,8 +5214,10 @@ declare interface IReducedCandidate {
 declare interface IResource {
     /** The resource identifier */
     readonly id: string;
+    /** The resource name */
+    readonly name: string;
     /** The resource type */
-    readonly resourceType: ResourceType;
+    readonly resourceType: IResourceType;
     /** The decision used to select candidates */
     readonly decision: ConcreteDecision;
     /** The available candidates for this resource */
@@ -4512,6 +5234,7 @@ declare interface IResourceBuilderCreateParams {
     conditionSets: ConditionSetCollector;
     resourceTypes: ReadOnlyResourceTypeCollector;
     decisions: AbstractDecisionCollector;
+    candidateValues: CandidateValueCollector;
 }
 
 /**
@@ -4541,6 +5264,7 @@ declare interface IResourceCandidateCreateParams {
     resourceType?: ResourceType;
     parentConditions?: ReadonlyArray<Condition>;
     conditionSets: ConditionSetCollector;
+    candidateValues: CandidateValueCollector;
 }
 
 /**
@@ -4554,10 +5278,10 @@ declare interface IResourceCandidateValidationProperties {
      */
     id: ResourceId;
     /**
-     * {@inheritdoc ResourceJson.Json.ILooseResourceCandidateDecl.isPartial}
+     * Describes how complete the candidate value is.
      * @public
      */
-    isPartial: boolean;
+    completeness: CandidateCompleteness;
     /**
      * {@inheritdoc ResourceJson.Json.ILooseResourceCandidateDecl.json}
      * @public
@@ -4698,7 +5422,7 @@ declare interface IResourceDeclContainer {
  * implementations without requiring the full ResourceManagerBuilder build mechanics.
  * @public
  */
-export declare interface IResourceManager {
+export declare interface IResourceManager<TR extends IResource = IResource> {
     /**
      * A {@link Conditions.ReadOnlyConditionCollector | ReadOnlyConditionCollector} which
      * contains the {@link Conditions.Condition | conditions} used by resource candidates.
@@ -4719,16 +5443,25 @@ export declare interface IResourceManager {
      * @param id - The resource identifier
      * @returns Success with the runtime resource if found, Failure otherwise
      */
-    getBuiltResource(id: string): Result<IResource>;
+    getBuiltResource(id: string): Result<TR>;
+    /**
+     * Gets a resource tree built from the resources in this resource manager.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     */
+    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<TR>>;
     /**
      * A read-only result map of all built resources, keyed by resource ID.
      * Resources are built on-demand when accessed and returns Results for error handling.
      */
-    readonly builtResources: Collections.IReadOnlyValidatingResultMap<ResourceId, IResource>;
+    readonly builtResources: Collections.IReadOnlyValidatingResultMap<ResourceId, TR>;
     /**
      * The number of resources in this resource manager.
      */
     readonly numResources: number;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
     /**
      * The number of candidates in this resource manager.
      */
@@ -4761,6 +5494,47 @@ declare interface IResourceManagerCloneOptions extends IResourceDeclarationOptio
      * These conditions can modify or extend the resource candidates in the cloned manager.
      */
     readonly candidates?: ReadonlyArray<ResourceJson.Json.ILooseResourceCandidateDecl>;
+    /**
+     * Optional qualifier collector to use for the cloned manager.
+     * If not provided, uses the same qualifiers as the original manager.
+     * This allows creating clones with different qualifier configurations.
+     */
+    readonly qualifiers?: IReadOnlyQualifierCollector;
+    /**
+     * Optional resource type collector to use for the cloned manager.
+     * If not provided, uses the same resource types as the original manager.
+     * This allows creating clones with different resource type configurations.
+     */
+    readonly resourceTypes?: ReadOnlyResourceTypeCollector;
+}
+
+/**
+ * Minimal resource resolver
+ * @public
+ */
+export declare interface IResourceResolver {
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    readonly resourceIds: ReadonlyArray<ResourceId>;
+    /**
+     * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
+     * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
+     * priority "partial" candidates into it in ascending order of priority.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with the composed JsonValue if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveComposedResourceValue(resource: string): Result<JsonValue>;
+    /**
+     * Creates a new {@link IResourceResolver | resource resolver} with the given context.
+     * @param context - The context to use for the new resource resolver.
+     * @returns `Success` with the new resource resolver if successful,
+     * or `Failure` with an error message if the context is invalid.
+     * @public
+     */
+    withContext(context: Record<string, string>): Result<IResourceResolver>;
 }
 
 /**
@@ -4906,13 +5680,82 @@ declare interface IResourceTreeRootInit<T> {
     readonly children: Record<ResourceName, ResourceTreeNodeInit<T>>;
 }
 
+/**
+ * Interface for a resource type.  Resource types are responsible for
+ * validating and converting JSON values into the appropriate strongly-typed
+ * resource value.
+ * @public
+ */
+declare interface IResourceType<T = unknown> extends ICollectible<ResourceTypeName, ResourceTypeIndex> {
+    /**
+     * The key for this resource type.
+     */
+    readonly key: ResourceTypeName;
+    /**
+     * The index for this resource type.
+     */
+    readonly index: ResourceTypeIndex | undefined;
+    /**
+     * Validates properties of a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
+     * a resource instance value.
+     * @param props - The {@link ResourceTypes.IResourceCandidateValidationProperties | properties } to validate.
+     * @returns `Success` with the strongly-typed resource value if the JSON and merge method
+     * are valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    validateDeclaration(props: IResourceCandidateValidationProperties): Result<T | Partial<T>>;
+    /**
+     * Validates a JSON value for use as a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed partial resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: CandidateCompleteness): Result<Partial<T>>;
+    /**
+     * Validates a JSON value for use as a complete resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: 'full'): Result<T>;
+    /**
+     * Validates a JSON value for use as a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed partial resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: 'partial'): Result<Partial<T>>;
+    /**
+     * Sets the index for this resource type.  Once set, the index cannot be changed.
+     */
+    setIndex(index: number): Result<ResourceTypeIndex>;
+    /**
+     * Creates a template for a new resource of this type.
+     * The template provides a default structure for creating new resource instances.
+     * @param resourceId - The id for the new resource.
+     * @param init - An optional initial value for the resource.
+     * @param resolver - An optional resource resolver that can be used to create the template.
+     * @param conditions - An optional set of conditions that must be met for the resource to be selected.
+     * @returns A loose resource declaration with default values for this resource type.
+     * @public
+     */
+    createTemplate(resourceId: ResourceId, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
+}
+
 /**
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
  */
-declare interface IResourceTypeConfig {
+declare interface IResourceTypeConfig<T extends JsonObject = JsonObject> {
     name: string;
     typeName: string;
+    template?: T;
 }
 
 /**
@@ -4967,6 +5810,33 @@ declare function isResourceTreeLeafInit<T>(init: ResourceTreeNodeInit<T>): init
  */
 declare function isResourceTreeRootOrNodeInit<T>(init: ResourceTreeNodeInit<T> | IResourceTreeRootInit<T>): init is IResourceTreeBranchInit<T>;
 
+/**
+ * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a
+ * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.
+ * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.
+ * @public
+ */
+declare function isSystemQualifierTypeConfig(config: IAnyQualifierTypeConfig): config is ISystemQualifierTypeConfig;
+
+/**
+ * Checks if the given index is a valid candidate value index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid candidate value index, otherwise `false`.
+ * @public
+ */
+declare function isValidCandidateValueIndex(index: number): index is CandidateValueIndex;
+
+/**
+ * Checks if the given key is a valid candidate value key.
+ *
+ * @param key - The key to validate.
+ * @returns `true` if the key is a valid candidate value key, otherwise `false`.
+ * @public
+ */
+declare function isValidCandidateValueKey(key: string): key is CandidateValueKey;
+
 /**
  * Determines whether a number is a valid condition index.
  * @param index - the number to validate
@@ -5080,6 +5950,15 @@ declare function isValidDecisionIndex(index: number): index is DecisionIndex;
  */
 declare function isValidDecisionKey(key: string): key is DecisionKey;
 
+/**
+ * Determines whether a string is a valid qualifier context value.
+ * For now, any non-empty string is considered a valid context value.
+ * @param value - the string to validate
+ * @returns true if the string is a valid qualifier context value, false otherwise.
+ * @public
+ */
+declare function isValidQualifierContextValue(value: string): value is QualifierContextValue;
+
 /**
  * Determines whether a string is a valid qualifier default values token.
  * Qualifier default values tokens are pipe-separated lists of qualifier default value tokens.
@@ -5195,7 +6074,7 @@ declare interface ISystemConfiguration {
     /** Optional description explaining the purpose and use case of the configuration. */
     description?: string;
     /** Qualifier type configurations that define the available qualifier types in the system. */
-    qualifierTypes: QualifierTypes.Config.ISystemQualifierTypeConfig[];
+    qualifierTypes: QualifierTypes.Config.IAnyQualifierTypeConfig[];
     /** Qualifier declarations that define the available qualifiers in the system. */
     qualifiers: Qualifiers.IQualifierDecl[];
     /** Resource type configurations that define the available resource types in the system. */
@@ -5213,6 +6092,8 @@ declare interface ISystemConfigurationInitParams {
      * Use `null` as the value to remove an existing default value.
      */
     qualifierDefaultValues?: Record<string, string | null>;
+    qualifierTypeFactory?: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>;
+    resourceTypeFactory?: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 }
 
 /**
@@ -5245,6 +6126,14 @@ declare interface ISystemTerritoryQualifierTypeConfig extends IQualifierTypeConf
     systemType: 'territory';
 }
 
+/**
+ * Validate ZIP file extension
+ * @param filename - Filename to validate
+ * @returns True if filename has .zip extension
+ * @public
+ */
+declare function isZipFile(filename: string): boolean;
+
 /**
  * Configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.
  * @public
@@ -5254,7 +6143,7 @@ declare interface ITerritoryQualifierTypeConfig {
     acceptLowercase?: boolean;
     allowedTerritories?: string[];
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of territory values to use for matching. If not provided, no hierarchy will be used.
      */
     hierarchy?: LiteralValueHierarchyDecl<string>;
@@ -5287,10 +6176,10 @@ declare interface ITerritoryQualifierTypeCreateParams {
      */
     acceptLowercase?: boolean;
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of territory values to use for matching. If not provided, no hierarchy will be used.
      */
-    hierarchy?: LiteralValueHierarchyDecl<string>;
+    hierarchy?: Config_2.LiteralValueHierarchyDecl<string>;
 }
 
 /**
@@ -5419,8 +6308,113 @@ declare interface IValidatingSimpleContextQualifierProviderCreateParams {
 }
 
 /**
- * Joins a list of {@link ResourceId | resource ID} or {@link ResourceName | resource name} with
- * to create a new {@link ResourceId | resource ID}. Returns `undefined` if no names are defined.
+ * JSON representation of ZIP archive config information
+ * @public
+ */
+declare interface IZipArchiveConfigInfo {
+    /** Type of config (always 'file') */
+    type: 'file';
+    /** Original config file path */
+    originalPath: string;
+    /** Path within the archive (e.g., "config.json") */
+    archivePath: string;
+}
+
+/**
+ * Options for creating a ZIP archive buffer from a file tree
+ * @public
+ */
+declare interface IZipArchiveFileTreeOptions {
+    /** Input file or directory */
+    inputItem?: FileTree.FileTreeItem;
+    /** Optional configuration file */
+    configItem?: FileTree.IFileTreeFileItem;
+}
+
+/**
+ * JSON representation of ZIP archive input information
+ * @public
+ */
+declare interface IZipArchiveInputInfo {
+    /** Type of input (file or directory) */
+    type: 'file' | 'directory';
+    /** Original file/directory path */
+    originalPath: string;
+    /** Path within the archive (e.g., "input/mydir") */
+    archivePath: string;
+}
+
+/**
+ * Options for loading a ZIP archive
+ * @public
+ */
+declare interface IZipArchiveLoadOptions {
+    /** Validate manifest strictly */
+    strictManifestValidation?: boolean;
+}
+
+/**
+ * Result of ZIP archive loading
+ * @public
+ */
+declare interface IZipArchiveLoadResult {
+    /** Parsed archive manifest */
+    manifest: IZipArchiveManifest_2 | undefined;
+    /** Loaded configuration */
+    config: Model.ISystemConfiguration | undefined;
+    /** All files extracted from the archive */
+    files: IImportedFile_2[];
+    /** Directory structure if available */
+    directory: IImportedDirectory_2 | undefined;
+}
+
+/**
+ * JSON representation of a ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+declare interface IZipArchiveManifest {
+    /** Archive creation timestamp */
+    timestamp: string;
+    /** Optional input source information */
+    input?: IZipArchiveInputInfo;
+    /** Optional configuration file information */
+    config?: IZipArchiveConfigInfo;
+}
+
+/**
+ * Standardized ZIP archive manifest format (compatible with existing tools)
+ * @public
+ */
+declare type IZipArchiveManifest_2 = Json_2.IZipArchiveManifest;
+
+/**
+ * Options for creating a ZIP archive buffer
+ * @public
+ */
+declare interface IZipArchivePathOptions {
+    /** File or directory path to include in the archive */
+    inputPath?: string;
+    /** Optional configuration file path */
+    configPath?: string;
+}
+
+/**
+ * Result of ZIP archive buffer creation
+ * @public
+ */
+declare interface IZipArchiveResult {
+    /** Raw ZIP data buffer */
+    zipBuffer: Uint8Array;
+    /** Archive manifest with metadata */
+    manifest: IZipArchiveManifest_2;
+    /** Total ZIP size in bytes */
+    size: number;
+}
+
+/**
+ * Joins a list of {@link ResourceId | resource ID} or {@link ResourceName | resource name} with
+ * to create a new {@link ResourceId | resource ID}. Returns `undefined` if no names are defined.
  *
  * @param base - The base name or ID to join.
  * @param names - Additional names to join.
@@ -5465,6 +6459,16 @@ declare namespace Json {
     }
 }
 
+declare namespace Json_2 {
+    export {
+        IZipArchiveInputInfo,
+        IZipArchiveConfigInfo,
+        IZipArchiveManifest,
+        IImportedFile,
+        IImportedDirectory
+    }
+}
+
 /**
  * {@link Import.Importers.IImporter | Importer} implementation which imports resources from a JSON object.
  * @public
@@ -5492,18 +6496,29 @@ declare class JsonImporter implements IImporter {
     private _tryImportResourceTree;
 }
 
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @public
+ */
+declare const jsonQualifierTypeConfig: Converter<Model_2.IQualifierTypeConfig<JsonObject>, Converters.IJsonConverterContext>;
+
 /**
  * Implementation of a {@link ResourceTypes.ResourceType | ResourceType} for JSON values.
  * @public
  */
 declare class JsonResourceType extends ResourceType<JsonObject> {
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.systemTypeName}
+     */
+    readonly systemTypeName: ResourceTypeName;
     /**
      * Protected {@link ResourceTypes.JsonResourceType | JsonResourceType} constructor for use by subclasses.
      * Use {@link ResourceTypes.JsonResourceType.create | JsonResourceType.create} to create a new instance.
      * @param key - The key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param index - Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      */
-    protected constructor(key: ResourceTypeName, index?: number);
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject);
     /**
      * Factory method to create a new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param params - {@link ResourceTypes.IJsonResourceTypeCreateParams | Parameters} to create the new instance.
@@ -5553,7 +6568,11 @@ declare const LanguagePrioritySystemConfiguration: ISystemConfiguration;
  * Accepts a list of language tags in the context by default.
  * @public
  */
-declare class LanguageQualifierType extends QualifierType {
+declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config_2.ILanguageQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
      * @param name - Optional name for the qualifier type. Defaults to 'language'.
@@ -5583,6 +6602,27 @@ declare class LanguageQualifierType extends QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config_2.ISystemLanguageQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config_2.ISystemLanguageQualifierTypeConfig>;
     /**
      * Matches a single language condition against a single language context value using
      * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.
@@ -5606,7 +6646,11 @@ declare const languageQualifierTypeConfig: ObjectConverter<Model_2.ILanguageQual
  * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
-declare class LiteralQualifierType extends QualifierType {
+declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config_2.ILiteralQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Indicates whether the qualifier match is case-sensitive.
      */
@@ -5642,6 +6686,27 @@ declare class LiteralQualifierType extends QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
      */
     isPotentialMatch(conditionValue: string, contextValue: string): boolean;
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config_2.ISystemLiteralQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config_2.ISystemLiteralQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
@@ -5771,6 +6836,11 @@ declare class LiteralValueHierarchy<T extends string = string> {
      */
     match(condition: QualifierConditionValue, context: QualifierContextValue, __operator?: ConditionOperator): QualifierMatchScore;
     protected static _buildValuesFromHierarchy<T extends string>(params: ILiteralValueHierarchyCreateParams<T>): Result<ReadonlyMap<T, ILiteralValue<T>>>;
+    /**
+     * Converts the hierarchy to a record of parent-child relationships.
+     * @returns A record of parent-child relationships.
+     */
+    asRecord(): Record<string, string>;
 }
 
 /**
@@ -5790,7 +6860,7 @@ declare function literalValueHierarchyCreateParams<T extends string>(valueConver
  * determine the relationship between values when matching conditions and contexts.
  * @public
  */
-declare type LiteralValueHierarchyDecl<T extends string> = Partial<Record<T, T>>;
+declare type LiteralValueHierarchyDecl<T extends string> = Record<T, T>;
 
 /**
  * `Converter` for a normalized {@link ResourceJson.Json.ILooseConditionDecl | loose condition declaration}.
@@ -5933,6 +7003,12 @@ declare function mergeLooseCandidate(candidate: Normalized.IImporterResourceCand
  */
 declare function mergeLooseResource(resource: Normalized.IImporterResourceDecl, baseName?: string, baseConditions?: ReadonlyArray<Json.ILooseConditionDecl>): Result<Normalized.ILooseResourceDecl>;
 
+/**
+ * Validator for MIME type strings
+ * @public
+ */
+declare const mimeType: Validator<string>;
+
 /**
  * Minimum valid priority for a condition.
  * @public
@@ -5947,14 +7023,17 @@ declare namespace Model {
 
 declare namespace Model_2 {
     export {
+        isSystemQualifierTypeConfig,
         IQualifierTypeConfig,
         ILanguageQualifierTypeConfig,
+        LiteralValueHierarchyDecl,
         ITerritoryQualifierTypeConfig,
         ILiteralQualifierTypeConfig,
         ISystemLanguageQualifierTypeConfig,
         ISystemTerritoryQualifierTypeConfig,
         ISystemLiteralQualifierTypeConfig,
-        ISystemQualifierTypeConfig
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
     }
 }
 
@@ -5975,6 +7054,48 @@ declare namespace Model_3 {
     }
 }
 
+declare namespace Model_4 {
+    export {
+        IBundleMetadata,
+        IBundleExportMetadata,
+        IBundle,
+        IBundleCreateParams
+    }
+}
+
+/**
+ * A validator for mutable context qualifier providers that accepts string inputs
+ * and converts them to strongly-typed values before calling the wrapped provider.
+ * Provides both read and mutation operations.
+ * @public
+ */
+declare class MutableContextQualifierProviderValidator<T extends IMutableContextQualifierProvider = IMutableContextQualifierProvider> extends BaseContextQualifierProviderValidator<T> implements IMutableContextQualifierProviderValidator<T> {
+    /**
+     * The wrapped mutable context qualifier provider.
+     */
+    readonly provider: T;
+    /**
+     * Constructs a new {@link Runtime.Context.MutableContextQualifierProviderValidator | MutableContextQualifierProviderValidator}.
+     * @param params - Required parameters for constructing the validator.
+     */
+    constructor(params: IMutableContextQualifierProviderValidatorCreateParams<T>);
+    /**
+     * Sets a qualifier value using string inputs, converting to strongly-typed values.
+     * @param name - The string name to convert.
+     * @param value - The string value to convert.
+     * @returns `Success` with the set {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    set(name: string, value: string): Result<QualifierContextValue>;
+    /**
+     * Removes a qualifier value using string input, converting to strongly-typed QualifierName.
+     * @param name - The string name to convert.
+     * @returns `Success` with the removed {@link QualifierContextValue | qualifier context value} if successful,
+     * or `Failure` with an error message if an error occurs.
+     */
+    remove(name: string): Result<QualifierContextValue>;
+}
+
 /**
  * {@link QualifierMatchScore | Match score} indicating no match.
  * @public
@@ -6025,6 +7146,14 @@ declare namespace Normalized {
     }
 }
 
+/**
+ * Normalize path separators for cross-platform compatibility
+ * @param path - Path to normalize
+ * @returns Normalized path
+ * @public
+ */
+declare function normalizePath(path: string): string;
+
 /**
  * Overall cache metrics across all cache types.
  * @public
@@ -6079,6 +7208,22 @@ declare function parseQualifierDefaultValuesTokenParts(token: string): Result<IQ
  */
 declare function parseQualifierDefaultValueTokenParts(token: string): Result<IQualifierDefaultValueTokenParts>;
 
+/**
+ * Parse and validate configuration JSON
+ * @param configData - JSON string containing configuration
+ * @returns Result containing validated configuration
+ * @public
+ */
+declare function parseZipArchiveConfiguration(configData: string): Result<Model.ISystemConfiguration>;
+
+/**
+ * Parse and validate a ZIP archive manifest
+ * @param manifestData - JSON string containing manifest data
+ * @returns Result containing validated manifest
+ * @public
+ */
+declare function parseZipArchiveManifest(manifestData: string): Result<Json_2.IZipArchiveManifest>;
+
 /**
  * {@link Import.Importers.IImporter | Importer} implementation which imports resources from a `FileTree`
  * given a path.
@@ -6306,6 +7451,12 @@ export declare type QualifierConditionValue = Brand<string, 'QualifierConditionV
  */
 export declare type QualifierContextValue = Brand<string, 'QualifierContextValue'>;
 
+/**
+ * `Converter` which validates an `unknown` value as a {@link QualifierContextValue | QualifierContextValue}.
+ * @public
+ */
+declare const qualifierContextValue: Converter<QualifierContextValue, unknown>;
+
 /**
  * Converter for a {@link Qualifiers.IQualifierDecl | qualifier declaration}.
  * @public
@@ -6509,11 +7660,15 @@ export { Qualifiers }
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-export declare abstract class QualifierType implements IQualifierType {
+export declare abstract class QualifierType<TCFGJSON extends JsonObject = JsonObject> implements IQualifierType<TCFGJSON> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.name}
      */
     readonly name: QualifierTypeName;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    abstract readonly systemTypeName: QualifierTypeName;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.key}
      */
@@ -6559,6 +7714,14 @@ export declare abstract class QualifierType implements IQualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.matches}
      */
     matches(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    abstract getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    abstract validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
      */
@@ -6614,7 +7777,7 @@ export declare abstract class QualifierType implements IQualifierType {
  * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.
  * @public
  */
-declare const qualifierType: Converter<QualifierType, IQualifierTypeConvertContext>;
+declare const qualifierType: Converter<QualifierType<JsonObject>, IQualifierTypeConvertContext>;
 
 /**
  * Collector for {@link QualifierTypes.QualifierType | QualifierType} objects.
@@ -6638,6 +7801,74 @@ declare class QualifierTypeCollector extends ValidatingConvertingCollector<Quali
     protected static _toQualifierType(from: unknown): Result<QualifierType>;
 }
 
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @param config - A `Converter` for the configuration object.
+ * @public
+ */
+declare function qualifierTypeConfig<T, TD = unknown>(config: Converter<T, TD>): Converter<Model_2.IQualifierTypeConfig<T>, TD>;
+
+/**
+ * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
+ * supporting both built-in system types and custom external types.
+ *
+ * This factory allows external consumers to extend the qualifier type system with their own custom types
+ * while maintaining support for all built-in types (Language, Territory, Literal).
+ *
+ * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
+ *
+ * @example Creating a factory with custom qualifier types
+ * ```typescript
+ * // Define a custom qualifier type
+ * class CustomQualifierType extends QualifierType {
+ *   // ... implementation
+ * }
+ *
+ * // Define a discriminated union of all types
+ * type AppQualifierType = SystemQualifierType | CustomQualifierType;
+ *
+ * // Create a factory that handles custom types
+ * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
+ *   create(config) {
+ *     // ... handle custom type creation
+ *   }
+ * };
+ *
+ * // Create the combined factory
+ * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
+ *
+ * // The factory returns T | SystemQualifierType, supporting all types
+ * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
+ * ```
+ *
+ * @remarks
+ * - The factory chains custom factories with the built-in factory
+ * - Custom factories are tried first, falling back to built-in types
+ * - The return type is a union of custom types (T) and system types
+ *
+ * @public
+ */
+declare class QualifierTypeFactory<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+}
+
+/**
+ * Function signature for creating a qualifier type from configuration.
+ * @public
+ */
+declare type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (config: QualifierTypes.Config.IAnyQualifierTypeConfig) => Result<T>;
+
 /**
  * Branded number representing a validated qualifier type index.
  * @public
@@ -6673,7 +7904,6 @@ declare namespace QualifierTypes {
         LanguageQualifierType,
         ILiteralQualifierTypeCreateParams,
         LiteralQualifierType,
-        LiteralValueHierarchyDecl,
         ILiteralValue,
         ILiteralValueHierarchyCreateParams,
         LiteralValueHierarchy,
@@ -6683,7 +7913,8 @@ declare namespace QualifierTypes {
         QualifierTypeCollector,
         ReadOnlyQualifierTypeCollector,
         createQualifierTypeFromConfig,
-        createQualifierTypeFromSystemConfig
+        createQualifierTypeFromSystemConfig,
+        SystemQualifierType
     }
 }
 export { QualifierTypes }
@@ -6706,6 +7937,24 @@ declare type ReadOnlyConditionCollector = Collections.IReadOnlyValidatingCollect
  */
 declare type ReadOnlyConditionSetCollector = Collections.IReadOnlyValidatingCollector<ConditionSet>;
 
+/**
+ * A validator for read-only context qualifier providers that accepts string inputs
+ * and converts them to strongly-typed values before calling the wrapped provider.
+ * Only provides read operations for compile-time type safety.
+ * @public
+ */
+declare class ReadOnlyContextQualifierProviderValidator<T extends IReadOnlyContextQualifierProvider = IReadOnlyContextQualifierProvider> extends BaseContextQualifierProviderValidator<T> implements IReadOnlyContextQualifierProviderValidator<T> {
+    /**
+     * The wrapped read-only context qualifier provider.
+     */
+    readonly provider: T;
+    /**
+     * Constructs a new {@link Runtime.Context.ReadOnlyContextQualifierProviderValidator | ReadOnlyContextQualifierProviderValidator}.
+     * @param params - Required parameters for constructing the validator.
+     */
+    constructor(params: IReadOnlyContextQualifierProviderValidatorCreateParams<T>);
+}
+
 /**
  * Interface exposing non-mutating members of a
  * {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector}.
@@ -6851,6 +8100,7 @@ declare namespace RegularExpressions {
         contextToken_2 as contextToken,
         conditionSetHash_2 as conditionSetHash,
         decisionKey_2 as decisionKey,
+        candidateValueKey_2 as candidateValueKey,
         qualifierDefaultValueToken_2 as qualifierDefaultValueToken,
         qualifierDefaultValuesToken_2 as qualifierDefaultValuesToken,
         territoryCode
@@ -6867,10 +8117,14 @@ export declare class Resource implements IResource {
      * The unique {@link ResourceId | id} of the resource.
      */
     readonly id: ResourceId;
+    /**
+     * The name of the resource.
+     */
+    readonly name: ResourceName;
     /**
      * The {@link ResourceTypes.ResourceType | type} of the resource.
      */
-    readonly _resourceType: ResourceType;
+    readonly resourceType: ResourceType;
     /**
      * The array of {@link Resources.ResourceCandidate | candidates} for the resource.
      */
@@ -6879,10 +8133,6 @@ export declare class Resource implements IResource {
      * {@link Decisions.ConcreteDecision | Decision} for optimized resource resolution.
      */
     readonly decision: ConcreteDecision;
-    /**
-     * Gets the resource type (implements IResource interface).
-     */
-    get resourceType(): ResourceType;
     /**
      * Gets the resource type name as a string.
      */
@@ -7007,6 +8257,10 @@ declare class ResourceBuilder {
      * Collector for {@link Decisions.AbstractDecision | abstract decisions}.
      */
     protected _decisions: AbstractDecisionCollector;
+    /**
+     * Collector for candidate values.
+     */
+    protected _candidateValues: CandidateValueCollector;
     /**
      * Constructor for a {@link Resources.ResourceBuilder | ResourceBuilder} object.
      * @param params - Parameters to construct the new {@link Resources.ResourceBuilder | ResourceBuilder}.
@@ -7084,10 +8338,16 @@ export declare class ResourceCandidate implements IResourceCandidate {
      * is a possible instance.
      */
     readonly id: ResourceId;
+    /**
+     * The candidate value that contains the JSON representation of the instance data.
+     */
+    readonly candidateValue: CandidateValue;
     /**
      * The JSON representation of the instance data to be applied.
+     * @remarks
+     * This property provides access to the JSON data from the underlying candidate value.
      */
-    readonly json: JsonObject;
+    get json(): JsonObject;
     /**
      * The conditions under which this candidate applies.
      */
@@ -7105,6 +8365,10 @@ export declare class ResourceCandidate implements IResourceCandidate {
      * this candidate belongs.
      */
     readonly resourceType: ResourceType | undefined;
+    /**
+     * The completeness of the candidate value.
+     */
+    get completeness(): CandidateCompleteness;
     /**
      * Constructor for a {@link Resources.ResourceCandidate | ResourceCandidate} object.
      * @param params - Parameters to create a new {@link Resources.ResourceCandidate | ResourceCandidate}.
@@ -7277,6 +8541,17 @@ declare class ResourceDeclTree implements IResourceDeclContainer {
     private _extract;
 }
 
+/**
+ * Type for handling resource resolution errors during tree traversal.
+ * The handler receives the resource that failed to resolve, the error message, and the resolver for recovery attempts.
+ * It can return:
+ * - Success(undefined) to omit the property from the result
+ * - Success(value) to use an alternate value
+ * - Failure to propagate the error
+ * @public
+ */
+declare type ResourceErrorHandler = (resource: IResource, message: string, resolver: ResourceResolver) => Result<JsonValue | undefined>;
+
 /**
  * Branded string representing a validated resource id.  A resource ID
  * is a dot-separated sequence of resource names.
@@ -7305,7 +8580,7 @@ declare const resourceIndex: Converter<ResourceIndex, unknown>;
 declare namespace ResourceJson {
     export {
         Compiled,
-        Convert_8 as Convert,
+        Convert_7 as Convert,
         Helpers_2 as Helpers,
         Json,
         Normalized,
@@ -7323,21 +8598,69 @@ export { ResourceJson }
  * and builds a collection of {@link Resources.Resource | resources} once all candidates are collected.
  * @public
  */
-export declare class ResourceManagerBuilder implements IResourceManager {
+export declare class ResourceManagerBuilder implements IResourceManager<Resource> {
+    /**
+     * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifiers} used by this resource manager.
+     */
     readonly qualifiers: IReadOnlyQualifierCollector;
+    /**
+     * The {@link ResourceTypes.ReadOnlyResourceTypeCollector | resource types} used by this resource manager.
+     */
     readonly resourceTypes: ReadOnlyResourceTypeCollector;
+    /**
+     * The {@link Conditions.ConditionCollector | condition collector} used by this resource manager.
+     * @internal
+     */
     protected readonly _conditions: ConditionCollector;
+    /**
+     * The {@link Conditions.ConditionSetCollector | condition set collector} used by this resource manager.
+     * @internal
+     */
     protected readonly _conditionSets: ConditionSetCollector;
+    /**
+     * The {@link Decisions.AbstractDecisionCollector | abstract decision collector} used by this resource manager.
+     * @internal
+     */
     protected readonly _decisions: AbstractDecisionCollector;
+    /**
+     * The candidate value collector used by this resource manager.
+     * @internal
+     */
+    protected readonly _candidateValues: CandidateValueCollector;
+    /**
+     * The {@link Resources.ResourceBuilder | resource builders} used by this resource manager.
+     * @internal
+     */
     protected readonly _resources: ValidatingResultMap<ResourceId, ResourceBuilder>;
-    readonly _builtResources: ValidatingResultMap<ResourceId, Resource>;
+    /**
+     * The {@link Resources.Resource | resources} built by this resource manager.
+     * @internal
+     */
+    protected readonly _builtResources: ValidatingResultMap<ResourceId, Resource>;
+    /**
+     * Whether the resources have been built.
+     * @internal
+     */
     protected _built: boolean;
+    /**
+     * The cached resource tree for this resource manager.
+     * @internal
+     */
+    protected _cachedResourceTree?: ResourceTree.IReadOnlyResourceTreeRoot<Resource>;
+    /**
+     * The {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier types} used by this resource manager.
+     */
+    get qualifierTypes(): ReadOnlyQualifierTypeCollector;
     /**
      * A {@link Conditions.ConditionCollector | ConditionCollector} which
      * contains the {@link Conditions.Condition | conditions} used so far by
      * the {@link Resources.ResourceCandidate | resource candidates} in this manager.
      */
     get conditions(): ReadOnlyConditionCollector;
+    /**
+     * The resource IDs that this resource manager can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
     /**
      * A {@link Conditions.ConditionSetCollector | ConditionSetCollector} which
      * contains the {@link Conditions.ConditionSet | condition sets} used so far by
@@ -7397,6 +8720,17 @@ export declare class ResourceManagerBuilder implements IResourceManager {
      * @public
      */
     static createPredefined(name: Config.PredefinedSystemConfiguration, qualifierDefaultValues?: Config.ISystemConfigurationInitParams['qualifierDefaultValues']): Result<ResourceManagerBuilder>;
+    /**
+     * Creates a new {@link Resources.ResourceManagerBuilder | ResourceManagerBuilder} from a
+     * {@link ResourceJson.Compiled.ICompiledResourceCollection | compiled resource collection}.
+     * This method reconstructs an exactly equivalent builder where all qualifier, condition,
+     * condition set, and decision indices match the original compiled collection.
+     * @param compiledCollection - The compiled resource collection to reconstruct from.
+     * @param systemConfig - The system configuration containing qualifiers and resource types.
+     * @returns `Success` with the new manager if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    static createFromCompiledResourceCollection(compiledCollection: ResourceJson.Compiled.ICompiledResourceCollection, systemConfig: Config.SystemConfiguration): Result<ResourceManagerBuilder>;
     /**
      * Given a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration}, builds and adds
      * a {@link Resources.ResourceCandidate | candidate} to the manager.
@@ -7450,6 +8784,19 @@ export declare class ResourceManagerBuilder implements IResourceManager {
      * @public
      */
     getAllBuiltResources(): Result<ReadonlyArray<Resource>>;
+    /**
+     * Builds and returns a hierarchical tree representation of all resources managed by this builder.
+     * Resources are organized based on their dot-separated resource IDs (e.g., "app.messages.welcome"
+     * becomes a tree with "app" as root, "messages" as branch, and "welcome" as leaf).
+     *
+     * String-based validation is available through the `children.validating` property,
+     * allowing callers to use `tree.children.validating.getById(stringId)` for validated access.
+     *
+     * Uses lazy initialization with caching for performance.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     * @public
+     */
+    getBuiltResourceTree(): Result<ResourceTree.IReadOnlyResourceTreeRoot<Resource>>;
     /**
      * Gets a read-only array of all {@link Resources.Resource | built resources} in the manager.
      * @returns `Success` with an array of resources if successful, or `Failure` with an error message if not.
@@ -7523,12 +8870,17 @@ export declare class ResourceManagerBuilder implements IResourceManager {
      */
     getResourceCollectionDecl(options?: IResourceDeclarationOptions): Result<ResourceJson.Normalized.IResourceCollectionDecl>;
     /**
-     * Creates a filtered clone of this ResourceManagerBuilder using the specified context.
-     * This is a convenience method that creates a new ResourceManagerBuilder with the same
-     * configuration but filtered to include only candidates that match the provided context.
-     * If candidates are provided for editing, they will be applied with collision detection.
-     * @param options - Options for the cloning operation, including the strongly-typed filterForContext property and optional candidates for edits.
-     * @returns A Result containing the new filtered ResourceManagerBuilder.
+     * Creates a clone of this ResourceManagerBuilder with optional configuration overrides.
+     * This method creates a new ResourceManagerBuilder that can optionally use different
+     * qualifiers and/or resource types than the original. It can also be filtered to include
+     * only candidates that match the provided context and apply candidate edits.
+     *
+     * @param options - Options for the cloning operation:
+     *   - `qualifiers`: Optional qualifier collector to use instead of the original
+     *   - `resourceTypes`: Optional resource type collector to use instead of the original
+     *   - `filterForContext`: Optional context filter for candidates
+     *   - `candidates`: Optional candidate edits to apply during cloning
+     * @returns A Result containing the new ResourceManagerBuilder with the specified configuration.
      * @public
      */
     clone(options?: IResourceManagerCloneOptions): Result<ResourceManagerBuilder>;
@@ -7547,7 +8899,6 @@ export declare class ResourceManagerBuilder implements IResourceManager {
      * @returns A Result containing the ConditionSet token if successful, or failure if validation fails
      * @internal
      */
-    private static _getConditionSetToken;
     /**
      * Applies candidate edits to a resource declaration, handling collisions using condition set tokens.
      * If there's no collision, adds the candidate. If there's a collision, replaces the original candidate with the edit.
@@ -7568,6 +8919,49 @@ export declare class ResourceManagerBuilder implements IResourceManager {
      * @internal
      */
     private static _createResourceDeclFromCandidates;
+    /**
+     * Reconstructs conditions from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add conditions to.
+     * @param compiledCollection - The compiled collection containing conditions.
+     * @returns `Success` if all conditions were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _reconstructConditions;
+    /**
+     * Reconstructs condition sets from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add condition sets to.
+     * @param compiledCollection - The compiled collection containing condition sets.
+     * @returns `Success` if all condition sets were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _reconstructConditionSets;
+    /**
+     * Reconstructs decisions from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add decisions to.
+     * @param compiledCollection - The compiled collection containing decisions.
+     * @returns `Success` if all decisions were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _reconstructDecisions;
+    /**
+     * Reconstructs resources and their candidates from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add resources to.
+     * @param compiledCollection - The compiled collection containing resources.
+     * @returns `Success` if all resources were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _reconstructResources;
+    /**
+     * Helper method to create candidates from a decision's condition sets.
+     * @param compiledResource - The compiled resource containing candidates.
+     * @param decision - The decision containing condition sets.
+     * @param resourceType - The resource type for the candidates.
+     * @param builder - The builder to add candidates to.
+     * @param candidateValues - Array of candidate values indexed by valueIndex.
+     * @returns `Success` if all candidates were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _createCandidatesFromDecision;
 }
 
 /**
@@ -7594,7 +8988,7 @@ declare const resourceName: Converter<ResourceName, unknown>;
  * and caching results for optimal performance.
  * @public
  */
-export declare class ResourceResolver {
+export declare class ResourceResolver implements IResourceResolver {
     /**
      * The resource manager that defines available resources and provides condition access.
      */
@@ -7612,7 +9006,15 @@ export declare class ResourceResolver {
      */
     readonly options: IResourceResolverOptions;
     /**
-     * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
+     * The readonly qualifier collector that provides qualifier implementations.
+     */
+    get qualifiers(): IReadOnlyQualifierCollector;
+    /**
+     * The resource IDs that this resolver can resolve.
+     */
+    get resourceIds(): ReadonlyArray<ResourceId>;
+    /**
+     * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for
      * the corresponding condition.
      */
@@ -7695,6 +9097,15 @@ export declare class ResourceResolver {
      * @public
      */
     resolveResource(resource: IResource): Result<IResourceCandidate>;
+    /**
+     * Resolves a resource by finding the best matching candidate.
+     * Uses the resource's associated decision to determine the best match based on the current context.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with the best matching candidate if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveResource(resource: string): Result<IResourceCandidate>;
     /**
      * Resolves all matching resource candidates in priority order.
      * Uses the resource's associated decision to determine all matching candidates based on the current context.
@@ -7704,6 +9115,15 @@ export declare class ResourceResolver {
      * @public
      */
     resolveAllResourceCandidates(resource: IResource): Result<ReadonlyArray<IResourceCandidate>>;
+    /**
+     * Resolves all matching resource candidates in priority order.
+     * Uses the resource's associated decision to determine all matching candidates based on the current context.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with an array of all matching candidates in priority order if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveAllResourceCandidates(resource: string): Result<ReadonlyArray<IResourceCandidate>>;
     /**
      * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
      * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
@@ -7714,6 +9134,20 @@ export declare class ResourceResolver {
      * @public
      */
     resolveComposedResourceValue(resource: IResource): Result<JsonValue>;
+    /**
+     * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
+     * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
+     * priority "partial" candidates into it in ascending order of priority.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with the composed JsonValue if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveComposedResourceValue(resource: string): Result<JsonValue>;
+    /**
+     * {@inheritDoc IResourceResolver.withContext}
+     */
+    withContext(context: Record<string, string>): Result<ResourceResolver>;
     /**
      * Clears all caches (condition, condition set, and decision), forcing all cached items
      * to be re-evaluated on next access. This should be called when the context changes and cached
@@ -7801,6 +9235,14 @@ declare namespace Resources {
         ICandidateInfo,
         IReducedCandidate,
         CandidateReducer,
+        ICandidateValue,
+        ICandidateValueCreateParams,
+        CandidateValue,
+        ICandidateValueCollectorCreateParams,
+        CandidateValueCollector,
+        IDeltaGeneratorParams,
+        IDeltaGeneratorOptions,
+        DeltaGenerator,
         IResourceCandidateCreateParams,
         ICandidateDeclOptions,
         ResourceCandidate,
@@ -7861,7 +9303,7 @@ declare const resourceTreeChildNodeDecl: Converter<Normalized.IResourceTreeChild
  * strongly-typed internal tree operations, ensuring type safety and consistent
  * error handling throughout the resource tree navigation.
  *
- * @internal
+ * @public
  */
 declare class ResourceTreeChildrenValidator<T> implements IReadOnlyResourceTreeChildren<T, string, string> {
     private readonly _inner;
@@ -7916,17 +9358,17 @@ declare class ResourceTreeChildrenValidator<T> implements IReadOnlyResourceTreeC
      */
     forEach(cb: (value: unknown, key: string, map: IReadOnlyResultMap<string, unknown>, thisArg?: unknown) => void, arg?: unknown): void;
     /**
-     * Gets a child node by its ResourceName key with detailed error information.
-     * @param key - The ResourceName key to look up
+     * Gets a child node by its string key with detailed error information.
+     * @param key - The string key to look up
      * @returns DetailedResult containing the node if found, or failure with details
      */
-    get(key: ResourceName): DetailedResult<IReadOnlyResourceTreeNode<T>, Collections.ResultMapResultDetail>;
+    get(key: string): DetailedResult<IReadOnlyResourceTreeNode<T>, Collections.ResultMapResultDetail>;
     /**
-     * Checks if a child node exists at the given ResourceName key.
-     * @param key - The ResourceName key to check
+     * Checks if a child node exists at the given string key.
+     * @param key - The string key to check
      * @returns True if a child node exists at the key, false otherwise
      */
-    has(key: ResourceName): boolean;
+    has(key: string): boolean;
     /**
      * Returns an iterator of ResourceName keys for all child nodes.
      * @returns Map iterator for all child node keys
@@ -7950,6 +9392,111 @@ declare class ResourceTreeChildrenValidator<T> implements IReadOnlyResourceTreeC
  */
 declare type ResourceTreeNodeInit<T> = IResourceTreeLeafInit<T> | IResourceTreeBranchInit<T>;
 
+/**
+ * Specialized resolver for resource tree operations, providing enhanced APIs for
+ * resolving entire resource trees from either resource IDs or pre-built tree nodes.
+ *
+ * This class provides a clean separation between individual resource resolution
+ * (handled by ResourceResolver) and tree-based operations, with support for
+ * lazy tree construction and enhanced error handling.
+ *
+ * @public
+ */
+declare class ResourceTreeResolver {
+    /**
+     * The {@link Runtime.ResourceResolver | ResourceResolver} to use for individual resource resolution
+     */
+    readonly resolver: ResourceResolver;
+    /**
+     * The {@link Runtime.IResourceManager | IResourceManager} to use for lazy tree construction.
+     * @internal
+     */
+    private readonly _resourceManager;
+    /**
+     * The built resource tree, lazily built on first access.
+     * @internal
+     */
+    private _tree?;
+    /**
+     * Creates a {@link Runtime.ResourceTreeResolver | ResourceTreeResolver} instance.
+     * @param resolver - The ResourceResolver to use for individual resource resolution
+     */
+    constructor(resolver: ResourceResolver);
+    /**
+     * Creates a {@link Runtime.ResourceTreeResolver | ResourceTreeResolver} instance.
+     * @param resolver - The ResourceResolver to use for individual resource resolution
+     */
+    static create(resolver: ResourceResolver): Result<ResourceTreeResolver>;
+    /**
+     * Gets the built resource tree, building it lazily on first access.
+     * @returns The resource tree root
+     * @throws Error if no resource manager was provided or tree building fails
+     * @public
+     */
+    get tree(): IReadOnlyResourceTreeRoot<IResource>;
+    /**
+     * Resolves a resource tree from a resource ID, building the tree lazily from the resource manager.
+     * @param resourceId - The ID of the root resource to resolve
+     * @param options - Optional configuration for error handling during resolution
+     * @returns Success with the composed JsonObject or undefined, or Failure with error message
+     * @public
+     */
+    resolveComposedResourceTree(resourceId: string, options?: IResolveResourceTreeOptions): Result<JsonObject | undefined>;
+    /**
+     * Resolves a pre-built resource tree node.
+     * @param node - The resource tree node to resolve
+     * @param options - Optional configuration for error handling during resolution
+     * @returns Success with the composed JsonObject or undefined, or Failure with error message
+     * @public
+     */
+    resolveComposedResourceTree(node: IReadOnlyResourceTreeNode<IResource>, options?: IResolveResourceTreeOptions): Result<JsonObject | undefined>;
+    private _getTree;
+    /**
+     * Resolves a tree from a resource ID by first building the tree from the resource manager.
+     * @internal
+     */
+    private _resolveFromResourceId;
+    /**
+     * Resolves a pre-built tree node using the extracted tree resolution logic.
+     * @internal
+     */
+    private _resolveFromTreeNode;
+    /**
+     * Handles resource resolution errors according to the specified mode.
+     * @param resource - The resource that failed to resolve
+     * @param message - The error message from the failed resolution
+     * @param mode - The error handling mode
+     * @param path - The path to the resource in the tree (for error context)
+     * @internal
+     */
+    private _handleResourceError;
+    /**
+     * Handles empty branch nodes according to the specified mode.
+     * @param node - The empty branch node
+     * @param failedChildren - Names of children that failed to resolve
+     * @param mode - The empty branch handling mode
+     * @param path - The path to the branch in the tree (for error context)
+     * @internal
+     */
+    private _handleEmptyBranch;
+    /**
+     * Processes a leaf node by resolving its resource value.
+     * @param node - The leaf node to process (must be a leaf node)
+     * @param path - The path to the node in the tree
+     * @param resourceErrorMode - How to handle resource resolution errors
+     * @internal
+     */
+    private _processLeafNode;
+    /**
+     * Processes a branch node by recursively resolving all its children.
+     * @param node - The branch node to process (must be a branch node)
+     * @param path - The path to the node in the tree
+     * @param options - Resolution options
+     * @internal
+     */
+    private _processBranchNode;
+}
+
 /**
  * `Converter` for a normalized {@link ResourceJson.Normalized.IResourceTreeRootDecl | resource tree root declaration}.
  * @public
@@ -7962,17 +9509,22 @@ declare const resourceTreeRootDecl: Converter<Normalized.IResourceTreeRootDecl>;
  * resource value.
  * @public
  */
-export declare abstract class ResourceType<T = unknown> implements ICollectible<ResourceTypeName, ResourceTypeIndex> {
+export declare abstract class ResourceType<T = unknown> implements IResourceType<T> {
     private _collectible;
+    private _template;
     /**
-     * The key for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.key}
      */
     get key(): ResourceTypeName;
     /**
-     * The index for this resource type.
+     * Name of the underlying system type.
+     */
+    abstract readonly systemTypeName: ResourceTypeName;
+    /**
+     * {@inheritdoc ResourceTypes.IResourceType.index}
      */
     get index(): ResourceTypeIndex | undefined;
-    protected constructor(key: ResourceTypeName, index?: number);
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject);
     /**
      * Validates properties of a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
      * a resource instance value.
@@ -8022,6 +9574,25 @@ export declare abstract class ResourceType<T = unknown> implements ICollectible<
      * Sets the index for this resource type.  Once set, the index cannot be changed.
      */
     setIndex(index: number): Result<ResourceTypeIndex>;
+    /**
+     * Creates a template for a new resource of this type.
+     * Default implementation provides a basic template.
+     * Subclasses can override to provide type-specific templates.
+     * @param resourceId - The id for the new resource
+     * @param init - An optional initial value for the resource.
+     * @param conditions - An optional set of conditions that must be met for the resource to be selected.
+     * @param resolver - An optional resource resolver that can be used to create the template.
+     * @returns A loose resource declaration with default values for this resource type
+     * @public
+     */
+    createTemplate(resourceId: ResourceId, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
+    /**
+     * Gets the default template value for this resource type.
+     * Subclasses should override this to provide type-specific default values.
+     * @returns The default JSON value for a new resource of this type
+     * @public
+     */
+    getDefaultTemplateCandidate(json?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, __resolver?: IResourceResolver): Result<ResourceJson.Json.IChildResourceCandidateDecl>;
 }
 
 /**
@@ -8045,7 +9616,30 @@ declare class ResourceTypeCollector extends ValidatingCollector<ResourceType> {
  * @returns A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
  * @public
  */
-declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig, unknown>;
+declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig<JsonObject>, unknown>;
+
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
+ * @public
+ */
+declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
+    /**
+     * Constructor for a resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+}
+
+/**
+ * Function signature for creating a resource type from configuration.
+ * @public
+ */
+declare type ResourceTypeFactoryFunction = (config: ResourceTypes.Config.IResourceTypeConfig) => Result<ResourceType>;
 
 /**
  * Branded number representing a validated resource type index.
@@ -8075,6 +9669,7 @@ declare namespace ResourceTypes {
     export {
         Config_3 as Config,
         IResourceCandidateValidationProperties,
+        IResourceType,
         ResourceType,
         IResourceCollectorCreateParams,
         ResourceTypeCollector,
@@ -8118,6 +9713,10 @@ declare namespace Runtime {
         IResourceResolverOptions,
         IResourceResolverCreateParams,
         ResourceResolver,
+        ResourceErrorHandler,
+        EmptyBranchHandler,
+        IResolveResourceTreeOptions,
+        ResourceTreeResolver,
         ConditionMatchType,
         IConditionMatchResult,
         ConditionSetResolutionResult,
@@ -8133,6 +9732,14 @@ declare namespace Runtime {
 }
 export { Runtime }
 
+/**
+ * Create a safe filename by removing invalid characters
+ * @param filename - Original filename
+ * @returns Sanitized filename
+ * @public
+ */
+declare function sanitizeFilename(filename: string): string;
+
 /**
  * @internal
  */
@@ -8143,7 +9750,12 @@ declare const segmentedIdentifier: RegExp;
  * using a `ResultMap` for qualifier value storage.
  * @public
  */
-declare class SimpleContextQualifierProvider extends ContextQualifierProvider {
+declare class SimpleContextQualifierProvider extends ContextQualifierProvider implements IMutableContextQualifierProvider {
+    /**
+     * Explicit mutability marker for compile-time type discrimination.
+     * Always `true` for mutable providers.
+     */
+    readonly mutable: true;
     /**
      * The readonly qualifier collector that defines and validates the qualifiers for this context.
      */
@@ -8221,6 +9833,14 @@ declare class SimpleContextQualifierProvider extends ContextQualifierProvider {
      * @public
      */
     clear(): void;
+    /**
+     * Resolves a qualifier from a name, index, or qualifier object.
+     * @param nameOrIndexOrQualifier - The input to resolve.
+     * @returns `Success` with the {@link Qualifier | qualifier} if successful,
+     * or `Failure` with an error message if not found or invalid.
+     * @internal
+     */
+    private _resolveQualifier;
     /**
      * Resolves a qualifier name from a name, index, or qualifier object.
      * @param nameOrIndexOrQualifier - The input to resolve.
@@ -8229,6 +9849,14 @@ declare class SimpleContextQualifierProvider extends ContextQualifierProvider {
      * @internal
      */
     private _resolveQualifierName;
+    /**
+     * Resolves a qualifier name from a qualifier-like object.
+     * @param nameOrIndexOrQualifier - The input to resolve.
+     * @returns `Success` with the {@link QualifierName | qualifier name} if successful,
+     * or `Failure` with an error message if not found or invalid.
+     * @internal
+     */
+    private static _qualifierNameFromQualifierLike;
 }
 
 /**
@@ -8274,7 +9902,7 @@ declare class SystemConfiguration {
      * @param config - The {@link Config.Model.ISystemConfiguration | system configuration} to use.
      * @public
      */
-    protected constructor(config: ISystemConfiguration);
+    protected constructor(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams);
     /**
      * Creates a new {@link Config.SystemConfiguration | SystemConfiguration} from the supplied
      * {@link Config.Model.ISystemConfiguration | system configuration}.
@@ -8285,6 +9913,14 @@ declare class SystemConfiguration {
      * @public
      */
     static create(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
+    /**
+     * Loads a {@link Config.SystemConfiguration | SystemConfiguration} from a file.
+     * @param path - The path to the file to load.
+     * @returns `Success` with the {@link Config.SystemConfiguration | SystemConfiguration}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static loadFromFile(path: string, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
     /**
      * Returns the {@link Config.Model.ISystemConfiguration | system configuration} that this
      * {@link Config.SystemConfiguration | SystemConfiguration} was created from.
@@ -8302,6 +9938,13 @@ declare class SystemConfiguration {
  */
 declare const systemConfiguration: ObjectConverter<ISystemConfiguration, unknown>;
 
+/**
+ * Validator for system configuration (delegates to config packlet)
+ * This validates that the parsed JSON conforms to the system configuration schema
+ * @public
+ */
+declare const systemConfiguration_2: Validator<Model.ISystemConfiguration>;
+
 /**
  * A `Converter` for {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | SystemLanguageQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | SystemLanguageQualifierTypeConfig} objects.
@@ -8316,6 +9959,14 @@ declare const systemLanguageQualifierTypeConfig: ObjectConverter<Model_2.ISystem
  */
 declare const systemLiteralQualifierTypeConfig: ObjectConverter<Model_2.ISystemLiteralQualifierTypeConfig, unknown>;
 
+/**
+ * A discriminated union of all system qualifier types.
+ * This allows TypeScript to properly discriminate between specific qualifier type implementations
+ * and access their specific methods like getConfiguration().
+ * @public
+ */
+declare type SystemQualifierType = LanguageQualifierType | TerritoryQualifierType | LiteralQualifierType;
+
 /**
  * A `Converter` for {@link QualifierTypes.Config.ISystemQualifierTypeConfig | SystemQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ISystemQualifierTypeConfig | SystemQualifierTypeConfig} objects.
@@ -8359,7 +10010,11 @@ declare const TerritoryPrioritySystemConfiguration: ISystemConfiguration;
  * implementation handles incorrect casing.
  * @public
  */
-declare class TerritoryQualifierType extends QualifierType {
+declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config_2.ITerritoryQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Optional array enumerating allowed territories to further constrain the type.
      */
@@ -8401,6 +10056,27 @@ declare class TerritoryQualifierType extends QualifierType {
      * @public
      */
     static createFromConfig(config: Config_2.IQualifierTypeConfig<Config_2.ITerritoryQualifierTypeConfig>): Result<TerritoryQualifierType>;
+    /**
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config_2.ISystemTerritoryQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config_2.ISystemTerritoryQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
@@ -8433,6 +10109,26 @@ declare class TerritoryQualifierType extends QualifierType {
  */
 declare const territoryQualifierTypeConfig: ObjectConverter<Model_2.ITerritoryQualifierTypeConfig, unknown>;
 
+/**
+ * Converts a number to a {@link CandidateValueIndex | candidate value index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toCandidateValueIndex(index: number): Result<CandidateValueIndex>;
+
+/**
+ * Converts a string to a {@link CandidateValueKey | candidate value key}.
+ *
+ * @param key - The key to convert.
+ * @returns `Success` with the converted key if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+declare function toCandidateValueKey(key: string): Result<CandidateValueKey>;
+
 /**
  * Converts a number to a {@link ConditionIndex} if it is a valid condition index.
  * @param index - the number to convert
@@ -8560,6 +10256,15 @@ declare function toDecisionKey(key: string): Result<DecisionKey>;
  */
 declare function toOptionalResourceId(id?: string): Result<ResourceId | undefined>;
 
+/**
+ * Converts a string to a {@link QualifierContextValue} if it is a valid qualifier context value.
+ * @param value - the string to convert
+ * @returns `Success` with the converted {@link QualifierContextValue} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+declare function toQualifierContextValue(value: string): Result<QualifierContextValue>;
+
 /**
  * Converts a string to a {@link QualifierDefaultValuesToken} if it is a valid qualifier default values token.
  * @param token - the string to convert
@@ -8703,7 +10408,9 @@ declare namespace Validate {
         isValidConditionSetHash,
         isValidDecisionKey,
         isValidDecisionIndex,
+        isValidQualifierContextValue,
         toQualifierName,
+        toQualifierContextValue,
         toQualifierIndex,
         toQualifierTypeName,
         toQualifierTypeIndex,
@@ -8732,12 +10439,16 @@ declare namespace Validate {
         isValidResourceIndex,
         isValidResourceTypeName,
         isValidResourceTypeIndex,
+        isValidCandidateValueIndex,
+        isValidCandidateValueKey,
         toResourceName,
         toResourceId,
         toOptionalResourceId,
         toResourceIndex,
         toResourceTypeName,
-        toResourceTypeIndex
+        toResourceTypeIndex,
+        toCandidateValueKey,
+        toCandidateValueIndex
     }
 }
 export { Validate }
@@ -8782,19 +10493,107 @@ declare const validatedContextQualifierValueDecl: Converter<IValidatedContextQua
  */
 declare const validatedQualifierDecl: Converter<IValidatedQualifierDecl, IQualifierDeclConvertContext>;
 
+/**
+ * Validate a {@link Config.Model.ISystemConfiguration | ISystemConfiguration} object.
+ * @param config - The system configuration to validate
+ * @returns `Success` with the validated system configuration if successful,
+ * or `Failure` with an error message if validation fails.
+ * @public
+ */
+declare function validateSystemConfiguration(config: unknown): Result<ISystemConfiguration>;
+
+/**
+ * Validate a ZIP archive manifest object
+ * @param manifest - Object to validate as manifest
+ * @returns Result containing validated manifest
+ * @public
+ */
+declare function validateZipArchiveManifest(manifest: unknown): Result<Json_2.IZipArchiveManifest>;
+
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+declare class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType> implements IConfigInitFactory<unknown, T | SystemQualifierType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config: unknown): Result<T | SystemQualifierType>;
+}
+
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+declare class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config: unknown): Result<ResourceType>;
+}
+
 /**
  * A {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} with a
- * {@link Runtime.Context.ContextQualifierProviderValidator | validator} property that enables
+ * {@link Runtime.Context.MutableContextQualifierProviderValidator | validator} property that enables
  * validated use of the underlying provider with string keys and values.
  * This eliminates the need for type casting in consumer code.
  * @public
  */
 declare class ValidatingSimpleContextQualifierProvider extends SimpleContextQualifierProvider {
     /**
-     * A {@link Runtime.Context.ContextQualifierProviderValidator | ContextQualifierProviderValidator} which validates
+     * A {@link Runtime.Context.MutableContextQualifierProviderValidator | MutableContextQualifierProviderValidator} which validates
      * string inputs before passing them to this provider.
      */
-    readonly validating: IReadOnlyContextQualifierProviderValidator;
+    readonly validating: IMutableContextQualifierProviderValidator;
     /**
      * Constructor for a {@link Runtime.ValidatingSimpleContextQualifierProvider | ValidatingSimpleContextQualifierProvider} object.
      * @param params - {@link Runtime.IValidatingSimpleContextQualifierProviderCreateParams | Parameters} used to create the provider.
@@ -8810,4 +10609,194 @@ declare class ValidatingSimpleContextQualifierProvider extends SimpleContextQual
     static create(params: IValidatingSimpleContextQualifierProviderCreateParams): Result<ValidatingSimpleContextQualifierProvider>;
 }
 
+declare namespace ZipArchive {
+    export {
+        Json_2 as Json,
+        Convert_12 as Convert,
+        ZipArchiveCreator,
+        ZipArchiveLoader,
+        IZipArchivePathOptions,
+        IZipArchiveFileTreeOptions,
+        ZipArchiveOptions,
+        IZipArchiveResult,
+        IZipArchiveManifest_2 as IZipArchiveManifest,
+        IZipArchiveLoadOptions,
+        IZipArchiveLoadResult,
+        IImportedFile_2 as IImportedFile,
+        IImportedDirectory_2 as IImportedDirectory,
+        ZipArchiveProgressCallback,
+        createZipArchiveManifest,
+        parseZipArchiveManifest,
+        validateZipArchiveManifest,
+        parseZipArchiveConfiguration,
+        generateZipArchiveFilename,
+        normalizePath,
+        getDirectoryName,
+        sanitizeFilename,
+        isZipFile,
+        ZipArchiveConstants
+    }
+}
+export { ZipArchive }
+
+/**
+ * Validator for ZIP archive config information
+ * @public
+ */
+declare const zipArchiveConfigInfo: Validator<Json_2.IZipArchiveConfigInfo>;
+
+/**
+ * Validator for ZIP archive config type
+ * @public
+ */
+declare const zipArchiveConfigType: Validator<'file'>;
+
+/**
+ * Constants for ZIP archive structure
+ * @public
+ */
+declare const ZipArchiveConstants: {
+    /** Manifest file name */
+    readonly MANIFEST_FILE: "manifest.json";
+    /** Configuration file name */
+    readonly CONFIG_FILE: "config.json";
+    /** Input files directory */
+    readonly INPUT_DIR: "input";
+    /** Configuration files directory */
+    readonly CONFIG_DIR: "config";
+};
+
+/**
+ * ZIP archive creator using fflate for universal compatibility
+ * @public
+ */
+declare class ZipArchiveCreator {
+    /**
+     * Create a ZIP archive buffer from a supplied buffer
+     * @param options - Input paths and configuration
+     * @param onProgress - Optional progress callback
+     * @returns Result containing ZIP buffer and manifest
+     */
+    createFromBuffer(options: ZipArchiveOptions, onProgress?: ZipArchiveProgressCallback): Promise<Result<IZipArchiveResult>>;
+    /**
+     * Add a single FileTree item to the ZIP archive
+     * @param files - ZIP files collection
+     * @param fileItem - FileTree file item to add
+     * @param archivePath - Path within the archive
+     * @returns Result indicating success or failure
+     */
+    private _addFileTreeItemToZip;
+    /**
+     * Add a directory recursively to the ZIP archive using FileTree
+     * @param files - ZIP files collection
+     * @param directoryItem - FileTree directory item to add
+     * @param archivePrefix - Prefix path within the archive
+     * @param onProgress - Optional progress callback
+     * @returns Result indicating success or failure
+     */
+    private _addDirectoryTreeToZip;
+    private _getInputFileTreeItem;
+    private _getConfigFileTreeItem;
+}
+
+/**
+ * Validator for ZIP archive input information
+ * @public
+ */
+declare const zipArchiveInputInfo: Validator<Json_2.IZipArchiveInputInfo>;
+
+/**
+ * Validator for ZIP archive input type
+ * @public
+ */
+declare const zipArchiveInputType: Validator<'file' | 'directory'>;
+
+/**
+ * ZIP archive loader extending ts-extras foundation
+ * @public
+ */
+declare class ZipArchiveLoader {
+    /**
+     * Load ZIP archive from File object (Browser)
+     * @param file - File object from file input
+     * @param options - Loading options
+     * @param onProgress - Optional progress callback
+     * @returns Result containing loaded archive data
+     */
+    loadFromFile(file: File, options?: IZipArchiveLoadOptions, onProgress?: ZipArchiveProgressCallback): Promise<Result<IZipArchiveLoadResult>>;
+    /**
+     * Load ZIP archive from ArrayBuffer (Universal)
+     * @param buffer - ZIP data buffer
+     * @param options - Loading options
+     * @param onProgress - Optional progress callback
+     * @returns Result containing loaded archive data
+     */
+    loadFromBuffer(buffer: ArrayBuffer, options?: IZipArchiveLoadOptions, onProgress?: ZipArchiveProgressCallback): Promise<Result<IZipArchiveLoadResult>>;
+    /**
+     * Load manifest from ZIP using ZipFileTreeAccessors
+     * @param zipAccessors - ZIP file tree accessors
+     * @returns Result containing parsed manifest
+     */
+    private _loadManifestFromAccessors;
+    /**
+     * Load configuration from ZIP using ZipFileTreeAccessors
+     * @param zipAccessors - ZIP file tree accessors
+     * @param manifest - Parsed manifest (may be undefined)
+     * @param options - Loading options
+     * @returns Result containing parsed configuration
+     */
+    private _loadConfigurationFromAccessors;
+    /**
+     * Extract files and directory structure from ZIP
+     * @param zipAccessors - ZIP file tree accessors
+     * @param onProgress - Optional progress callback
+     * @returns Result containing files and directory structure
+     */
+    private _extractFilesFromAccessors;
+    /**
+     * Recursively process file tree items
+     * @param zipAccessors - ZIP file tree accessors
+     * @param currentPath - Current directory path
+     * @param items - Items to process
+     * @param files - Files collection
+     * @param directories - Directories collection
+     * @param onProgress - Optional progress callback
+     * @param processed - Processing counter
+     */
+    private _processFileTreeItems;
+    /**
+     * Build directory structure from files
+     * @param files - Extracted files
+     * @param directories - Directories map
+     * @returns Root directory structure or null
+     */
+    private _buildDirectoryStructure;
+    /**
+     * Get file MIME type based on extension
+     * @param filename - Filename
+     * @returns MIME type
+     */
+    private _getFileType;
+}
+
+/**
+ * Validator for ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+declare const zipArchiveManifest: Validator<Json_2.IZipArchiveManifest>;
+
+/**
+ * Options for creating a ZIP archive buffer
+ * @public
+ */
+declare type ZipArchiveOptions = IZipArchivePathOptions | IZipArchiveFileTreeOptions;
+
+/**
+ * Progress callback for ZIP operations
+ * @public
+ */
+declare type ZipArchiveProgressCallback = (stage: 'reading-file' | 'parsing-zip' | 'loading-manifest' | 'loading-config' | 'extracting-files' | 'processing-resources' | 'creating-zip', progress: number, // 0-100
+details: string) => void;
+
 export { }