@fgv/ts-res 5.0.0-3 → 5.0.0-30

package/dist/ts-res.d.ts

@@ -1,10 +1,13 @@
 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 { 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 { ObjectConverter } from '@fgv/ts-utils';
@@ -13,6 +16,7 @@ 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
@@ -130,6 +134,13 @@ 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>;
+
 /**
  * Converts an array of {@link Helpers.IConditionTokenParts | condition token parts} into an array of
  * syntactically validated {@link ConditionToken | condition tokens}.
@@ -178,6 +189,283 @@ 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,
+        IBundleExportMetadata,
+        IBundle,
+        IBundleCreateParams,
+        BundleBuilder,
+        BundleLoader,
+        IBundleLoaderCreateParams,
+        BundleUtils,
+        IBundleComponents,
+        Model_4 as Model,
+        Convert_10 as Convert,
+        BundleNormalizer
+    }
+}
+export { Bundle }
+
+/**
+ * `Converter` for a {@link Bundle.IBundle | bundle} object.
+ * @public
+ */
+declare const bundle: Converter<IBundle>;
+
+/**
+ * Builder for creating resource bundles from a ResourceManagerBuilder.
+ * Handles the compilation, configuration extraction, and integrity verification
+ * needed to create a complete, portable bundle.
+ * @public
+ */
+export declare class BundleBuilder {
+    /**
+     * Creates a resource bundle from a ResourceManagerBuilder.
+     * @param builder - The ResourceManagerBuilder containing the resources to bundle
+     * @param systemConfig - The SystemConfiguration used to create the builder
+     * @param params - Optional parameters for bundle creation
+     * @returns Success with the created bundle if successful, Failure with error message otherwise
+     * @public
+     */
+    static create(builder: ResourceManagerBuilder, systemConfig: SystemConfiguration, params?: IBundleCreateParams): Result<IBundle>;
+    /**
+     * Creates a resource bundle from a ResourceManagerBuilder using a predefined system configuration.
+     * This is a convenience method for the common case of using predefined configurations.
+     * @param builder - The ResourceManagerBuilder containing the resources to bundle
+     * @param configName - The name of the predefined system configuration used
+     * @param params - Optional parameters for bundle creation
+     * @returns Success with the created bundle if successful, Failure with error message otherwise
+     * @public
+     */
+    static createFromPredefined(builder: ResourceManagerBuilder, configName: PredefinedSystemConfiguration, params?: IBundleCreateParams): Result<IBundle>;
+    /**
+     * Generates a hash checksum for the compiled resource collection.
+     * The checksum is calculated using the provided hash normalizer.
+     * @param compiledCollection - The compiled resource collection to generate checksum for
+     * @param hashNormalizer - The hash normalizer to use for checksum generation
+     * @returns Success with the checksum string if successful, Failure otherwise
+     * @internal
+     */
+    private static _generateChecksum;
+}
+
+/**
+ * `Converter` for {@link Bundle.IBundleCreateParams | bundle creation parameters}.
+ * @public
+ */
+declare const bundleCreateParams: Converter<IBundleCreateParams>;
+
+/**
+ * `Converter` for {@link Bundle.IBundleExportMetadata | bundle export metadata}.
+ * @public
+ */
+declare const bundleExportMetadata: Converter<IBundleExportMetadata>;
+
+/**
+ * Loader for creating an IResourceManager from a resource bundle.
+ * Handles integrity verification and reconstruction of the runtime resource manager.
+ * @public
+ */
+export declare class BundleLoader {
+    /**
+     * Creates an IResourceManager from a resource bundle.
+     * @param params - Parameters for bundle loading including the bundle and options
+     * @returns Success with the IResourceManager if successful, Failure with error message otherwise
+     * @public
+     */
+    static createManagerFromBundle(params: IBundleLoaderCreateParams): Result<IResourceManager>;
+    /**
+     * Verifies the integrity of a bundle by checking its checksum.
+     * @param bundle - The bundle to verify
+     * @param skipVerification - Whether to skip verification
+     * @param hashNormalizer - The hash normalizer to use for verification
+     * @returns Success if verification passes or is skipped, Failure otherwise
+     * @internal
+     */
+    private static _verifyBundleIntegrity;
+    /**
+     * Generates a hash checksum for the compiled resource collection.
+     * @param compiledCollection - The compiled resource collection to generate checksum for
+     * @param hashNormalizer - The hash normalizer to use for checksum generation
+     * @returns Success with the checksum string if successful, Failure otherwise
+     * @internal
+     */
+    private static _generateChecksum;
+    /**
+     * Creates a SystemConfiguration from the bundle's configuration.
+     * @param bundle - The bundle containing the configuration
+     * @returns Success with the SystemConfiguration if successful, Failure otherwise
+     * @internal
+     */
+    private static _createSystemConfiguration;
+    /**
+     * Creates a CompiledResourceCollection from the bundle.
+     * @param bundle - The bundle to load
+     * @param qualifierTypes - The qualifier type collector from the system configuration
+     * @param resourceTypes - The resource type collector from the system configuration
+     * @returns Success with the CompiledResourceCollection if successful, Failure otherwise
+     * @internal
+     */
+    private static _createCompiledResourceCollection;
+}
+
+/**
+ * `Converter` for a {@link Bundle.IBundleMetadata | bundle metadata} object.
+ * @public
+ */
+declare const bundleMetadata: Converter<IBundleMetadata>;
+
+/**
+ * Normalizes ResourceManagerBuilder instances to ensure consistent ordering
+ * of internal entities, enabling order-independent bundle checksums.
+ *
+ * The normalization process rebuilds the ResourceManagerBuilder from the ground up
+ * in a canonical order to ensure identical index assignments regardless of
+ * original construction order.
+ * @public
+ */
+declare class BundleNormalizer {
+    /**
+     * Creates a normalized ResourceManagerBuilder from an existing builder.
+     * The normalized builder will have identical entities but arranged in
+     * canonical order to ensure consistent index assignments.
+     *
+     * @param originalBuilder - The ResourceManagerBuilder to normalize
+     * @param systemConfig - The SystemConfiguration used to create the original builder
+     * @returns Success with the normalized ResourceManagerBuilder if successful, Failure otherwise
+     */
+    static normalize(originalBuilder: ResourceManagerBuilder, systemConfig: SystemConfiguration): Result<ResourceManagerBuilder>;
+    /**
+     * Creates a normalized ResourceManagerBuilder using a predefined system configuration.
+     * This is a convenience method for the common case of using predefined configurations.
+     *
+     * @param originalBuilder - The ResourceManagerBuilder to normalize
+     * @param configName - The name of the predefined system configuration used
+     * @returns Success with the normalized ResourceManagerBuilder if successful, Failure otherwise
+     */
+    static normalizeFromPredefined(originalBuilder: ResourceManagerBuilder, configName: PredefinedSystemConfiguration): Result<ResourceManagerBuilder>;
+    /**
+     * Normalizes all conditions from the original builder by adding them to the
+     * normalized builder in sorted order using loose condition declarations.
+     *
+     * @param originalBuilder - The source ResourceManagerBuilder
+     * @param normalizedBuilder - The target normalized ResourceManagerBuilder
+     * @returns Success if all conditions were normalized successfully, Failure otherwise
+     * @internal
+     */
+    private static _normalizeConditions;
+    /**
+     * Normalizes all condition sets from the original builder by adding them to the
+     * normalized builder in sorted order using loose condition set declarations.
+     *
+     * @param originalBuilder - The source ResourceManagerBuilder
+     * @param normalizedBuilder - The target normalized ResourceManagerBuilder
+     * @returns Success if all condition sets were normalized successfully, Failure otherwise
+     * @internal
+     */
+    private static _normalizeConditionSets;
+    /**
+     * Normalizes all candidates by sorting them first by resource ID, then by condition set.
+     *
+     * @param originalBuilder - The source ResourceManagerBuilder
+     * @param normalizedBuilder - The target normalized ResourceManagerBuilder
+     * @returns Success if all candidates were normalized successfully, Failure otherwise
+     * @internal
+     */
+    private static _normalizeCandidates;
+    /**
+     * Adds normalized resources to the target builder by first normalizing conditions,
+     * then condition sets, then candidates.
+     *
+     * @param originalBuilder - The source ResourceManagerBuilder
+     * @param normalizedBuilder - The target normalized ResourceManagerBuilder
+     * @returns Success if all resources were added successfully, Failure otherwise
+     * @internal
+     */
+    private static _addNormalizedResources;
+}
+
+/**
+ * Lightweight converter for bundle structure validation without full processing.
+ * Useful for detecting bundle files without the overhead of full validation.
+ * @public
+ */
+declare const bundleStructure: Converter<{
+    metadata: IBundleMetadata;
+    config: unknown;
+    compiledCollection: unknown;
+}>;
+
+/**
+ * Utility functions for working with resource bundles.
+ * Provides reusable logic for bundle detection, parsing, and component extraction.
+ * @public
+ */
+declare class BundleUtils {
+    /**
+     * Checks if the given object appears to be a bundle file by examining its structure.
+     * This is a lightweight check that doesn't perform full validation.
+     * @param data - The data to check
+     * @returns True if the data appears to be a bundle structure
+     * @public
+     */
+    static isBundleFile(data: unknown): boolean;
+    /**
+     * Extracts and validates components from a bundle for reuse.
+     * Performs full validation of the bundle structure and creates typed components.
+     * @param bundleData - The raw bundle data to extract components from
+     * @returns Success with bundle components if valid, Failure with error message otherwise
+     * @public
+     */
+    static extractBundleComponents(bundleData: unknown): Result<IBundleComponents>;
+    /**
+     * Extracts just the metadata from potential bundle data without full validation.
+     * Useful for displaying bundle information without processing the entire bundle.
+     * @param data - The data to extract metadata from
+     * @returns Success with metadata if found and valid, Failure otherwise
+     * @public
+     */
+    static extractBundleMetadata(data: unknown): Result<IBundleMetadata>;
+    /**
+     * Parses bundle data from a JSON string.
+     * Convenience method that combines JSON parsing with bundle component extraction.
+     * @param jsonString - The JSON string containing bundle data
+     * @returns Success with bundle components if valid, Failure with error message otherwise
+     * @public
+     */
+    static parseBundleFromJson(jsonString: string): Result<IBundleComponents>;
+    /**
+     * Checks if a file name suggests it might be a bundle file.
+     * This is a heuristic check based on file naming conventions.
+     * @param fileName - The file name to check
+     * @returns True if the file name suggests a bundle file
+     * @public
+     */
+    static isBundleFileName(fileName: string): boolean;
+}
+
 /**
  * Simple implementation of {@link Decisions.ICandidate | ICandidate} with
  * helper methods for sorting and presentation.
@@ -227,6 +515,15 @@ declare class Candidate<TVALUE extends JsonValue = JsonValue> implements ICandid
  */
 declare type CandidateAction = 'unchanged' | 'reduced' | 'suppressed';
 
+/**
+ * The completeness of a resource candidate value.  A full value is one that
+ * contains all of the required properties for the resource type.  A partial
+ * value is one that contains some of the required properties for the resource
+ * type.
+ * @public
+ */
+export declare type CandidateCompleteness = 'full' | 'partial';
+
 /**
  * Manages candidate reduction logic for filtering and qualifier reduction operations.
  * Encapsulates the state and logic needed to consistently process candidates for reduction.
@@ -292,6 +589,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
@@ -402,13 +832,17 @@ declare namespace Common {
         ResourceTypeName,
         ResourceTypeIndex,
         ResourceValueMergeMethod,
-        allResourceValueMergeMethods
+        allResourceValueMergeMethods,
+        CandidateCompleteness,
+        CandidateValueIndex,
+        CandidateValueKey,
+        IResourceResolver
     }
 }
 
 declare namespace Compiled {
     export {
-        Convert_3 as Convert,
+        Convert_6 as Convert,
         ICompiledResourceOptions,
         ICompiledConditionMetadata,
         ICompiledConditionSetMetadata,
@@ -429,61 +863,61 @@ declare namespace Compiled {
  * Converter for a {@link ResourceJson.Compiled.ICompiledAbstractDecision | compiled abstract decision}.
  * @public
  */
-declare const compiledAbstractDecision: ObjectConverter<Model.ICompiledAbstractDecision, unknown>;
+declare const compiledAbstractDecision: ObjectConverter<Model_3.ICompiledAbstractDecision, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledCandidate | compiled candidate}.
  * @public
  */
-declare const compiledCandidate: ObjectConverter<Model.ICompiledCandidate, unknown>;
+declare const compiledCandidate: ObjectConverter<Model_3.ICompiledCandidate, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledCondition | compiled condition}.
  * @public
  */
-declare const compiledCondition: ObjectConverter<Model.ICompiledCondition, unknown>;
+declare const compiledCondition: ObjectConverter<Model_3.ICompiledCondition, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledConditionMetadata | compiled condition metadata}.
  * @public
  */
-declare const compiledConditionMetadata: ObjectConverter<Model.ICompiledConditionMetadata, unknown>;
+declare const compiledConditionMetadata: ObjectConverter<Model_3.ICompiledConditionMetadata, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSet | compiled condition set}.
  * @public
  */
-declare const compiledConditionSet: ObjectConverter<Model.ICompiledConditionSet, unknown>;
+declare const compiledConditionSet: ObjectConverter<Model_3.ICompiledConditionSet, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSetMetadata | compiled condition set metadata}.
  * @public
  */
-declare const compiledConditionSetMetadata: ObjectConverter<Model.ICompiledConditionSetMetadata, unknown>;
+declare const compiledConditionSetMetadata: ObjectConverter<Model_3.ICompiledConditionSetMetadata, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledDecisionMetadata | compiled decision metadata}.
  * @public
  */
-declare const compiledDecisionMetadata: ObjectConverter<Model.ICompiledDecisionMetadata, unknown>;
+declare const compiledDecisionMetadata: ObjectConverter<Model_3.ICompiledDecisionMetadata, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledQualifier | compiled qualifier}.
  * @public
  */
-declare const compiledQualifier: ObjectConverter<Model.ICompiledQualifier, unknown>;
+declare const compiledQualifier: ObjectConverter<Model_3.ICompiledQualifier, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledQualifierType | compiled qualifier type}.
  * @public
  */
-declare const compiledQualifierType: ObjectConverter<Model.ICompiledQualifierType, unknown>;
+declare const compiledQualifierType: ObjectConverter<Model_3.ICompiledQualifierType, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledResource | compiled resource}.
  * @public
  */
-declare const compiledResource: ObjectConverter<Model.ICompiledResource, unknown>;
+declare const compiledResource: ObjectConverter<Model_3.ICompiledResource, unknown>;
 
 /**
  * A compiled resource collection implements {@link Runtime.IResourceManager | IResourceManager}
@@ -491,30 +925,35 @@ declare const compiledResource: ObjectConverter<Model.ICompiledResource, unknown
  * 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;
     /**
      * 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}
      */
@@ -563,7 +1002,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
@@ -612,6 +1051,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
@@ -628,13 +1073,13 @@ declare class CompiledResourceCollection implements IResourceManager {
  * This combines all the individual converters into a single converter for the entire resource collection.
  * @public
  */
-declare const compiledResourceCollection: ObjectConverter<Model.ICompiledResourceCollection, unknown>;
+declare const compiledResourceCollection: ObjectConverter<Model_3.ICompiledResourceCollection, unknown>;
 
 /**
  * Converter for a {@link ResourceJson.Compiled.ICompiledResourceType | compiled resource type}.
  * @public
  */
-declare const compiledResourceType: ObjectConverter<Model.ICompiledResourceType, unknown>;
+declare const compiledResourceType: ObjectConverter<Model_3.ICompiledResourceType, unknown>;
 
 /**
  * A {@link Decisions.ConcreteDecision | concrete decision} is a {@link Decisions.IDecision | decision}
@@ -685,7 +1130,7 @@ declare class ConcreteDecision<TVALUE extends JsonValue = JsonValue> implements
  * Represents a single condition applied to some resource instance.
  * @public
  */
-declare class Condition implements IValidatedConditionDecl {
+export declare class Condition implements IValidatedConditionDecl {
     /**
      * The {@link Qualifiers.Qualifier | qualifier} used in this condition.
      */
@@ -932,7 +1377,7 @@ declare const conditionPriority: Converter<ConditionPriority, unknown>;
 
 declare namespace Conditions {
     export {
-        Convert_2 as Convert,
+        Convert_11 as Convert,
         Condition,
         IConditionCollectorCreateParams,
         ConditionCollector,
@@ -956,7 +1401,7 @@ export { Conditions }
  * context for a resource instance to be valid.
  * @public
  */
-declare class ConditionSet implements IValidatedConditionSetDecl {
+export declare class ConditionSet implements IValidatedConditionSetDecl {
     protected readonly _collectible: Collections.Collectible<ConditionSetKey, ConditionSetIndex>;
     /**
      * The {@link Conditions.Condition | conditions} that make up this condition
@@ -1026,6 +1471,14 @@ 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.
@@ -1120,10 +1573,10 @@ declare class ConditionSetCollector extends ValidatingCollector<ConditionSet> {
 declare type ConditionSetDecl = ConditionSetDeclAsArray | ConditionSetDeclAsRecord;
 
 /**
- * Converter which converts to a {@link Conditions.IConditionSetDecl | condition set declaration}.
+ * `Converter` for a normalized {@link ResourceJson.Normalized.ConditionSetDecl | condition set declaration}.
  * @public
  */
-declare const conditionSetDecl: ObjectConverter<IConditionSetDecl, unknown>;
+declare const conditionSetDecl: Converter<Normalized.ConditionSetDecl>;
 
 /**
  * Normalized non-validated declaration of a {@link Conditions.Condition | condition}.
@@ -1132,10 +1585,10 @@ declare const conditionSetDecl: ObjectConverter<IConditionSetDecl, unknown>;
 declare type ConditionSetDecl_2 = ReadonlyArray<ILooseConditionDecl>;
 
 /**
- * `Converter` for a normalized {@link ResourceJson.Normalized.ConditionSetDecl | condition set declaration}.
+ * Converter which converts to a {@link Conditions.IConditionSetDecl | condition set declaration}.
  * @public
  */
-declare const conditionSetDecl_2: Converter<Normalized.ConditionSetDecl>;
+declare const conditionSetDecl_2: ObjectConverter<IConditionSetDecl, unknown>;
 
 /**
  * Non-validated declaration of a {@link Conditions.Condition | condition}.
@@ -1373,8 +1826,20 @@ declare class ConditionTokens {
 
 declare namespace Config {
     export {
-        Model_2 as Model,
-        Convert_10 as Convert,
+        Model,
+        Convert_9 as Convert,
+        createQualifierTypeFactory,
+        createResourceTypeFactory,
+        QualifierTypeFactoryFunction,
+        ResourceTypeFactoryFunction,
+        IConfigInitFactory,
+        ChainedConfigInitFactory,
+        BuiltInQualifierTypeFactory,
+        QualifierTypeFactory,
+        ValidatingQualifierTypeFactory,
+        BuiltInResourceTypeFactory,
+        ResourceTypeFactory,
+        ValidatingResourceTypeFactory,
         updateSystemConfigurationQualifierDefaultValues,
         ISystemConfigurationInitParams,
         SystemConfiguration,
@@ -1390,21 +1855,24 @@ export { Config }
 
 declare namespace Config_2 {
     export {
-        Convert_6 as Convert,
+        Convert_2 as Convert,
+        isSystemQualifierTypeConfig,
         IQualifierTypeConfig,
         ILanguageQualifierTypeConfig,
+        LiteralValueHierarchyDecl,
         ITerritoryQualifierTypeConfig,
         ILiteralQualifierTypeConfig,
         ISystemLanguageQualifierTypeConfig,
         ISystemTerritoryQualifierTypeConfig,
         ISystemLiteralQualifierTypeConfig,
-        ISystemQualifierTypeConfig
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
     }
 }
 
 declare namespace Config_3 {
     export {
-        Convert_9 as Convert,
+        Convert_5 as Convert,
         IResourceTypeConfig
     }
 }
@@ -1417,7 +1885,7 @@ declare const containerContextDecl: Converter<Normalized.IContainerContextDecl>;
 
 declare namespace Context {
     export {
-        Convert_5 as Convert,
+        Convert_8 as Convert,
         IContextMatchOptions,
         IContextQualifierValueDecl,
         IContextDecl,
@@ -1749,6 +2217,8 @@ declare namespace Convert {
         resourceIndex,
         resourceTypeName,
         resourceTypeIndex,
+        candidateValueKey,
+        candidateValueIndex,
         resourceValueMergeMethod,
         contextQualifierToken,
         contextToken,
@@ -1760,44 +2230,100 @@ export { Convert }
 
 declare namespace Convert_10 {
     export {
-        systemConfiguration,
-        predefinedSystemConfiguration
+        bundleMetadata,
+        bundleExportMetadata,
+        bundle,
+        bundleCreateParams,
+        bundleStructure
     }
 }
 
-declare namespace Convert_2 {
+declare namespace Convert_11 {
     export {
         conditionDecl,
         IConditionDeclConvertContext,
         validatedConditionDecl,
-        conditionSetDecl,
+        conditionSetDecl_2 as conditionSetDecl,
         IConditionSetDeclConvertContext,
         validatedConditionSetDecl
     }
 }
 
+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,
+        jsonQualifierTypeConfig,
+        anyQualifierTypeConfig
+    }
+}
+
 declare namespace Convert_3 {
     export {
-        compiledConditionMetadata,
-        compiledConditionSetMetadata,
-        compiledDecisionMetadata,
-        compiledQualifierType,
-        compiledQualifier,
-        compiledResourceType,
-        compiledCondition,
-        compiledConditionSet,
-        compiledAbstractDecision,
-        compiledCandidate,
-        compiledResource,
-        compiledResourceCollection
+        literalValueHierarchyCreateParams,
+        IQualifierTypeConvertContext,
+        qualifierType
     }
 }
 
 declare namespace Convert_4 {
+    export {
+        qualifierDecl,
+        IQualifierDeclConvertContext,
+        validatedQualifierDecl,
+        IQualifierConvertContext,
+        qualifier
+    }
+}
+
+declare namespace Convert_5 {
+    export {
+        resourceTypeConfig
+    }
+}
+
+declare namespace Convert_6 {
+    export {
+        compiledConditionMetadata,
+        compiledConditionSetMetadata,
+        compiledDecisionMetadata,
+        compiledQualifierType,
+        compiledQualifier,
+        compiledResourceType,
+        compiledCondition,
+        compiledConditionSet,
+        compiledAbstractDecision,
+        compiledCandidate,
+        compiledResource,
+        compiledResourceCollection
+    }
+}
+
+declare namespace Convert_7 {
     export {
         looseConditionDecl,
         childConditionDecl,
-        conditionSetDecl_2 as conditionSetDecl,
+        conditionSetDecl,
         looseResourceCandidateDecl,
         importerResourceCandidateDecl,
         childResourceCandidateDecl,
@@ -1811,7 +2337,7 @@ declare namespace Convert_4 {
     }
 }
 
-declare namespace Convert_5 {
+declare namespace Convert_8 {
     export {
         contextQualifierValueDecl,
         contextDecl,
@@ -1821,42 +2347,22 @@ declare namespace Convert_5 {
     }
 }
 
-declare namespace Convert_6 {
-    export {
-        languageQualifierTypeConfig,
-        territoryQualifierTypeConfig,
-        literalQualifierTypeConfig,
-        systemLanguageQualifierTypeConfig,
-        systemTerritoryQualifierTypeConfig,
-        systemLiteralQualifierTypeConfig,
-        systemQualifierTypeConfig
-    }
-}
-
-declare namespace Convert_7 {
-    export {
-        literalValueHierarchyCreateParams,
-        IQualifierTypeConvertContext,
-        qualifierType
-    }
-}
-
-declare namespace Convert_8 {
-    export {
-        qualifierDecl,
-        IQualifierDeclConvertContext,
-        validatedQualifierDecl,
-        IQualifierConvertContext,
-        qualifier
-    }
-}
-
 declare namespace Convert_9 {
     export {
-        resourceTypeConfig
+        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
@@ -1867,19 +2373,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.
@@ -1891,11 +2405,22 @@ 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
  */
-declare class Decision<TVALUE extends JsonValue = JsonValue> implements IDecision<TVALUE> {
+export declare class Decision<TVALUE extends JsonValue = JsonValue> implements IDecision<TVALUE> {
     /**
      * The sorted {@link Conditions.ConditionSet  | ConditionSets} that make up this decision.
      * @public
@@ -2058,6 +2583,17 @@ declare const DefaultResourceTypes: ReadonlyArray<ResourceTypes.Config.IResource
  */
 declare const DefaultSystemConfiguration: ISystemConfiguration;
 
+/**
+ * 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,
@@ -2203,6 +2739,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.
@@ -2244,7 +2804,8 @@ declare namespace Helpers {
         IQualifierDefaultValueTokenParts,
         splitResourceId,
         joinResourceIds,
-        joinOptionalResourceIds
+        joinOptionalResourceIds,
+        getNameForResourceId
     }
 }
 export { Helpers }
@@ -2283,6 +2844,153 @@ 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.
+ * @public
+ */
+declare interface IBundle {
+    /**
+     * Metadata about the bundle including build date and integrity checksum.
+     */
+    metadata: IBundleMetadata;
+    /**
+     * The system configuration that was used to build the resources in this bundle.
+     */
+    config: Model.ISystemConfiguration;
+    /**
+     * The compiled resource collection containing all resources, conditions, and decisions.
+     */
+    compiledCollection: Compiled.ICompiledResourceCollection;
+    /**
+     * Optional export metadata for tracking when and how the bundle was exported.
+     */
+    exportMetadata?: IBundleExportMetadata;
+}
+
+/**
+ * Components extracted from a bundle for reuse in different contexts.
+ * @public
+ */
+declare interface IBundleComponents {
+    /**
+     * The system configuration from the bundle.
+     */
+    systemConfiguration: SystemConfiguration;
+    /**
+     * The compiled resource collection from the bundle.
+     */
+    compiledCollection: Compiled.ICompiledResourceCollection;
+    /**
+     * The bundle metadata including build information.
+     */
+    metadata: IBundleMetadata;
+}
+
+/**
+ * Optional parameters for bundle creation.
+ * @public
+ */
+declare interface IBundleCreateParams {
+    /**
+     * Optional version identifier to include in the bundle metadata.
+     */
+    version?: string;
+    /**
+     * Optional description to include in the bundle metadata.
+     */
+    description?: string;
+    /**
+     * Optional custom build date. If not provided, the current date will be used.
+     */
+    dateBuilt?: string;
+    /**
+     * Optional hash normalizer for generating checksums. If not provided,
+     * a CRC32 normalizer will be used for browser compatibility.
+     */
+    hashNormalizer?: Hash.HashingNormalizer;
+    /**
+     * Whether to normalize the ResourceManagerBuilder before bundle creation.
+     * When true, the builder is reconstructed in canonical order to ensure
+     * order-independent checksums. Defaults to false for Phase 1 compatibility.
+     */
+    normalize?: boolean;
+}
+
+/**
+ * Optional export metadata for tracking bundle export information.
+ * @public
+ */
+declare interface IBundleExportMetadata {
+    /**
+     * ISO timestamp indicating when the bundle was exported.
+     */
+    exportedAt: string;
+    /**
+     * Tool or application that exported the bundle.
+     */
+    exportedFrom: string;
+    /**
+     * Type of bundle export (e.g., 'ts-res-bundle', 'ts-res-bundle-filtered').
+     */
+    type: string;
+    /**
+     * Optional filter context if the bundle represents filtered data.
+     */
+    filterContext?: Record<string, unknown>;
+}
+
+/**
+ * Parameters for creating a BundleLoader.
+ * @public
+ */
+declare interface IBundleLoaderCreateParams {
+    /**
+     * The bundle to load.
+     */
+    bundle: IBundle;
+    /**
+     * Whether to skip checksum verification during loading.
+     * Default is false - checksum verification is performed.
+     */
+    skipChecksumVerification?: boolean;
+    /**
+     * Optional hash normalizer for verifying checksums. If not provided,
+     * a CRC32 normalizer will be used for browser compatibility.
+     * Must match the normalizer used during bundle creation.
+     */
+    hashNormalizer?: Hash.HashingNormalizer;
+}
+
+/**
+ * Metadata for a resource bundle, including build information and integrity verification.
+ * @public
+ */
+declare interface IBundleMetadata {
+    /**
+     * ISO timestamp indicating when the bundle was built.
+     */
+    dateBuilt: string;
+    /**
+     * SHA-256 checksum of the serialized compiled resource collection for integrity verification.
+     */
+    checksum: string;
+    /**
+     * Optional version identifier for the bundle.
+     */
+    version?: string;
+    /**
+     * Optional human-readable description of the bundle.
+     */
+    description?: string;
+}
+
 /**
  * Cache metrics interface for tracking cache performance.
  * @public
@@ -2340,6 +3048,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
@@ -2463,9 +3234,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.
      */
@@ -2638,6 +3409,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.
      */
@@ -2829,6 +3604,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
@@ -3113,6 +3901,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
@@ -3246,6 +4074,11 @@ declare interface IJsonResourceTypeCreateParams {
      * instance.
      */
     index?: number;
+    /**
+     * Optional template for new instances of {@link ResourceTypes.JsonResourceType | JsonResourceType}
+     * resources.
+     */
+    template?: JsonObject;
 }
 
 /**
@@ -3310,10 +4143,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.
      */
@@ -3337,7 +4170,7 @@ declare interface ILiteralValue<T extends string> {
  */
 declare interface ILiteralValueHierarchyCreateParams<T extends string = string> {
     values: ReadonlyArray<T>;
-    hierarchy?: LiteralValueHierarchyDecl<T>;
+    hierarchy?: Partial<LiteralValueHierarchyDecl<T>>;
 }
 
 /**
@@ -3570,14 +4403,27 @@ declare class ImportContext implements IValidatedImportContext {
 }
 
 /**
- * `Converter` for a normalized {@link ResourceJson.Normalized.IImporterResourceCandidateDecl | importer resource candidate declaration}.
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
  * @public
  */
-declare const importerResourceCandidateDecl: Converter<Normalized.IImporterResourceCandidateDecl>;
+declare const importedDirectory: Converter<Json_2.IImportedDirectory>;
 
 /**
- * `Converter` for a normalized {@link ResourceJson.Normalized.IImporterResourceCollectionDecl | importer resource collection declaration}.
- * This allows for a mix of loose and child resource declarations.
+ * 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
+ */
+declare const importerResourceCandidateDecl: Converter<Normalized.IImporterResourceCandidateDecl>;
+
+/**
+ * `Converter` for a normalized {@link ResourceJson.Normalized.IImporterResourceCollectionDecl | importer resource collection declaration}.
+ * This allows for a mix of loose and child resource declarations.
  * @public
  */
 declare const importerResourceCollectionDecl: Converter<Normalized.IImporterResourceCollectionDecl>;
@@ -3754,11 +4600,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.
      */
@@ -3821,6 +4671,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>>>;
 }
 
 /**
@@ -3981,7 +4842,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
@@ -4068,6 +4929,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
@@ -4077,8 +4961,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 */
@@ -4095,6 +4981,7 @@ declare interface IResourceBuilderCreateParams {
     conditionSets: ConditionSetCollector;
     resourceTypes: ReadOnlyResourceTypeCollector;
     decisions: AbstractDecisionCollector;
+    candidateValues: CandidateValueCollector;
 }
 
 /**
@@ -4124,6 +5011,7 @@ declare interface IResourceCandidateCreateParams {
     resourceType?: ResourceType;
     parentConditions?: ReadonlyArray<Condition>;
     conditionSets: ConditionSetCollector;
+    candidateValues: CandidateValueCollector;
 }
 
 /**
@@ -4137,10 +5025,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
@@ -4281,7 +5169,7 @@ declare interface IResourceDeclContainer {
  * implementations without requiring the full ResourceManagerBuilder build mechanics.
  * @public
  */
-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.
@@ -4302,12 +5190,17 @@ 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.
      */
@@ -4333,6 +5226,56 @@ declare interface IResourceManagerBuilderCreateParams {
     resourceTypes: ReadOnlyResourceTypeCollector;
 }
 
+/**
+ * Options for ResourceManagerBuilder clone operations.
+ * Extends IDeclarationOptions to include support for applying edits when cloning.
+ * @public
+ */
+declare interface IResourceManagerCloneOptions extends IResourceDeclarationOptions {
+    /**
+     * Optional array of loose condition declarations to be applied as edits during the clone operation.
+     * 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 {
+    /**
+     * 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>;
+}
+
 /**
  * A listener for {@link Runtime.ResourceResolver | ResourceResolver} cache activity.
  * @public
@@ -4356,6 +5299,11 @@ declare interface IResourceResolverCacheListener {
      * @param index - The index of the cache that had an error.
      */
     onCacheError(cache: ResourceResolverCacheType, index: number): void;
+    /**
+     * Called when a context error occurs.
+     * @param error - The error that occurred.
+     */
+    onContextError(qualifier: string, error: string): void;
     /**
      * Called when a cache is cleared.
      * @param cache - The type of cache that was cleared.
@@ -4387,6 +5335,24 @@ declare interface IResourceResolverCreateParams {
      * An optional listener for {@link Runtime.ResourceResolver | ResourceResolver} cache activity.
      */
     listener?: IResourceResolverCacheListener;
+    /**
+     * Optional configuration options for the {@link Runtime.ResourceResolver | ResourceResolver}.
+     */
+    options?: IResourceResolverOptions;
+}
+
+/**
+ * Options for configuring a {@link Runtime.ResourceResolver | ResourceResolver}.
+ * @public
+ */
+declare interface IResourceResolverOptions {
+    /**
+     * Controls whether null values in resource composition should suppress properties
+     * instead of setting them to null. When true, properties with null values from
+     * higher-priority partial candidates will be omitted from the final composed resource.
+     * @defaultValue false
+     */
+    suppressNullAsDelete?: boolean;
 }
 
 /**
@@ -4453,13 +5419,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;
 }
 
 /**
@@ -4514,6 +5549,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
@@ -4742,7 +5804,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. */
@@ -4760,6 +5822,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>;
 }
 
 /**
@@ -4792,6 +5856,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
@@ -4801,7 +5873,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>;
@@ -4834,10 +5906,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>;
 }
 
 /**
@@ -4965,6 +6037,111 @@ declare interface IValidatingSimpleContextQualifierProviderCreateParams {
     qualifierValues?: Record<string, string>;
 }
 
+/**
+ * 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.
@@ -5012,6 +6189,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
@@ -5039,18 +6226,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.
@@ -5065,15 +6263,15 @@ declare class JsonResourceType extends ResourceType<JsonObject> {
     /**
      * {@inheritdoc ResourceTypes.ResourceType.(validate:1)}
      */
-    validate(json: JsonObject, isPartial: true): Result<JsonObject>;
+    validate(json: JsonObject, completeness: CandidateCompleteness): Result<JsonObject>;
     /**
      * {@inheritdoc ResourceTypes.ResourceType.(validate:2)}
      */
-    validate(json: JsonObject, isPartial: false): Result<JsonObject>;
+    validate(json: JsonObject, completeness: 'full'): Result<JsonObject>;
     /**
      * {@inheritdoc ResourceTypes.ResourceType.(validate:3)}
      */
-    validate(json: JsonObject, isPartial: boolean): Result<JsonObject>;
+    validate(json: JsonObject, completeness: 'partial'): Result<JsonObject>;
 }
 
 /**
@@ -5100,7 +6298,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'.
@@ -5130,6 +6332,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}.
@@ -5146,14 +6369,18 @@ declare class LanguageQualifierType extends QualifierType {
  * @returns A `Converter` for {@link QualifierTypes.Config.ILanguageQualifierTypeConfig | LanguageQualifierTypeConfig} objects.
  * @public
  */
-declare const languageQualifierTypeConfig: ObjectConverter<Model_3.ILanguageQualifierTypeConfig, unknown>;
+declare const languageQualifierTypeConfig: ObjectConverter<Model_2.ILanguageQualifierTypeConfig, unknown>;
 
 /**
  * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value,
  * 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.
      */
@@ -5189,6 +6416,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}
      */
@@ -5234,7 +6482,7 @@ declare class LiteralQualifierType extends QualifierType {
  * @returns A `Converter` for {@link QualifierTypes.Config.ILiteralQualifierTypeConfig | LiteralQualifierTypeConfig} objects.
  * @public
  */
-declare const literalQualifierTypeConfig: ObjectConverter<Model_3.ILiteralQualifierTypeConfig, unknown>;
+declare const literalQualifierTypeConfig: ObjectConverter<Model_2.ILiteralQualifierTypeConfig, unknown>;
 
 /**
  * A class that implements a hierarchy of literal values. The hierarchy is defined as a
@@ -5318,6 +6566,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>;
 }
 
 /**
@@ -5337,7 +6590,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}.
@@ -5480,6 +6733,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
@@ -5487,6 +6746,28 @@ declare function mergeLooseResource(resource: Normalized.IImporterResourceDecl,
 export declare const MinConditionPriority: ConditionPriority;
 
 declare namespace Model {
+    export {
+        ISystemConfiguration
+    }
+}
+
+declare namespace Model_2 {
+    export {
+        isSystemQualifierTypeConfig,
+        IQualifierTypeConfig,
+        ILanguageQualifierTypeConfig,
+        LiteralValueHierarchyDecl,
+        ITerritoryQualifierTypeConfig,
+        ILiteralQualifierTypeConfig,
+        ISystemLanguageQualifierTypeConfig,
+        ISystemTerritoryQualifierTypeConfig,
+        ISystemLiteralQualifierTypeConfig,
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
+    }
+}
+
+declare namespace Model_3 {
     export {
         ICompiledConditionMetadata,
         ICompiledConditionSetMetadata,
@@ -5503,22 +6784,12 @@ declare namespace Model {
     }
 }
 
-declare namespace Model_2 {
-    export {
-        ISystemConfiguration
-    }
-}
-
-declare namespace Model_3 {
+declare namespace Model_4 {
     export {
-        IQualifierTypeConfig,
-        ILanguageQualifierTypeConfig,
-        ITerritoryQualifierTypeConfig,
-        ILiteralQualifierTypeConfig,
-        ISystemLanguageQualifierTypeConfig,
-        ISystemTerritoryQualifierTypeConfig,
-        ISystemLiteralQualifierTypeConfig,
-        ISystemQualifierTypeConfig
+        IBundleMetadata,
+        IBundleExportMetadata,
+        IBundle,
+        IBundleCreateParams
     }
 }
 
@@ -5545,6 +6816,10 @@ declare class NoOpResourceResolverCacheListener implements IResourceResolverCach
      * {@inheritDoc Runtime.IResourceResolverCacheListener.onCacheError}
      */
     onCacheError(cache: ResourceResolverCacheType, index: number): void;
+    /**
+     * {@inheritDoc Runtime.IResourceResolverCacheListener.onContextError}
+     */
+    onContextError(qualifier: string, error: string): void;
     /**
      * {@inheritDoc Runtime.IResourceResolverCacheListener.onCacheClear}
      */
@@ -5568,6 +6843,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
@@ -5622,6 +6905,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.
@@ -5692,7 +6991,7 @@ declare const predefinedSystemConfiguration: Converter<PredefinedSystemConfigura
  * which a resource is used.
  * @public
  */
-declare class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {
+export declare class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {
     /**
      * The name of the qualifier.
      */
@@ -6031,7 +7330,7 @@ declare const qualifierName: Converter<QualifierName, unknown>;
 
 declare namespace Qualifiers {
     export {
-        Convert_8 as Convert,
+        Convert_4 as Convert,
         Qualifier,
         IQualifierDecl,
         IValidatedQualifierDecl,
@@ -6052,11 +7351,15 @@ export { Qualifiers }
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-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}
      */
@@ -6102,6 +7405,14 @@ 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}
      */
@@ -6157,7 +7468,7 @@ 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.
@@ -6181,6 +7492,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
@@ -6208,7 +7587,7 @@ declare const qualifierTypeName: Converter<QualifierTypeName, unknown>;
 declare namespace QualifierTypes {
     export {
         Config_2 as Config,
-        Convert_7 as Convert,
+        Convert_3 as Convert,
         IQualifierType,
         IQualifierTypeCreateParams,
         QualifierType,
@@ -6216,7 +7595,6 @@ declare namespace QualifierTypes {
         LanguageQualifierType,
         ILiteralQualifierTypeCreateParams,
         LiteralQualifierType,
-        LiteralValueHierarchyDecl,
         ILiteralValue,
         ILiteralValueHierarchyCreateParams,
         LiteralValueHierarchy,
@@ -6226,7 +7604,8 @@ declare namespace QualifierTypes {
         QualifierTypeCollector,
         ReadOnlyQualifierTypeCollector,
         createQualifierTypeFromConfig,
-        createQualifierTypeFromSystemConfig
+        createQualifierTypeFromSystemConfig,
+        SystemQualifierType
     }
 }
 export { QualifierTypes }
@@ -6394,6 +7773,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
@@ -6405,15 +7785,19 @@ declare namespace RegularExpressions {
  * candidate instances.
  * @public
  */
-declare class Resource implements IResource {
+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.
      */
@@ -6422,10 +7806,6 @@ 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.
      */
@@ -6550,6 +7930,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}.
@@ -6621,16 +8005,22 @@ declare type ResourceBuilderResultDetail = Collections.ResultMapResultDetail | '
  * and instructions on how to merge it with other instances.
  * @public
  */
-declare class ResourceCandidate implements IResourceCandidate {
+export declare class ResourceCandidate implements IResourceCandidate {
     /**
      * The unique identifier of the resource for which this candidate
      * 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.
      */
@@ -6648,6 +8038,10 @@ 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}.
@@ -6820,6 +8214,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.
@@ -6848,7 +8253,7 @@ declare const resourceIndex: Converter<ResourceIndex, unknown>;
 declare namespace ResourceJson {
     export {
         Compiled,
-        Convert_4 as Convert,
+        Convert_7 as Convert,
         Helpers_2 as Helpers,
         Json,
         Normalized,
@@ -6866,15 +8271,59 @@ export { ResourceJson }
  * and builds a collection of {@link Resources.Resource | resources} once all candidates are collected.
  * @public
  */
-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
@@ -6931,6 +8380,26 @@ declare class ResourceManagerBuilder implements IResourceManager {
      * @public
      */
     static create(params: IResourceManagerBuilderCreateParams): Result<ResourceManagerBuilder>;
+    /**
+     * Creates a new {@link Resources.ResourceManagerBuilder | ResourceManagerBuilder} object from a predefined system configuration.
+     * @param name - The name of the predefined system configuration to use.
+     * @param qualifierDefaultValues - Optional default values for qualifiers.
+     * @returns `Success` with the new {@link Resources.ResourceManagerBuilder | ResourceManagerBuilder} object if successful,
+     * or `Failure` with an error message if not.
+     * @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.
@@ -6940,6 +8409,20 @@ declare class ResourceManagerBuilder implements IResourceManager {
      */
     addLooseCandidate(decl: ResourceJson.Json.ILooseResourceCandidateDecl): DetailedResult<ResourceCandidate, ResourceBuilderResultDetail>;
     addResource(decl: ResourceJson.Json.ILooseResourceDecl): DetailedResult<ResourceBuilder, ResourceBuilderResultDetail>;
+    /**
+     * Adds a condition to the manager.
+     * @param decl - The condition declaration to add.
+     * @returns `Success` with the condition if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    addCondition(decl: ResourceJson.Json.ILooseConditionDecl): Result<Condition>;
+    /**
+     * Adds a condition set to the manager.
+     * @param decl - The condition set declaration to add.
+     * @returns `Success` with the condition set if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    addConditionSet(conditions: ResourceJson.Normalized.ConditionSetDecl): Result<ConditionSet>;
     /**
      * Gets a read-only array of all {@link Resources.ResourceBuilder | resource builders} present in the manager.
      * @returns `Success` with the {@link Resources.ResourceBuilder | resource builder} if successful,
@@ -6970,6 +8453,19 @@ 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.
@@ -7043,14 +8539,98 @@ 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.
-     * @param options - Options for the cloning operation, including the strongly-typed filterForContext property.
-     * @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?: IResourceDeclarationOptions): Result<ResourceManagerBuilder>;
+    clone(options?: IResourceManagerCloneOptions): Result<ResourceManagerBuilder>;
+    /**
+     * Creates a resource ID keyed map from an array of loose resource candidate declarations.
+     * This enables efficient detection of edit collisions by grouping candidates by their target resource.
+     * @param candidates - Array of loose resource candidate declarations to organize
+     * @returns A Result containing a Map where keys are validated ResourceIds and values are arrays of candidates for that resource
+     * @internal
+     */
+    private static _createCandidatesByResourceMap;
+    /**
+     * Generates a proper ConditionSet token for collision detection using the existing ConditionSet.getKeyForDecl method.
+     * @param conditionSet - The condition set to generate a token for
+     * @param conditionCollector - The condition collector needed for validation context
+     * @returns A Result containing the ConditionSet token if successful, or failure if validation fails
+     * @internal
+     */
+    /**
+     * 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.
+     * @param resourceDecl - The original resource declaration to potentially modify
+     * @param candidatesByResource - Map of resource IDs to arrays of candidate edits
+     * @param conditionCollector - The condition collector needed for generating condition tokens
+     * @returns A Result containing the resource declaration to use (original or modified)
+     * @internal
+     */
+    private static _applyEditsToResourceDeclaration;
+    /**
+     * Creates a new resource declaration from an array of candidate declarations.
+     * This is used when cloning to create new resources that don't exist in the original manager.
+     * @param resourceId - The validated resource ID for the new resource
+     * @param candidates - Array of loose candidate declarations for the new resource
+     * @param conditionCollector - The condition collector for validation context
+     * @returns A Result containing the new resource declaration if successful, or failure if validation fails
+     * @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;
 }
 
 /**
@@ -7077,7 +8657,7 @@ declare const resourceName: Converter<ResourceName, unknown>;
  * and caching results for optimal performance.
  * @public
  */
-declare class ResourceResolver {
+export declare class ResourceResolver implements IResourceResolver {
     /**
      * The resource manager that defines available resources and provides condition access.
      */
@@ -7090,6 +8670,14 @@ declare class ResourceResolver {
      * The context qualifier provider that resolves qualifier values.
      */
     readonly contextQualifierProvider: IContextQualifierProvider;
+    /**
+     * The configuration options for this resource resolver.
+     */
+    readonly options: IResourceResolverOptions;
+    /**
+     * The readonly qualifier collector that provides qualifier implementations.
+     */
+    get qualifiers(): IReadOnlyQualifierCollector;
     /**
      * 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
@@ -7174,6 +8762,15 @@ 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.
@@ -7183,6 +8780,15 @@ 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
@@ -7193,6 +8799,20 @@ 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
@@ -7233,6 +8853,8 @@ declare type ResourceResolverCacheActivity = 'hit' | 'miss' | 'error' | 'clear';
  */
 declare class ResourceResolverCacheMetricsListener<TM extends ICacheMetrics> implements IResourceResolverCacheListener {
     private readonly _metrics;
+    private _contextErrors;
+    get numContextErrors(): number;
     constructor(factory: () => TM);
     constructor(metrics: OverallCacheMetrics<TM>);
     /**
@@ -7252,6 +8874,10 @@ declare class ResourceResolverCacheMetricsListener<TM extends ICacheMetrics> imp
      * {@inheritDoc Runtime.IResourceResolverCacheListener.onCacheError}
      */
     onCacheError(cache: ResourceResolverCacheType, index: number): void;
+    /**
+     * {@inheritDoc Runtime.IResourceResolverCacheListener.onContextError}
+     */
+    onContextError(qualifier: string, error: string): void;
     /**
      * {@inheritDoc Runtime.IResourceResolverCacheListener.onCacheClear}
      */
@@ -7274,6 +8900,11 @@ declare namespace Resources {
         ICandidateInfo,
         IReducedCandidate,
         CandidateReducer,
+        ICandidateValue,
+        ICandidateValueCreateParams,
+        CandidateValue,
+        ICandidateValueCollectorCreateParams,
+        CandidateValueCollector,
         IResourceCandidateCreateParams,
         ICandidateDeclOptions,
         ResourceCandidate,
@@ -7286,7 +8917,8 @@ declare namespace Resources {
         ResourceManagerBuilderResultDetail,
         ResourceManagerBuilder,
         IResourceDeclarationOptions,
-        ICompiledResourceOptionsWithFilter
+        ICompiledResourceOptionsWithFilter,
+        IResourceManagerCloneOptions
     }
 }
 export { Resources }
@@ -7333,7 +8965,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;
@@ -7388,17 +9020,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
@@ -7422,6 +9054,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
@@ -7434,17 +9171,22 @@ declare const resourceTreeRootDecl: Converter<Normalized.IResourceTreeRootDecl>;
  * resource value.
  * @public
  */
-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.
@@ -7457,34 +9199,62 @@ declare abstract class ResourceType<T = unknown> implements ICollectible<Resourc
     /**
      * Validates a JSON value for use as a partial resource instance value.
      * @param json - The JSON value to validate.
-     * @param isPartial - `true` indicates that the value is expected to be partial.
+     * @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
      */
-    abstract validate(json: JsonValue, isPartial: true): Result<Partial<T>>;
+    abstract 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 isPartial - `false` indicates that the value is expected to be complete.
+     * @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
      */
-    abstract validate(json: JsonValue, isPartial: false): Result<T>;
+    abstract 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
+     */
+    abstract validate(json: JsonValue, completeness: 'partial'): Result<Partial<T>>;
     /**
      * Validates a JSON value for use as a full or partial resource instance value.
      * @param json - The JSON value to validate.
-     * @param isPartial - Indicates whether the value is expected to be partial.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
      * @returns `Success` with the strongly-typed full or partial resource value if
      * the JSON is valid, `Failure` with an error message otherwise.
      * @public
      */
-    abstract validate(json: JsonValue, isPartial?: boolean): Result<T | Partial<T>>;
+    abstract validate(json: JsonValue, completeness?: CandidateCompleteness): Result<T | 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.
+     * 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>;
 }
 
 /**
@@ -7508,7 +9278,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.
@@ -7538,6 +9331,7 @@ declare namespace ResourceTypes {
     export {
         Config_3 as Config,
         IResourceCandidateValidationProperties,
+        IResourceType,
         ResourceType,
         IResourceCollectorCreateParams,
         ResourceTypeCollector,
@@ -7578,8 +9372,13 @@ declare namespace Runtime {
         IValidatingSimpleContextQualifierProviderCreateParams,
         ValidatingSimpleContextQualifierProvider,
         DecisionResolutionResult,
+        IResourceResolverOptions,
         IResourceResolverCreateParams,
         ResourceResolver,
+        ResourceErrorHandler,
+        EmptyBranchHandler,
+        IResolveResourceTreeOptions,
+        ResourceTreeResolver,
         ConditionMatchType,
         IConditionMatchResult,
         ConditionSetResolutionResult,
@@ -7595,6 +9394,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
  */
@@ -7736,7 +9543,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}.
@@ -7747,6 +9554,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.
@@ -7764,33 +9579,48 @@ 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.
  * @public
  */
-declare const systemLanguageQualifierTypeConfig: ObjectConverter<Model_3.ISystemLanguageQualifierTypeConfig, unknown>;
+declare const systemLanguageQualifierTypeConfig: ObjectConverter<Model_2.ISystemLanguageQualifierTypeConfig, unknown>;
 
 /**
  * A `Converter` for {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | SystemLiteralQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | SystemLiteralQualifierTypeConfig} objects.
  * @public
  */
-declare const systemLiteralQualifierTypeConfig: ObjectConverter<Model_3.ISystemLiteralQualifierTypeConfig, unknown>;
+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.
  * @public
  */
-declare const systemQualifierTypeConfig: Converter<Model_3.ISystemQualifierTypeConfig, unknown>;
+declare const systemQualifierTypeConfig: Converter<Model_2.ISystemQualifierTypeConfig, unknown>;
 
 /**
  * A `Converter` for {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | SystemTerritoryQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | SystemTerritoryQualifierTypeConfig} objects.
  * @public
  */
-declare const systemTerritoryQualifierTypeConfig: ObjectConverter<Model_3.ISystemTerritoryQualifierTypeConfig, unknown>;
+declare const systemTerritoryQualifierTypeConfig: ObjectConverter<Model_2.ISystemTerritoryQualifierTypeConfig, unknown>;
 
 /**
  * @internal
@@ -7821,7 +9651,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.
      */
@@ -7863,6 +9697,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}
      */
@@ -7893,7 +9748,27 @@ declare class TerritoryQualifierType extends QualifierType {
  * @returns A `Converter` for {@link QualifierTypes.Config.ITerritoryQualifierTypeConfig | TerritoryQualifierTypeConfig} objects.
  * @public
  */
-declare const territoryQualifierTypeConfig: ObjectConverter<Model_3.ITerritoryQualifierTypeConfig, unknown>;
+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.
@@ -8194,12 +10069,16 @@ declare namespace Validate {
         isValidResourceIndex,
         isValidResourceTypeName,
         isValidResourceTypeIndex,
+        isValidCandidateValueIndex,
+        isValidCandidateValueKey,
         toResourceName,
         toResourceId,
         toOptionalResourceId,
         toResourceIndex,
         toResourceTypeName,
-        toResourceTypeIndex
+        toResourceTypeIndex,
+        toCandidateValueKey,
+        toCandidateValueIndex
     }
 }
 export { Validate }
@@ -8244,6 +10123,94 @@ 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
@@ -8272,4 +10239,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 { }