@fgv/ts-res 5.0.0-27 → 5.0.0-29

package/dist/ts-res.d.ts

@@ -7,6 +7,7 @@ import { FileTree } from '@fgv/ts-utils';
 import { Hash } from '@fgv/ts-utils';
 import { ICollectible } from '@fgv/ts-utils';
 import { IReadOnlyResultMap } from '@fgv/ts-utils';
+import { JsonCompatible } from '@fgv/ts-json-base';
 import { JsonObject } from '@fgv/ts-json-base';
 import { JsonValue } from '@fgv/ts-json-base';
 import { ObjectConverter } from '@fgv/ts-utils';
@@ -189,12 +190,15 @@ 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}.
+ * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
+ * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
+ * if successful, `Failure` with an error message otherwise.
  * @public
  */
-declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.ISystemQualifierTypeConfig, SystemQualifierType> {
     /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<QualifierType>;
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType>;
 }
 
 /**
@@ -1824,12 +1828,18 @@ declare namespace Config {
     export {
         Model,
         Convert_9 as Convert,
+        createQualifierTypeFactory,
+        createResourceTypeFactory,
+        QualifierTypeFactoryFunction,
+        ResourceTypeFactoryFunction,
         IConfigInitFactory,
         ChainedConfigInitFactory,
         BuiltInQualifierTypeFactory,
         QualifierTypeFactory,
+        ValidatingQualifierTypeFactory,
         BuiltInResourceTypeFactory,
         ResourceTypeFactory,
+        ValidatingResourceTypeFactory,
         updateSystemConfigurationQualifierDefaultValues,
         ISystemConfigurationInitParams,
         SystemConfiguration,
@@ -2345,6 +2355,14 @@ declare namespace Convert_9 {
     }
 }
 
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createQualifierTypeFactory<T extends QualifierType = QualifierType>(fn: QualifierTypeFactoryFunction<T>): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>;
+
 /**
  * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
@@ -2358,16 +2376,24 @@ declare namespace Convert_9 {
 declare function createQualifierTypeFromConfig(typeConfig: Config_2.IAnyQualifierTypeConfig): Result<QualifierType>;
 
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISystemQualifierTypeConfig): Result<QualifierType>;
+declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISystemQualifierTypeConfig): Result<SystemQualifierType>;
+
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createResourceTypeFactory(fn: ResourceTypeFactoryFunction): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 
 /**
  * Creates a {@link ResourceTypes.ResourceType | ResourceType} from a configuration object.
@@ -4144,7 +4170,7 @@ declare interface ILiteralValue<T extends string> {
  */
 declare interface ILiteralValueHierarchyCreateParams<T extends string = string> {
     values: ReadonlyArray<T>;
-    hierarchy?: LiteralValueHierarchyDecl<T>;
+    hierarchy?: Partial<LiteralValueHierarchyDecl<T>>;
 }
 
 /**
@@ -4574,7 +4600,7 @@ declare interface IQualifierDefaultValueTokenParts {
  * territories, etc).
  * @public
  */
-declare interface IQualifierType extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
+declare interface IQualifierType<TCFGJSON extends JsonObject = JsonObject> extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
     /**
      * The name of the qualifier type.
      */
@@ -4649,13 +4675,13 @@ declare interface IQualifierType extends ICollectible<QualifierTypeName, Qualifi
      * Gets the configuration for this qualifier type.
      * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * Validates configuration JSON data for this qualifier type.
      * @param from - The unknown data to validate as configuration JSON.
      * @returns `Success` with validated JSON configuration if valid, `Failure` with an error message otherwise.
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
 }
 
 /**
@@ -5465,10 +5491,10 @@ declare interface IResourceType<T = unknown> extends ICollectible<ResourceTypeNa
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
  */
-declare interface IResourceTypeConfig {
+declare interface IResourceTypeConfig<T extends JsonObject = JsonObject> {
     name: string;
     typeName: string;
-    template?: JsonObject;
+    template?: T;
 }
 
 /**
@@ -6272,7 +6298,7 @@ declare const LanguagePrioritySystemConfiguration: ISystemConfiguration;
  * Accepts a list of language tags in the context by default.
  * @public
  */
-declare class LanguageQualifierType extends QualifierType {
+declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config_2.ILanguageQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -6315,11 +6341,11 @@ declare class LanguageQualifierType extends QualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLanguageQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.
@@ -6350,7 +6376,7 @@ declare const languageQualifierTypeConfig: ObjectConverter<Model_2.ILanguageQual
  * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
-declare class LiteralQualifierType extends QualifierType {
+declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config_2.ILiteralQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -6399,11 +6425,11 @@ declare class LiteralQualifierType extends QualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemLiteralQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.
@@ -6564,7 +6590,7 @@ declare function literalValueHierarchyCreateParams<T extends string>(valueConver
  * determine the relationship between values when matching conditions and contexts.
  * @public
  */
-declare type LiteralValueHierarchyDecl<T extends string> = Partial<Record<T, T>>;
+declare type LiteralValueHierarchyDecl<T extends string> = Record<T, T>;
 
 /**
  * `Converter` for a normalized {@link ResourceJson.Json.ILooseConditionDecl | loose condition declaration}.
@@ -7325,7 +7351,7 @@ export { Qualifiers }
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-export declare abstract class QualifierType implements IQualifierType {
+export declare abstract class QualifierType<TCFGJSON extends JsonObject = JsonObject> implements IQualifierType<TCFGJSON> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.name}
      */
@@ -7382,11 +7408,11 @@ export declare abstract class QualifierType implements IQualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    abstract getConfigurationJson(): Result<JsonObject>;
+    abstract getConfigurationJson(): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    abstract validateConfigurationJson(from: unknown): Result<JsonObject>;
+    abstract validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
      */
@@ -7442,7 +7468,7 @@ export declare abstract class QualifierType implements IQualifierType {
  * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.
  * @public
  */
-declare const qualifierType: Converter<QualifierType, IQualifierTypeConvertContext>;
+declare const qualifierType: Converter<QualifierType<JsonObject>, IQualifierTypeConvertContext>;
 
 /**
  * Collector for {@link QualifierTypes.QualifierType | QualifierType} objects.
@@ -7475,19 +7501,65 @@ declare class QualifierTypeCollector extends ValidatingConvertingCollector<Quali
 declare function qualifierTypeConfig<T, TD = unknown>(config: Converter<T, TD>): Converter<Model_2.IQualifierTypeConfig<T>, TD>;
 
 /**
- * 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.
+ * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
+ * supporting both built-in system types and custom external types.
+ *
+ * This factory allows external consumers to extend the qualifier type system with their own custom types
+ * while maintaining support for all built-in types (Language, Territory, Literal).
+ *
+ * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
+ *
+ * @example Creating a factory with custom qualifier types
+ * ```typescript
+ * // Define a custom qualifier type
+ * class CustomQualifierType extends QualifierType {
+ *   // ... implementation
+ * }
+ *
+ * // Define a discriminated union of all types
+ * type AppQualifierType = SystemQualifierType | CustomQualifierType;
+ *
+ * // Create a factory that handles custom types
+ * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
+ *   create(config) {
+ *     // ... handle custom type creation
+ *   }
+ * };
+ *
+ * // Create the combined factory
+ * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
+ *
+ * // The factory returns T | SystemQualifierType, supporting all types
+ * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
+ * ```
+ *
+ * @remarks
+ * - The factory chains custom factories with the built-in factory
+ * - Custom factories are tried first, falling back to built-in types
+ * - The return type is a union of custom types (T) and system types
+ *
  * @public
  */
-declare class QualifierTypeFactory extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+declare class QualifierTypeFactory<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
     /**
      * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
-     * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
-     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
      */
-    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>[]);
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
 }
 
+/**
+ * Function signature for creating a qualifier type from configuration.
+ * @public
+ */
+declare type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (config: QualifierTypes.Config.IAnyQualifierTypeConfig) => Result<T>;
+
 /**
  * Branded number representing a validated qualifier type index.
  * @public
@@ -7532,7 +7604,8 @@ declare namespace QualifierTypes {
         QualifierTypeCollector,
         ReadOnlyQualifierTypeCollector,
         createQualifierTypeFromConfig,
-        createQualifierTypeFromSystemConfig
+        createQualifierTypeFromSystemConfig,
+        SystemQualifierType
     }
 }
 export { QualifierTypes }
@@ -9205,7 +9278,7 @@ declare class ResourceTypeCollector extends ValidatingCollector<ResourceType> {
  * @returns A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
  * @public
  */
-declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig, unknown>;
+declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig<JsonObject>, unknown>;
 
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
@@ -9215,12 +9288,21 @@ declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig, unknown>;
 declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
-    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
 }
 
+/**
+ * Function signature for creating a resource type from configuration.
+ * @public
+ */
+declare type ResourceTypeFactoryFunction = (config: ResourceTypes.Config.IResourceTypeConfig) => Result<ResourceType>;
+
 /**
  * Branded number representing a validated resource type index.
  * @public
@@ -9518,6 +9600,14 @@ declare const systemLanguageQualifierTypeConfig: ObjectConverter<Model_2.ISystem
  */
 declare const systemLiteralQualifierTypeConfig: ObjectConverter<Model_2.ISystemLiteralQualifierTypeConfig, unknown>;
 
+/**
+ * A discriminated union of all system qualifier types.
+ * This allows TypeScript to properly discriminate between specific qualifier type implementations
+ * and access their specific methods like getConfiguration().
+ * @public
+ */
+declare type SystemQualifierType = LanguageQualifierType | TerritoryQualifierType | LiteralQualifierType;
+
 /**
  * A `Converter` for {@link QualifierTypes.Config.ISystemQualifierTypeConfig | SystemQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ISystemQualifierTypeConfig | SystemQualifierTypeConfig} objects.
@@ -9561,7 +9651,7 @@ declare const TerritoryPrioritySystemConfiguration: ISystemConfiguration;
  * implementation handles incorrect casing.
  * @public
  */
-declare class TerritoryQualifierType extends QualifierType {
+declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config_2.ITerritoryQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -9608,17 +9698,19 @@ declare class TerritoryQualifierType extends QualifierType {
      */
     static createFromConfig(config: Config_2.IQualifierTypeConfig<Config_2.ITerritoryQualifierTypeConfig>): Result<TerritoryQualifierType>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
     getConfiguration(): Result<Config_2.ISystemTerritoryQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config_2.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.
@@ -10048,6 +10140,77 @@ declare function validateSystemConfiguration(config: unknown): Result<ISystemCon
  */
 declare function validateZipArchiveManifest(manifest: unknown): Result<Json_2.IZipArchiveManifest>;
 
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+declare class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType> implements IConfigInitFactory<unknown, T | SystemQualifierType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config: unknown): Result<T | SystemQualifierType>;
+}
+
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+declare class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config: unknown): Result<ResourceType>;
+}
+
 /**
  * A {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} with a
  * {@link Runtime.Context.ContextQualifierProviderValidator | validator} property that enables

package/lib/packlets/config/configInitFactory.d.ts

@@ -1,8 +1,18 @@
 import { Result } from '@fgv/ts-utils';
-import { QualifierType } from '../qualifier-types';
+import { QualifierType, SystemQualifierType } from '../qualifier-types';
 import * as QualifierTypes from '../qualifier-types';
 import * as ResourceTypes from '../resource-types';
 import { ResourceType } from '../resource-types';
+/**
+ * Function signature for creating a qualifier type from configuration.
+ * @public
+ */
+export type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (config: QualifierTypes.Config.IAnyQualifierTypeConfig) => Result<T>;
+/**
+ * Function signature for creating a resource type from configuration.
+ * @public
+ */
+export type ResourceTypeFactoryFunction = (config: ResourceTypes.Config.IResourceTypeConfig) => Result<ResourceType>;
 /**
  * Interface for a factory that creates a new instance of a configuration object.
  * @public
@@ -15,6 +25,20 @@ export interface IConfigInitFactory<TConfig, T> {
      */
     create(config: TConfig): Result<T>;
 }
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export declare function createQualifierTypeFactory<T extends QualifierType = QualifierType>(fn: QualifierTypeFactoryFunction<T>): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>;
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export declare function createResourceTypeFactory(fn: ResourceTypeFactoryFunction): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 /**
  * A factory that chains multiple factories together.
  * @public
@@ -34,25 +58,110 @@ export declare class ChainedConfigInitFactory<TConfig, T> implements IConfigInit
     create(config: TConfig): Result<T>;
 }
 /**
- * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
+ * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
+ * if successful, `Failure` with an error message otherwise.
  * @public
  */
-export declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+export declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.ISystemQualifierTypeConfig, SystemQualifierType> {
     /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<QualifierType>;
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType>;
 }
 /**
- * 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.
+ * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
+ * supporting both built-in system types and custom external types.
+ *
+ * This factory allows external consumers to extend the qualifier type system with their own custom types
+ * while maintaining support for all built-in types (Language, Territory, Literal).
+ *
+ * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
+ *
+ * @example Creating a factory with custom qualifier types
+ * ```typescript
+ * // Define a custom qualifier type
+ * class CustomQualifierType extends QualifierType {
+ *   // ... implementation
+ * }
+ *
+ * // Define a discriminated union of all types
+ * type AppQualifierType = SystemQualifierType | CustomQualifierType;
+ *
+ * // Create a factory that handles custom types
+ * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
+ *   create(config) {
+ *     // ... handle custom type creation
+ *   }
+ * };
+ *
+ * // Create the combined factory
+ * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
+ *
+ * // The factory returns T | SystemQualifierType, supporting all types
+ * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
+ * ```
+ *
+ * @remarks
+ * - The factory chains custom factories with the built-in factory
+ * - Custom factories are tried first, falling back to built-in types
+ * - The return type is a union of custom types (T) and system types
+ *
  * @public
  */
-export declare class QualifierTypeFactory extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+export declare class QualifierTypeFactory<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
     /**
      * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
-     * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
-     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+}
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+export declare class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType> implements IConfigInitFactory<unknown, T | SystemQualifierType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      */
-    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>[]);
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config: unknown): Result<T | SystemQualifierType>;
 }
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
@@ -70,9 +179,39 @@ export declare class BuiltInResourceTypeFactory implements IConfigInitFactory<Re
 export declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
-    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+}
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+export declare class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config: unknown): Result<ResourceType>;
 }
 //# sourceMappingURL=configInitFactory.d.ts.map

package/lib/packlets/config/configInitFactory.js

@@ -54,10 +54,34 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceTypeFactory = exports.BuiltInResourceTypeFactory = exports.QualifierTypeFactory = exports.BuiltInQualifierTypeFactory = exports.ChainedConfigInitFactory = void 0;
+exports.ValidatingResourceTypeFactory = exports.ResourceTypeFactory = exports.BuiltInResourceTypeFactory = exports.ValidatingQualifierTypeFactory = exports.QualifierTypeFactory = exports.BuiltInQualifierTypeFactory = exports.ChainedConfigInitFactory = void 0;
+exports.createQualifierTypeFactory = createQualifierTypeFactory;
+exports.createResourceTypeFactory = createResourceTypeFactory;
 const ts_utils_1 = require("@fgv/ts-utils");
 const QualifierTypes = __importStar(require("../qualifier-types"));
 const ResourceTypes = __importStar(require("../resource-types"));
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+function createQualifierTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+function createResourceTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
 /**
  * A factory that chains multiple factories together.
  * @public
@@ -87,7 +111,10 @@ class ChainedConfigInitFactory {
 }
 exports.ChainedConfigInitFactory = ChainedConfigInitFactory;
 /**
- * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
+ * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
+ * if successful, `Failure` with an error message otherwise.
  * @public
  */
 class BuiltInQualifierTypeFactory {
@@ -101,21 +128,112 @@ class BuiltInQualifierTypeFactory {
 }
 exports.BuiltInQualifierTypeFactory = BuiltInQualifierTypeFactory;
 /**
- * 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.
+ * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
+ * supporting both built-in system types and custom external types.
+ *
+ * This factory allows external consumers to extend the qualifier type system with their own custom types
+ * while maintaining support for all built-in types (Language, Territory, Literal).
+ *
+ * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
+ *
+ * @example Creating a factory with custom qualifier types
+ * ```typescript
+ * // Define a custom qualifier type
+ * class CustomQualifierType extends QualifierType {
+ *   // ... implementation
+ * }
+ *
+ * // Define a discriminated union of all types
+ * type AppQualifierType = SystemQualifierType | CustomQualifierType;
+ *
+ * // Create a factory that handles custom types
+ * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
+ *   create(config) {
+ *     // ... handle custom type creation
+ *   }
+ * };
+ *
+ * // Create the combined factory
+ * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
+ *
+ * // The factory returns T | SystemQualifierType, supporting all types
+ * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
+ * ```
+ *
+ * @remarks
+ * - The factory chains custom factories with the built-in factory
+ * - Custom factories are tried first, falling back to built-in types
+ * - The return type is a union of custom types (T) and system types
+ *
  * @public
  */
 class QualifierTypeFactory extends ChainedConfigInitFactory {
     /**
      * 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.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
      */
     constructor(factories) {
-        super([...factories, new BuiltInQualifierTypeFactory()]);
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createQualifierTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInQualifierTypeFactory()]);
     }
 }
 exports.QualifierTypeFactory = QualifierTypeFactory;
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+class ValidatingQualifierTypeFactory {
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new QualifierTypeFactory(factories);
+    }
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config) {
+        return QualifierTypes.Config.Convert.anyQualifierTypeConfig
+            .convert(config)
+            .onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+exports.ValidatingQualifierTypeFactory = ValidatingQualifierTypeFactory;
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
  * @public
@@ -135,13 +253,50 @@ exports.BuiltInResourceTypeFactory = BuiltInResourceTypeFactory;
 class ResourceTypeFactory extends ChainedConfigInitFactory {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
     constructor(factories) {
         factories = factories !== null && factories !== void 0 ? factories : [];
-        super([...factories, new BuiltInResourceTypeFactory()]);
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createResourceTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInResourceTypeFactory()]);
     }
 }
 exports.ResourceTypeFactory = ResourceTypeFactory;
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+class ValidatingResourceTypeFactory {
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new ResourceTypeFactory(factories);
+    }
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config) {
+        return ResourceTypes.Config.Convert.resourceTypeConfig.convert(config).onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+exports.ValidatingResourceTypeFactory = ValidatingResourceTypeFactory;
 //# sourceMappingURL=configInitFactory.js.map

package/lib/packlets/qualifier-types/config/json.d.ts

@@ -24,7 +24,7 @@ export interface ILanguageQualifierTypeConfig {
  * determine the relationship between values when matching conditions and contexts.
  * @public
  */
-export type LiteralValueHierarchyDecl<T extends string> = Partial<Record<T, T>>;
+export type LiteralValueHierarchyDecl<T extends string> = Record<T, T>;
 /**
  * Configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.
  * @public

package/lib/packlets/qualifier-types/convert.d.ts

@@ -16,7 +16,7 @@ export interface IQualifierTypeConvertContext {
  * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.
  * @public
  */
-export declare const qualifierType: Converter<QualifierType, IQualifierTypeConvertContext>;
+export declare const qualifierType: Converter<QualifierType<import("@fgv/ts-json-base").JsonObject>, IQualifierTypeConvertContext>;
 /**
  * Gets a converter for {@link QualifierTypes.ILiteralValueHierarchyCreateParams | ILiteralValueHierarchyCreateParams}
  * objects with values validated by a supplied value converter.

package/lib/packlets/qualifier-types/helpers.d.ts

@@ -1,6 +1,16 @@
 import { Result } from '@fgv/ts-utils';
 import * as Config from './config';
 import { QualifierType } from './qualifierType';
+import { LanguageQualifierType } from './languageQualifierType';
+import { TerritoryQualifierType } from './territoryQualifierType';
+import { LiteralQualifierType } from './literalQualifierType';
+/**
+ * A discriminated union of all system qualifier types.
+ * This allows TypeScript to properly discriminate between specific qualifier type implementations
+ * and access their specific methods like getConfiguration().
+ * @public
+ */
+export type SystemQualifierType = LanguageQualifierType | TerritoryQualifierType | LiteralQualifierType;
 /**
  * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
@@ -13,14 +23,14 @@ import { QualifierType } from './qualifierType';
  */
 export declare function createQualifierTypeFromConfig(typeConfig: Config.IAnyQualifierTypeConfig): Result<QualifierType>;
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-export declare function createQualifierTypeFromSystemConfig(typeConfig: Config.ISystemQualifierTypeConfig): Result<QualifierType>;
+export declare function createQualifierTypeFromSystemConfig(typeConfig: Config.ISystemQualifierTypeConfig): Result<SystemQualifierType>;
 //# sourceMappingURL=helpers.d.ts.map

package/lib/packlets/qualifier-types/helpers.js

@@ -93,12 +93,12 @@ function createQualifierTypeFromConfig(typeConfig) {
     }
 }
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */

package/lib/packlets/qualifier-types/languageQualifierType.d.ts

@@ -2,7 +2,7 @@ import { Result } from '@fgv/ts-utils';
 import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore, QualifierTypeName } from '../common';
 import { IQualifierTypeCreateParams, QualifierType } from './qualifierType';
 import * as Config from './config';
-import { JsonObject } from '@fgv/ts-json-base';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Interface defining the parameters that can be used to create a new
  * {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}.
@@ -25,7 +25,7 @@ export interface ILanguageQualifierTypeCreateParams extends Partial<IQualifierTy
  * Accepts a list of language tags in the context by default.
  * @public
  */
-export declare class LanguageQualifierType extends QualifierType {
+export declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config.ILanguageQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -68,11 +68,11 @@ export declare class LanguageQualifierType extends QualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemLanguageQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemLanguageQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.

package/lib/packlets/qualifier-types/languageQualifierType.js

@@ -146,9 +146,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from) {
-        return Config.Convert.systemLanguageQualifierTypeConfig
-            .convert(from)
-            .onSuccess((config) => (0, ts_utils_1.succeed)(config));
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
     }
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
@@ -157,7 +155,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
      * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
      */
     validateConfiguration(from) {
-        return this.validateConfigurationJson(from).onSuccess((json) => Config.Convert.systemLanguageQualifierTypeConfig.convert(json));
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
     }
     /**
      * Matches a single language condition against a single language context value using

package/lib/packlets/qualifier-types/literalQualifierType.d.ts

@@ -3,7 +3,7 @@ import { ConditionOperator, QualifierConditionValue, QualifierContextValue, Qual
 import { QualifierType } from './qualifierType';
 import { LiteralValueHierarchy } from './literalValueHierarchy';
 import * as Config from './config';
-import { JsonObject } from '@fgv/ts-json-base';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Interface defining the parameters that can be used to create a new
  * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
@@ -44,7 +44,7 @@ export interface ILiteralQualifierTypeCreateParams {
  * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
-export declare class LiteralQualifierType extends QualifierType {
+export declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config.ILiteralQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -93,11 +93,11 @@ export declare class LiteralQualifierType extends QualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemLiteralQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemLiteralQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.

package/lib/packlets/qualifier-types/literalQualifierType.js

@@ -155,9 +155,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from) {
-        return Config.Convert.systemLiteralQualifierTypeConfig
-            .convert(from)
-            .onSuccess((config) => (0, ts_utils_1.succeed)(config));
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
     }
     /**
      * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
@@ -166,7 +164,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
      * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
      */
     validateConfiguration(from) {
-        return this.validateConfigurationJson(from).onSuccess((json) => Config.Convert.systemLiteralQualifierTypeConfig.convert(json));
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
     }
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}

package/lib/packlets/qualifier-types/literalValueHierarchy.d.ts

@@ -17,7 +17,7 @@ export interface ILiteralValue<T extends string> {
  */
 export interface ILiteralValueHierarchyCreateParams<T extends string = string> {
     values: ReadonlyArray<T>;
-    hierarchy?: LiteralValueHierarchyDecl<T>;
+    hierarchy?: Partial<LiteralValueHierarchyDecl<T>>;
 }
 /**
  * A class that implements a hierarchy of literal values. The hierarchy is defined as a

package/lib/packlets/qualifier-types/qualifierType.d.ts

@@ -1,13 +1,14 @@
 import { Collections, ICollectible, Result } from '@fgv/ts-utils';
 import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore, QualifierTypeIndex, QualifierTypeName } from '../common';
-import { JsonObject } from '@fgv/ts-json-base';
+import { JsonCompatible, JsonObject } from '@fgv/ts-json-base';
+import * as Config from './config';
 /**
  * Interface for a qualifier type. A qualifier type implements the build and
  * runtime semantics for some class of related qualifiers (e.g. language,
  * territories, etc).
  * @public
  */
-export interface IQualifierType extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
+export interface IQualifierType<TCFGJSON extends JsonObject = JsonObject> extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
     /**
      * The name of the qualifier type.
      */
@@ -82,13 +83,13 @@ export interface IQualifierType extends ICollectible<QualifierTypeName, Qualifie
      * Gets the configuration for this qualifier type.
      * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * Validates configuration JSON data for this qualifier type.
      * @param from - The unknown data to validate as configuration JSON.
      * @returns `Success` with validated JSON configuration if valid, `Failure` with an error message otherwise.
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
 }
 /**
  * Parameters used to create a base {@link QualifierTypes.QualifierType | qualifier type}.
@@ -114,7 +115,7 @@ export interface IQualifierTypeCreateParams {
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-export declare abstract class QualifierType implements IQualifierType {
+export declare abstract class QualifierType<TCFGJSON extends JsonObject = JsonObject> implements IQualifierType<TCFGJSON> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.name}
      */
@@ -171,11 +172,11 @@ export declare abstract class QualifierType implements IQualifierType {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    abstract getConfigurationJson(): Result<JsonObject>;
+    abstract getConfigurationJson(): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    abstract validateConfigurationJson(from: unknown): Result<JsonObject>;
+    abstract validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
      */

package/lib/packlets/qualifier-types/territoryQualifierType.d.ts

@@ -3,7 +3,7 @@ import { QualifierConditionValue, QualifierContextValue, QualifierMatchScore, Co
 import { QualifierType } from './qualifierType';
 import { LiteralValueHierarchy } from './literalValueHierarchy';
 import * as Config from './config';
-import { JsonObject } from '@fgv/ts-json-base';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
  * @public
@@ -42,7 +42,7 @@ export interface ITerritoryQualifierTypeCreateParams {
  * implementation handles incorrect casing.
  * @public
  */
-export declare class TerritoryQualifierType extends QualifierType {
+export declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config.ITerritoryQualifierTypeConfig>> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
      */
@@ -89,17 +89,19 @@ export declare class TerritoryQualifierType extends QualifierType {
      */
     static createFromConfig(config: Config.IQualifierTypeConfig<Config.ITerritoryQualifierTypeConfig>): Result<TerritoryQualifierType>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
     getConfiguration(): Result<Config.ISystemTerritoryQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
-    getConfigurationJson(): Result<JsonObject>;
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
-    validateConfigurationJson(from: unknown): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemTerritoryQualifierTypeConfig>>;
     /**
      * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
      * for this qualifier type.

package/lib/packlets/qualifier-types/territoryQualifierType.js

@@ -147,7 +147,9 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
         }).onSuccess(TerritoryQualifierType.create);
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
      */
     getConfiguration() {
         return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemTerritoryQualifierTypeConfig.convert(json));
@@ -170,9 +172,7 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from) {
-        return Config.Convert.systemTerritoryQualifierTypeConfig
-            .convert(from)
-            .onSuccess((config) => (0, ts_utils_1.succeed)(config));
+        return Config.Convert.systemTerritoryQualifierTypeConfig.convert(from);
     }
     /**
      * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}

package/lib/packlets/resource-types/config/convert.d.ts

@@ -4,5 +4,5 @@ import { IResourceTypeConfig } from './json';
  * @returns A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
  * @public
  */
-export declare const resourceTypeConfig: import("@fgv/ts-utils").ObjectConverter<IResourceTypeConfig, unknown>;
+export declare const resourceTypeConfig: import("@fgv/ts-utils").ObjectConverter<IResourceTypeConfig<import("@fgv/ts-json-base").JsonObject>, unknown>;
 //# sourceMappingURL=convert.d.ts.map

package/lib/packlets/resource-types/config/json.d.ts

@@ -3,9 +3,9 @@ import { JsonObject } from '@fgv/ts-json-base';
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
  */
-export interface IResourceTypeConfig {
+export interface IResourceTypeConfig<T extends JsonObject = JsonObject> {
     name: string;
     typeName: string;
-    template?: JsonObject;
+    template?: T;
 }
 //# sourceMappingURL=json.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-res",
-  "version": "5.0.0-27",
+  "version": "5.0.0-29",
   "description": "Multi-dimensional Resource Runtime",
   "main": "lib/index.js",
   "types": "dist/ts-res.d.ts",
@@ -44,16 +44,16 @@
     "@rushstack/heft-node-rig": "2.9.5",
     "@types/heft-jest": "1.0.6",
     "eslint-plugin-tsdoc": "~0.4.0",
-    "@fgv/ts-utils-jest": "5.0.0-27",
-    "@fgv/ts-extras": "5.0.0-27"
+    "@fgv/ts-utils-jest": "5.0.0-29",
+    "@fgv/ts-extras": "5.0.0-29"
   },
   "dependencies": {
     "luxon": "^3.7.2",
     "fflate": "~0.8.2",
-    "@fgv/ts-utils": "5.0.0-27",
-    "@fgv/ts-bcp47": "5.0.0-27",
-    "@fgv/ts-json-base": "5.0.0-27",
-    "@fgv/ts-json": "5.0.0-27"
+    "@fgv/ts-utils": "5.0.0-29",
+    "@fgv/ts-json-base": "5.0.0-29",
+    "@fgv/ts-bcp47": "5.0.0-29",
+    "@fgv/ts-json": "5.0.0-29"
   },
   "scripts": {
     "build": "heft build --clean",