@fgv/ts-res 5.0.0-2 → 5.0.0-21

package/dist/ts-res.d.ts

@@ -3,6 +3,7 @@ import { Collections } from '@fgv/ts-utils';
 import { Converter } from '@fgv/ts-utils';
 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 { JsonObject } from '@fgv/ts-json-base';
@@ -13,6 +14,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
@@ -178,6 +180,280 @@ declare function buildQualifierDefaultValuesToken(parts: ReadonlyArray<IQualifie
  */
 declare function buildQualifierDefaultValueToken({ qualifier, value }: IQualifierDefaultValueTokenParts): Result<QualifierDefaultValueToken>;
 
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @public
+ */
+declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<QualifierType>;
+}
+
+/**
+ * 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 +503,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 +577,25 @@ declare class CandidateReducer {
     reduceCandidate(candidate: ResourceCandidate): Result<IReducedCandidate | undefined>;
 }
 
+/**
+ * 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 +706,14 @@ declare namespace Common {
         ResourceTypeName,
         ResourceTypeIndex,
         ResourceValueMergeMethod,
-        allResourceValueMergeMethods
+        allResourceValueMergeMethods,
+        CandidateCompleteness
     }
 }
 
 declare namespace Compiled {
     export {
-        Convert_3 as Convert,
+        Convert_6 as Convert,
         ICompiledResourceOptions,
         ICompiledConditionMetadata,
         ICompiledConditionSetMetadata,
@@ -429,61 +734,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,7 +796,7 @@ 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;
@@ -563,7 +868,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
@@ -628,13 +933,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 +990,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 +1237,7 @@ declare const conditionPriority: Converter<ConditionPriority, unknown>;
 
 declare namespace Conditions {
     export {
-        Convert_2 as Convert,
+        Convert_11 as Convert,
         Condition,
         IConditionCollectorCreateParams,
         ConditionCollector,
@@ -956,7 +1261,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 +1331,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 +1433,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 +1445,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 +1686,14 @@ declare class ConditionTokens {
 
 declare namespace Config {
     export {
-        Model_2 as Model,
-        Convert_10 as Convert,
+        Model,
+        Convert_9 as Convert,
+        IConfigInitFactory,
+        ChainedConfigInitFactory,
+        BuiltInQualifierTypeFactory,
+        QualifierTypeFactory,
+        BuiltInResourceTypeFactory,
+        ResourceTypeFactory,
         updateSystemConfigurationQualifierDefaultValues,
         ISystemConfigurationInitParams,
         SystemConfiguration,
@@ -1390,7 +1709,8 @@ export { Config }
 
 declare namespace Config_2 {
     export {
-        Convert_6 as Convert,
+        Convert_2 as Convert,
+        isSystemQualifierTypeConfig,
         IQualifierTypeConfig,
         ILanguageQualifierTypeConfig,
         ITerritoryQualifierTypeConfig,
@@ -1398,13 +1718,14 @@ declare namespace Config_2 {
         ISystemLanguageQualifierTypeConfig,
         ISystemTerritoryQualifierTypeConfig,
         ISystemLiteralQualifierTypeConfig,
-        ISystemQualifierTypeConfig
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
     }
 }
 
 declare namespace Config_3 {
     export {
-        Convert_9 as Convert,
+        Convert_5 as Convert,
         IResourceTypeConfig
     }
 }
@@ -1417,7 +1738,7 @@ declare const containerContextDecl: Converter<Normalized.IContainerContextDecl>;
 
 declare namespace Context {
     export {
-        Convert_5 as Convert,
+        Convert_8 as Convert,
         IContextMatchOptions,
         IContextQualifierValueDecl,
         IContextDecl,
@@ -1760,23 +2081,76 @@ 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 {
+        languageQualifierTypeConfig,
+        territoryQualifierTypeConfig,
+        literalQualifierTypeConfig,
+        systemLanguageQualifierTypeConfig,
+        systemTerritoryQualifierTypeConfig,
+        systemLiteralQualifierTypeConfig,
+        systemQualifierTypeConfig
+    }
+}
+
 declare namespace Convert_3 {
+    export {
+        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,
@@ -1793,11 +2167,11 @@ declare namespace Convert_3 {
     }
 }
 
-declare namespace Convert_4 {
+declare namespace Convert_7 {
     export {
         looseConditionDecl,
         childConditionDecl,
-        conditionSetDecl_2 as conditionSetDecl,
+        conditionSetDecl,
         looseResourceCandidateDecl,
         importerResourceCandidateDecl,
         childResourceCandidateDecl,
@@ -1811,7 +2185,7 @@ declare namespace Convert_4 {
     }
 }
 
-declare namespace Convert_5 {
+declare namespace Convert_8 {
     export {
         contextQualifierValueDecl,
         contextDecl,
@@ -1821,39 +2195,11 @@ 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
     }
 }
 
@@ -1891,11 +2237,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
@@ -2203,6 +2560,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,43 +2625,191 @@ declare namespace Helpers {
         IQualifierDefaultValueTokenParts,
         splitResourceId,
         joinResourceIds,
-        joinOptionalResourceIds
+        joinOptionalResourceIds,
+        getNameForResourceId
     }
 }
-export { Helpers }
+export { Helpers }
+
+declare namespace Helpers_2 {
+    export {
+        mergeContextDecl,
+        mergeLooseCandidate,
+        mergeImporterCandidate,
+        mergeChildCandidate,
+        mergeLooseResource,
+        mergeImporterResource,
+        mergeChildResource,
+        IDeclarationOptions
+    }
+}
+
+/**
+ * Parameters for creating a {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+ * @public
+ */
+declare interface IAbstractDecisionCollectorCreateParams {
+    /**
+     * {@link Conditions.ReadOnlyConditionSetCollector | ConditionSetCollector} used to create conditions
+     * sets for decisions in this collector.
+     */
+    conditionSets: ReadOnlyConditionSetCollector;
+}
+
+/**
+ * Parameters to create an {@link Decisions.AbstractDecision | AbstractDecision}.
+ * @public
+ */
+declare interface IAbstractDecisionCreateParams {
+    conditionSets: ConditionSet[];
+    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;
+}
 
-declare namespace Helpers_2 {
-    export {
-        mergeContextDecl,
-        mergeLooseCandidate,
-        mergeImporterCandidate,
-        mergeChildCandidate,
-        mergeLooseResource,
-        mergeImporterResource,
-        mergeChildResource,
-        IDeclarationOptions
-    }
+/**
+ * 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;
 }
 
 /**
- * Parameters for creating a {@link Decisions.AbstractDecisionCollector | AbstractDecisionCollector}.
+ * Optional export metadata for tracking bundle export information.
  * @public
  */
-declare interface IAbstractDecisionCollectorCreateParams {
+declare interface IBundleExportMetadata {
     /**
-     * {@link Conditions.ReadOnlyConditionSetCollector | ConditionSetCollector} used to create conditions
-     * sets for decisions in this collector.
+     * ISO timestamp indicating when the bundle was exported.
      */
-    conditionSets: ReadOnlyConditionSetCollector;
+    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 to create an {@link Decisions.AbstractDecision | AbstractDecision}.
+ * Parameters for creating a BundleLoader.
  * @public
  */
-declare interface IAbstractDecisionCreateParams {
-    conditionSets: ConditionSet[];
-    index?: number;
+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;
 }
 
 /**
@@ -2829,6 +3358,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 +3655,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
@@ -3569,6 +4151,19 @@ declare class ImportContext implements IValidatedImportContext {
     static forContainerImport(container?: ResourceJson.Normalized.IContainerContextDecl, importer?: ImportContext): Result<ImportContext | undefined>;
 }
 
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+declare const importedDirectory: Converter<Json_2.IImportedDirectory>;
+
+/**
+ * Converter for imported file
+ * @public
+ */
+declare const importedFile: Converter<Json_2.IImportedFile>;
+
 /**
  * `Converter` for a normalized {@link ResourceJson.Normalized.IImporterResourceCandidateDecl | importer resource candidate declaration}.
  * @public
@@ -4077,8 +4672,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 */
@@ -4137,10 +4734,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 +4878,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 +4899,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 +4935,31 @@ 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;
+}
+
 /**
  * A listener for {@link Runtime.ResourceResolver | ResourceResolver} cache activity.
  * @public
@@ -4356,6 +4983,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 +5019,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,6 +5103,71 @@ 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
+     * @returns A loose resource declaration with default values for this resource type
+     * @public
+     */
+    createTemplate(resourceId: ResourceId): ResourceJson.Json.ILooseResourceDecl;
+}
+
 /**
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
@@ -4514,6 +5229,15 @@ 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;
+
 /**
  * Determines whether a number is a valid condition index.
  * @param index - the number to validate
@@ -4760,6 +5484,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 +5518,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
@@ -4965,6 +5699,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 +5851,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
@@ -5065,15 +5914,20 @@ 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>;
+    /**
+     * Gets the default template value for a JSON resource type.
+     * @returns An empty object as the default JSON value
+     */
+    protected getDefaultTemplateValue(): JsonObject;
 }
 
 /**
@@ -5146,7 +6000,7 @@ 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,
@@ -5234,7 +6088,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
@@ -5480,13 +6334,40 @@ 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
  */
 export declare const MinConditionPriority: ConditionPriority;
 
-declare namespace Model {
+declare namespace Model {
+    export {
+        ISystemConfiguration
+    }
+}
+
+declare namespace Model_2 {
+    export {
+        isSystemQualifierTypeConfig,
+        IQualifierTypeConfig,
+        ILanguageQualifierTypeConfig,
+        ITerritoryQualifierTypeConfig,
+        ILiteralQualifierTypeConfig,
+        ISystemLanguageQualifierTypeConfig,
+        ISystemTerritoryQualifierTypeConfig,
+        ISystemLiteralQualifierTypeConfig,
+        ISystemQualifierTypeConfig,
+        IAnyQualifierTypeConfig
+    }
+}
+
+declare namespace Model_3 {
     export {
         ICompiledConditionMetadata,
         ICompiledConditionSetMetadata,
@@ -5503,22 +6384,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 +6416,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 +6443,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 +6505,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 +6591,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 +6930,7 @@ declare const qualifierName: Converter<QualifierName, unknown>;
 
 declare namespace Qualifiers {
     export {
-        Convert_8 as Convert,
+        Convert_4 as Convert,
         Qualifier,
         IQualifierDecl,
         IValidatedQualifierDecl,
@@ -6052,7 +6951,7 @@ export { Qualifiers }
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-declare abstract class QualifierType implements IQualifierType {
+export declare abstract class QualifierType implements IQualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.name}
      */
@@ -6181,6 +7080,20 @@ declare class QualifierTypeCollector extends ValidatingConvertingCollector<Quali
     protected static _toQualifierType(from: unknown): Result<QualifierType>;
 }
 
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | system qualifier type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInQualifierTypeFactory | built-in factory} that handles built-in qualifier types.
+ * @public
+ */
+declare class QualifierTypeFactory extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>[]);
+}
+
 /**
  * Branded number representing a validated qualifier type index.
  * @public
@@ -6208,7 +7121,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,
@@ -6405,15 +7318,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 +7339,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.
      */
@@ -6621,7 +7534,7 @@ 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.
@@ -6648,6 +7561,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}.
@@ -6848,7 +7765,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 +7783,54 @@ 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 {@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 +7887,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 +7916,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 +7960,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 +8046,97 @@ 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.
+     * @returns `Success` if all candidates were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    private static _createCandidatesFromDecision;
 }
 
 /**
@@ -7077,7 +8163,7 @@ declare const resourceName: Converter<ResourceName, unknown>;
  * and caching results for optimal performance.
  * @public
  */
-declare class ResourceResolver {
+export declare class ResourceResolver {
     /**
      * The resource manager that defines available resources and provides condition access.
      */
@@ -7090,6 +8176,10 @@ 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 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
@@ -7233,6 +8323,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 +8344,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}
      */
@@ -7286,7 +8382,8 @@ declare namespace Resources {
         ResourceManagerBuilderResultDetail,
         ResourceManagerBuilder,
         IResourceDeclarationOptions,
-        ICompiledResourceOptionsWithFilter
+        ICompiledResourceOptionsWithFilter,
+        IResourceManagerCloneOptions
     }
 }
 export { Resources }
@@ -7333,7 +8430,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 +8485,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
@@ -7434,14 +8531,14 @@ 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;
     /**
-     * The key for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.key}
      */
     get key(): ResourceTypeName;
     /**
-     * The index for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.index}
      */
     get index(): ResourceTypeIndex | undefined;
     protected constructor(key: ResourceTypeName, index?: number);
@@ -7457,34 +8554,58 @@ 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
+     * @returns A loose resource declaration with default values for this resource type
+     * @public
+     */
+    createTemplate(resourceId: ResourceId): 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
+     */
+    protected getDefaultTemplateValue(): JsonObject;
 }
 
 /**
@@ -7510,6 +8631,20 @@ declare class ResourceTypeCollector extends ValidatingCollector<ResourceType> {
  */
 declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig, 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 - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+}
+
 /**
  * Branded number representing a validated resource type index.
  * @public
@@ -7538,6 +8673,7 @@ declare namespace ResourceTypes {
     export {
         Config_3 as Config,
         IResourceCandidateValidationProperties,
+        IResourceType,
         ResourceType,
         IResourceCollectorCreateParams,
         ResourceTypeCollector,
@@ -7578,6 +8714,7 @@ declare namespace Runtime {
         IValidatingSimpleContextQualifierProviderCreateParams,
         ValidatingSimpleContextQualifierProvider,
         DecisionResolutionResult,
+        IResourceResolverOptions,
         IResourceResolverCreateParams,
         ResourceResolver,
         ConditionMatchType,
@@ -7595,6 +8732,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 +8881,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 +8892,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 +8917,40 @@ 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 `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
@@ -7893,7 +9053,7 @@ 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 ConditionIndex} if it is a valid condition index.
@@ -8244,6 +9404,23 @@ 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 {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} with a
  * {@link Runtime.Context.ContextQualifierProviderValidator | validator} property that enables
@@ -8272,4 +9449,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 { }