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

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

@@ -0,0 +1,217 @@
+import { Result } from '@fgv/ts-utils';
+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
+ */
+export interface IConfigInitFactory<TConfig, T> {
+    /**
+     * Creates a new instance of a configuration object.
+     * @param config - The configuration object to create.
+     * @returns A result containing the new instance of the configuration object.
+     */
+    create(config: TConfig): Result<T>;
+}
+/**
+ * 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
+ */
+export declare class ChainedConfigInitFactory<TConfig, T> implements IConfigInitFactory<TConfig, T> {
+    readonly factories: IConfigInitFactory<TConfig, T>[];
+    /**
+     * Constructor for a chained config init factory.
+     * @param factories - The factories to chain.
+     */
+    constructor(factories: IConfigInitFactory<TConfig, T>[]);
+    /**
+     * Creates a new instance of a configuration object.
+     * @param config - The configuration object to create.
+     * @returns A result containing the new instance of the configuration object.
+     */
+    create(config: TConfig): Result<T>;
+}
+/**
+ * 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.ISystemQualifierTypeConfig, SystemQualifierType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType>;
+}
+/**
+ * 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<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+}
+/**
+ * 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: 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}.
+ * @public
+ */
+export declare class BuiltInResourceTypeFactory implements IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: ResourceTypes.Config.IResourceTypeConfig): Result<ResourceType>;
+}
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
+ * @public
+ */
+export declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
+    /**
+     * Constructor for a resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+}
+/**
+ * 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

@@ -0,0 +1,302 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ */
+class ChainedConfigInitFactory {
+    /**
+     * Constructor for a chained config init factory.
+     * @param factories - The factories to chain.
+     */
+    constructor(factories) {
+        this.factories = factories;
+    }
+    /**
+     * Creates a new instance of a configuration object.
+     * @param config - The configuration object to create.
+     * @returns A result containing the new instance of the configuration object.
+     */
+    create(config) {
+        for (const factory of this.factories) {
+            const result = factory.create(config);
+            if (result.isSuccess()) {
+                return result;
+            }
+        }
+        return (0, ts_utils_1.fail)('No factory was able to create the configuration object');
+    }
+}
+exports.ChainedConfigInitFactory = ChainedConfigInitFactory;
+/**
+ * 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 {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config) {
+        if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {
+            return QualifierTypes.createQualifierTypeFromSystemConfig(config);
+        }
+        return (0, ts_utils_1.fail)(`${config.name}: unknown built-in qualifier type (${config.systemType})`);
+    }
+}
+exports.BuiltInQualifierTypeFactory = BuiltInQualifierTypeFactory;
+/**
+ * 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 - 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) {
+        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
+ */
+class BuiltInResourceTypeFactory {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config) {
+        return ResourceTypes.createResourceTypeFromConfig(config);
+    }
+}
+exports.BuiltInResourceTypeFactory = BuiltInResourceTypeFactory;
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
+ * @public
+ */
+class ResourceTypeFactory extends ChainedConfigInitFactory {
+    /**
+     * Constructor for a resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories) {
+        factories = factories !== null && factories !== void 0 ? factories : [];
+        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/config/convert.d.ts

@@ -1,3 +1,4 @@
+import { Result } from '@fgv/ts-utils';
 import { ISystemConfiguration } from './json';
 /**
  * A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
@@ -11,4 +12,12 @@ export declare const systemConfiguration: import("@fgv/ts-utils").ObjectConverte
  * @public
  */
 export declare const predefinedSystemConfiguration: import("@fgv/ts-utils").Converter<import("./common").PredefinedSystemConfiguration, readonly import("./common").PredefinedSystemConfiguration[]>;
+/**
+ * Validate a {@link Config.Model.ISystemConfiguration | ISystemConfiguration} object.
+ * @param config - The system configuration to validate
+ * @returns `Success` with the validated system configuration if successful,
+ * or `Failure` with an error message if validation fails.
+ * @public
+ */
+export declare function validateSystemConfiguration(config: unknown): Result<ISystemConfiguration>;
 //# sourceMappingURL=convert.d.ts.map

package/lib/packlets/config/convert.js

@@ -55,6 +55,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.predefinedSystemConfiguration = exports.systemConfiguration = void 0;
+exports.validateSystemConfiguration = validateSystemConfiguration;
 /* eslint-disable @rushstack/typedef-var */
 const ts_utils_1 = require("@fgv/ts-utils");
 const QualifierTypes = __importStar(require("../qualifier-types"));
@@ -69,7 +70,7 @@ const common_1 = require("./common");
 exports.systemConfiguration = ts_utils_1.Converters.strictObject({
     name: ts_utils_1.Converters.optionalString,
     description: ts_utils_1.Converters.optionalString,
-    qualifierTypes: ts_utils_1.Converters.arrayOf(QualifierTypes.Config.Convert.systemQualifierTypeConfig),
+    qualifierTypes: ts_utils_1.Converters.arrayOf(QualifierTypes.Config.Convert.anyQualifierTypeConfig),
     qualifiers: ts_utils_1.Converters.arrayOf(Qualifiers.Convert.qualifierDecl),
     resourceTypes: ts_utils_1.Converters.arrayOf(ResourceTypes.Config.Convert.resourceTypeConfig)
 });
@@ -79,4 +80,14 @@ exports.systemConfiguration = ts_utils_1.Converters.strictObject({
  * @public
  */
 exports.predefinedSystemConfiguration = ts_utils_1.Converters.enumeratedValue(common_1.allPredefinedSystemConfigurations);
+/**
+ * Validate a {@link Config.Model.ISystemConfiguration | ISystemConfiguration} object.
+ * @param config - The system configuration to validate
+ * @returns `Success` with the validated system configuration if successful,
+ * or `Failure` with an error message if validation fails.
+ * @public
+ */
+function validateSystemConfiguration(config) {
+    return exports.systemConfiguration.convert(config);
+}
 //# sourceMappingURL=convert.js.map

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

@@ -1,5 +1,6 @@
 import * as Model from './json';
 import * as Convert from './convert';
+export * from './configInitFactory';
 export * from './systemConfiguration';
 export * from './common';
 export { Model, Convert };

package/lib/packlets/config/index.js

@@ -62,6 +62,7 @@ const Model = __importStar(require("./json"));
 exports.Model = Model;
 const Convert = __importStar(require("./convert"));
 exports.Convert = Convert;
+__exportStar(require("./configInitFactory"), exports);
 __exportStar(require("./systemConfiguration"), exports);
 __exportStar(require("./common"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -11,7 +11,7 @@ export interface ISystemConfiguration {
     /** Optional description explaining the purpose and use case of the configuration. */
     description?: string;
     /** Qualifier type configurations that define the available qualifier types in the system. */
-    qualifierTypes: QualifierTypes.Config.ISystemQualifierTypeConfig[];
+    qualifierTypes: QualifierTypes.Config.IAnyQualifierTypeConfig[];
     /** Qualifier declarations that define the available qualifiers in the system. */
     qualifiers: Qualifiers.IQualifierDecl[];
     /** Resource type configurations that define the available resource types in the system. */

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

@@ -1,8 +1,11 @@
 import { Result } from '@fgv/ts-utils';
-import { ReadOnlyQualifierTypeCollector } from '../qualifier-types';
+import * as QualifierTypes from '../qualifier-types';
+import * as ResourceTypes from '../resource-types';
+import { QualifierType, ReadOnlyQualifierTypeCollector } from '../qualifier-types';
 import { IReadOnlyQualifierCollector } from '../qualifiers';
-import { ReadOnlyResourceTypeCollector } from '../resource-types';
+import { ReadOnlyResourceTypeCollector, ResourceType } from '../resource-types';
 import { ISystemConfiguration } from './json';
+import { IConfigInitFactory } from './configInitFactory';
 /**
  * Parameters used to initialize a {@link Config.SystemConfiguration | SystemConfiguration}.
  * @public
@@ -14,6 +17,8 @@ export interface ISystemConfigurationInitParams {
      * Use `null` as the value to remove an existing default value.
      */
     qualifierDefaultValues?: Record<string, string | null>;
+    qualifierTypeFactory?: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>;
+    resourceTypeFactory?: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 }
 /**
  * Creates a copy of the provided {@link Config.Model.ISystemConfiguration | system configuration}
@@ -58,7 +63,7 @@ export declare class SystemConfiguration {
      * @param config - The {@link Config.Model.ISystemConfiguration | system configuration} to use.
      * @public
      */
-    protected constructor(config: ISystemConfiguration);
+    protected constructor(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams);
     /**
      * Creates a new {@link Config.SystemConfiguration | SystemConfiguration} from the supplied
      * {@link Config.Model.ISystemConfiguration | system configuration}.
@@ -69,6 +74,14 @@ export declare class SystemConfiguration {
      * @public
      */
     static create(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
+    /**
+     * Loads a {@link Config.SystemConfiguration | SystemConfiguration} from a file.
+     * @param path - The path to the file to load.
+     * @returns `Success` with the {@link Config.SystemConfiguration | SystemConfiguration}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static loadFromFile(path: string, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
     /**
      * Returns the {@link Config.Model.ISystemConfiguration | system configuration} that this
      * {@link Config.SystemConfiguration | SystemConfiguration} was created from.