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

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>;
 }
 
 /**
@@ -2358,16 +2362,16 @@ 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 ResourceTypes.ResourceType | ResourceType} from a configuration object.
@@ -4144,7 +4148,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 +4578,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 +4653,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 +5469,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 +6276,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 +6319,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 +6354,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 +6403,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 +6568,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 +7329,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 +7386,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 +7446,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,17 +7479,54 @@ 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 {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     *                    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: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>[]);
 }
 
 /**
@@ -7532,7 +7573,8 @@ declare namespace QualifierTypes {
         QualifierTypeCollector,
         ReadOnlyQualifierTypeCollector,
         createQualifierTypeFromConfig,
-        createQualifierTypeFromSystemConfig
+        createQualifierTypeFromSystemConfig,
+        SystemQualifierType
     }
 }
 export { QualifierTypes }
@@ -9205,7 +9247,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}
@@ -9518,6 +9560,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 +9611,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 +9658,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.

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

@@ -1,5 +1,5 @@
 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';
@@ -34,25 +34,65 @@ 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 {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     *                    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: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>[]);
 }
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.

package/lib/packlets/config/configInitFactory.js

@@ -87,7 +87,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,15 +104,52 @@ 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 {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     *                    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()]);

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-28",
   "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-extras": "5.0.0-28",
+    "@fgv/ts-utils-jest": "5.0.0-28"
   },
   "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-json-base": "5.0.0-28",
+    "@fgv/ts-bcp47": "5.0.0-28",
+    "@fgv/ts-utils": "5.0.0-28",
+    "@fgv/ts-json": "5.0.0-28"
   },
   "scripts": {
     "build": "heft build --clean",